cdsl-cad/cadfs_to_cdsl/lowering.py

from __future__ import annotations

import math
from copy import deepcopy
from dataclasses import dataclass
from typing import Any
from .featurescript_parser import symbolic_string
from .ir import Call, FeatureIR, ModelIR, SketchIR
from .query_parser import parse_query, query_expr, walk_calls


UNSUPPORTED = {"draft", "thicken", "split", "moveFace", "replaceFace", "deleteFace", "import", "derive"}

# The parser preserves every direct ``operation(context, id + "F...", ...)``
# call. Keep lowering's executable surface explicit so newly observed source
# APIs get a stable unsupported-operation diagnostic rather than disappearing
# from history or falling through to an incidental implementation error.
LOWERABLE_OPERATIONS = {
    "assignVariable", "transform", "deleteBodies", "cPoint", "cPlane", "extrude", "loft", "sweep",
    "booleanBodies", "revolve", "fillet", "chamfer", "shell", "hole",
    "circularPattern", "mirror",
}
PLANES = {
    "Top": {"origin_mm": [0., 0., 0.], "x_dir": [1., 0., 0.], "normal": [0., 0., 1.]},
    "Front": {"origin_mm": [0., 0., 0.], "x_dir": [1., 0., 0.], "normal": [0., -1., 0.]},
    "Right": {"origin_mm": [0., 0., 0.], "x_dir": [0., 1., 0.], "normal": [1., 0., 0.]},
}


# CADFS 未携带标准孔表的实体定义。下列条目由 source STEP 验证：该组合在
# CADFS 的 B-rep 中不是普通 blind counterbore，而是简化为贯穿的攻丝孔。
# 不能为未知目录项推测尺寸；未列入的孔仍按显式 FeatureScript 尺寸 lower。
_STANDARD_TAPPED_THROUGH_BORE_DIAMETERS = {
    ("ISO", "M10", "Clearance & tapped"): 15.0,
}


@dataclass
class LoweringResult:
    cdsl: dict[str, Any] | None
    status: str
    diagnostics: list[dict[str, Any]]
    history: list[dict[str, Any]]


class UnsupportedCapability(ValueError):
    def __init__(self, capability: str, message: str):
        super().__init__(message); self.capability = capability


class OpenSketchProfileError(ValueError):
    pass


def plain(value: Any) -> Any:
    if isinstance(value, Call): return {"call": value.name, "args": [plain(arg) for arg in value.args], "line": value.line}
    if isinstance(value, list): return [plain(item) for item in value]
    if isinstance(value, dict): return {key: plain(item) for key, item in value.items()}
    return value


def _selector_intent(
    value: Any,
    *,
    query_family: str,
    kind: str,
    evidence: str,
    allowed: tuple[str, ...] = ("continuation",),
    multiplicity: str = "one",
    output_role: str | None = None,
    disambiguation: dict[str, Any] | None = None,
) -> dict[str, Any]:
    """Keep the source query as semantics, separate from runtime topology IDs."""
    query = parse_query(value)
    intent: dict[str, Any] = {
        "version": "1.0",
        "kind": kind,
        "query_family": query_family,
        # Version metadata is populated from the enclosing ModelIR only when
        # the exported source actually contains it.  ``"0"`` used to look
        # like a real FeatureScript version and caused downstream capability
        # checks to make an unjustified compatibility decision.
        "source_query": {"ast": query.ast},
        # Keep an executable-independent typed expression as well as the raw
        # source AST. This records set boundaries and filters without claiming
        # that an unsupported family can be resolved from geometry.
        "query_expr": query_expr(value),
        "derivation_policy": {"allowed": list(allowed), "multiplicity": multiplicity},
        "evidence": evidence,
    }
    if query.source_sketch and query.source_entity:
        intent["source_entity"] = {"sketch_id": query.source_sketch, "entity_id": query.source_entity}
    if output_role is not None:
        intent["output_role"] = output_role
    if disambiguation is not None:
        intent["disambiguation"] = disambiguation
    return intent


def _deferred_featurescript_selector_intent(value: Any, *, kind: str) -> dict[str, Any]:
    """Preserve an unsupported CADFS topology query without authorizing hints.

    Geometry remains useful diagnostic context, but it cannot be mistaken for
    an implementation of the source query.  A non-empty policy keeps the
    intent structurally valid while ``none`` makes the resolver reject it
    before stable-ID or geometry matching.
    """
    query = parse_query(value)
    try:
        _call, _owner, family, _query_kind, _definition = _direct_make_query(value)
    except ValueError:
        family = str(query.topology_type or "FEATURESCRIPT_QUERY").rsplit(".", 1)[-1].upper()
    if not family or not family.replace("_", "").isalnum() or not family[0].isalpha():
        family = "FEATURESCRIPT_QUERY"
    return _selector_intent(
        value,
        query_family=family,
        kind=kind,
        evidence="feature_script_query",
        allowed=("continuation",),
        multiplicity="none",
        disambiguation={
            "type": "deferred_source_query",
            "query_combinators": list(query.query_combinators),
            "filters": list(query.filters),
            "body_scope": list(query.body_scope),
            "source_refs": [
                {"sketch_id": sketch_id, "entity_id": entity_id}
                for sketch_id, entity_id in _source_refs(value)
            ],
        },
    )


def _explicit_datum_selector_intent(value: Any, *, kind: str) -> dict[str, Any]:
    """Mark a source datum as an explicit geometric, not lineage, selector."""
    return _selector_intent(
        value,
        query_family="GEOMETRIC",
        kind=kind,
        evidence="explicit_datum",
    )


def _finalize_selector_intents(cdsl: dict[str, Any], model: ModelIR) -> None:
    """Bind source-version metadata for top-level and nested selectors."""
    source_version = model.featurescript_version
    stack: list[Any] = [cdsl]
    while stack:
        value = stack.pop()
        if isinstance(value, list):
            stack.extend(value)
            continue
        if not isinstance(value, dict):
            continue
        intent = value.get("selector_intent")
        if isinstance(intent, dict):
            source_query = intent.get("source_query")
            if isinstance(source_query, dict):
                if source_version:
                    source_query["featurescript_version"] = source_version
                if model.standard_library:
                    source_query["standard_library"] = model.standard_library
                if model.standard_library_version:
                    source_query["standard_library_version"] = model.standard_library_version
                if model.standard_library_imports:
                    source_query["standard_library_imports"] = deepcopy(model.standard_library_imports)
        stack.extend(value.values())


def _bool(value: Any) -> bool:
    return value is True or (isinstance(value, str) and value.lower() == "true")


def _number(value: Any, units: bool = False) -> float:
    if isinstance(value, (float, int)): return float(value)
    if isinstance(value, str):
        constants = {"mm": 1., "millimeter": 1., "cm": 10., "m": 1000., "inch": 25.4, "in": 25.4, "ft": 304.8, "degree": 1.}
        if value in constants: return constants[value]
        return float(value)
    if isinstance(value, Call) and value.name == "__binary__":
        left, op, right = value.args; a, b = _number(left, units), _number(right, units)
        return {"+": a + b, "-": a - b, "*": a * b, "/": a / b}[str(op)]
    if isinstance(value, Call) and value.name == "round" and len(value.args) == 1:
        # CADFS sometimes serializes a known pattern count as ``round(8)``.
        # An already integral constant is provably unchanged, so it needs no
        # FeatureScript rounding-mode assumption. Non-integral calls remain
        # unsupported until that language-level semantic is represented.
        rounded_input = _number(value.args[0], units)
        if math.isfinite(rounded_input) and rounded_input.is_integer():
            return rounded_input
    raise ValueError(f"not a constant number: {plain(value)!r}")


def _resolve_source_variables(value: Any, variables: dict[str, Any]) -> Any:
    """Resolve exact earlier ``getVariable(context, name)`` source calls.

    CADFS variables are ordered context state, not topology. Lowering captures
    the declared expression before it can be consumed by geometry parameters;
    a missing or malformed lookup remains a deterministic source error rather
    than becoming a guessed numeric default.
    """
    if isinstance(value, Call):
        if value.name == "getVariable":
            if len(value.args) != 2 or value.args[0] != "context" or not isinstance(value.args[1], str):
                raise ValueError("getVariable must name one source context variable")
            name = value.args[1]
            if name not in variables:
                raise ValueError(f"source variable is unavailable: {name}")
            return deepcopy(variables[name])
        return Call(value.name, [_resolve_source_variables(argument, variables) for argument in value.args], value.line, value.raw)
    if isinstance(value, list):
        return [_resolve_source_variables(item, variables) for item in value]
    if isinstance(value, dict):
        return {key: _resolve_source_variables(item, variables) for key, item in value.items()}
    return value


def _assign_variable_params(params: dict[str, Any]) -> tuple[str, Any, dict[str, Any]]:
    """Lower the two exported scalar assignVariable forms without coercion."""
    name = params.get("name")
    if not isinstance(name, str) or not name:
        raise ValueError("assignVariable requires one non-empty source name")
    variants = [(key, params[key]) for key in ("anyValue", "lengthValue") if key in params]
    if len(variants) != 1:
        raise UnsupportedCapability(
            "assign_variable_value",
            "assignVariable requires exactly one anyValue or lengthValue source expression",
        )
    key, value = variants[0]
    numeric_value = _number(value, units=key == "lengthValue")
    if not math.isfinite(numeric_value):
        raise UnsupportedCapability("assign_variable_value", "assignVariable value must be finite")
    return name, value, {
        "name": name,
        "value": numeric_value,
        "value_kind": "length" if key == "lengthValue" else "any",
    }


def _lookup_table_definition(value: Any) -> dict[str, str]:
    for call in walk_calls(value):
        if call.name != "lookupTablePath" or not call.args or not isinstance(call.args[0], dict): continue
        return {str(key): str(item) for key, item in call.args[0].items() if isinstance(item, (str, int, float))}
    return {}


def _standard_tapped_through_bore_diameter(params: dict[str, Any], style: str, end_style: str) -> float | None:
    if style.upper() not in {"COUNTERBORE", "C_BORE"} or "BLIND" not in end_style or not _bool(params.get("isTappedThrough")):
        return None
    definition = _lookup_table_definition(params.get("standardBlindInLast"))
    return _STANDARD_TAPPED_THROUGH_BORE_DIAMETERS.get((definition.get("standard", ""), definition.get("size", ""), definition.get("type", "")))


def _point(value: Any) -> list[float]:
    if isinstance(value, Call) and value.name == "__binary__" and value.args[1] == "*":
        scale = _number(value.args[2], True); point = _point(value.args[0]); return [v * scale for v in point]
    if isinstance(value, Call) and value.name in {"v", "vector"} and len(value.args) >= 2:
        return [_number(value.args[0]), _number(value.args[1])]
    if isinstance(value, list) and len(value) >= 2: return [_number(value[0]), _number(value[1])]
    raise ValueError(f"not a 2D point: {plain(value)!r}")


def _cross(a: list[float], b: list[float]) -> list[float]:
    return [a[1]*b[2]-a[2]*b[1], a[2]*b[0]-a[0]*b[2], a[0]*b[1]-a[1]*b[0]]


def _dot(a: list[float], b: list[float]) -> float: return sum(left * right for left, right in zip(a, b))


def _unit(value: list[float], message: str) -> list[float]:
    length = math.sqrt(_dot(value, value))
    if length <= 1e-9: raise ValueError(message)
    return [component / length for component in value]


def _sub(a: list[float], b: list[float]) -> list[float]: return [a[index] - b[index] for index in range(3)]


def _rotate(value: list[float], axis: list[float], angle_rad: float) -> list[float]:
    axis = _unit(axis, "rotation axis is degenerate")
    cosine, sine = math.cos(angle_rad), math.sin(angle_rad)
    cross = _cross(axis, value); projection = _dot(axis, value) * (1.0 - cosine)
    return [value[index] * cosine + cross[index] * sine + axis[index] * projection for index in range(3)]


def _translate_frame(frame: dict[str, Any], offset: list[float]) -> dict[str, Any]:
    return {**frame, "origin_mm": [frame["origin_mm"][index] + offset[index] for index in range(3)]}


def _rotate_point(point: list[float], axis: dict[str, list[float]], angle_rad: float) -> list[float]:
    relative = _rotate(_sub(point, axis["origin_mm"]), axis["direction"], angle_rad)
    return [axis["origin_mm"][index] + relative[index] for index in range(3)]


def _rotate_frame(frame: dict[str, Any], axis: dict[str, list[float]], angle_rad: float) -> dict[str, Any]:
    return {
        **frame,
        "origin_mm": _rotate_point(frame["origin_mm"], axis, angle_rad),
        "x_dir": _rotate(frame["x_dir"], axis["direction"], angle_rad),
        "normal": _rotate(frame["normal"], axis["direction"], angle_rad),
    }


def _reflect_vector(value: list[float], plane: dict[str, Any]) -> list[float]:
    normal = _unit(list(plane["normal"]), "mirror plane normal is degenerate")
    amount = 2.0 * _dot(value, normal)
    return [value[index] - amount * normal[index] for index in range(3)]


def _reflect_point(point: list[float], plane: dict[str, Any]) -> list[float]:
    normal = _unit(list(plane["normal"]), "mirror plane normal is degenerate")
    amount = 2.0 * _dot(_sub(point, plane["origin_mm"]), normal)
    return [point[index] - amount * normal[index] for index in range(3)]


def _reflect_frame(frame: dict[str, Any], plane: dict[str, Any]) -> dict[str, Any]:
    return {
        **frame,
        "origin_mm": _reflect_point(frame["origin_mm"], plane),
        "x_dir": _reflect_vector(frame["x_dir"], plane),
        "normal": _reflect_vector(frame["normal"], plane),
    }


def _y_dir(plane: dict[str, Any]) -> list[float]: return _cross(plane["normal"], plane["x_dir"])


def _global(plane: dict[str, Any], point: list[float]) -> list[float]:
    y = _y_dir(plane); return [plane["origin_mm"][i] + plane["x_dir"][i]*point[0] + y[i]*point[1] for i in range(3)]


def _shift_plane(plane: dict[str, Any], distance: float) -> dict[str, Any]:
    return {**plane, "origin_mm": [plane["origin_mm"][i] + plane["normal"][i]*distance for i in range(3)]}


def _oriented_plane(plane: dict[str, Any], normal_sign: float, distance: float = 0.0) -> dict[str, Any]:
    shifted = _shift_plane(plane, distance)
    # 翻转端盖法向时同步翻转 x 轴，保持 normal × x_dir 的草图局部 y 轴
    # 不变。否则同一 CADFS 草图会在附着端盖后被镜像。
    return {
        **shifted,
        "x_dir": [normal_sign * value for value in plane["x_dir"]],
        "normal": [normal_sign * value for value in plane["normal"]],
    }


def _attachment_plane(plane: dict[str, Any]) -> dict[str, Any]:
    """Choose the global-origin projection as the later sketch attachment origin.

    CADFS keeps a plane's physical location and the plane coordinates used by
    a later sketch separate.  The latter is the global origin projected onto
    the physical plane, not necessarily the selected point or profile centre.
    Keep this only as an attachment frame; selectors and body topology
    continue to use the physical frame.
    """
    normal = plane["normal"]
    origin = plane["origin_mm"]
    distance = _dot(origin, normal)
    return {**plane, "origin_mm": [distance * normal[index] for index in range(3)]}


def _loft_cap_frames(start: dict[str, Any], end: dict[str, Any]) -> dict[str, dict[str, Any]] | None:
    """Record the physical outer normals for the first and last loft sections."""
    direction = _sub(end["origin_mm"], start["origin_mm"])
    if math.sqrt(_dot(direction, direction)) <= 1e-9:
        return None
    # Loft start/end caps face away from the section sequence. Sketch normals do
    # not necessarily have that orientation, so retain the CDSL frame handedness
    # while choosing the actual B-rep exterior normal for CAP references.
    start_sign = 1.0 if _dot(start["normal"], direction) <= 0 else -1.0
    end_sign = 1.0 if _dot(end["normal"], direction) >= 0 else -1.0
    return {"start": _oriented_plane(start, start_sign), "end": _oriented_plane(end, end_sign)}


def _frame(origin: list[float], x_dir: list[float], normal: list[float]) -> dict[str, list[float]]:
    normal = _unit(normal, "reference plane normal is degenerate")
    x_dir = _sub(x_dir, [normal[index] * _dot(x_dir, normal) for index in range(3)])
    return {"origin_mm": origin, "x_dir": _unit(x_dir, "reference plane x direction is degenerate"), "normal": normal}


def _pattern_copy_cap_plane(value: Any, feature_frames: dict[str, dict[str, Any]]) -> dict[str, Any] | None:
    """Resolve one mirrored COPY(CAP_FACE) frame without flattening its source query."""
    try:
        _call, pattern_owner, topology, kind, definition = _direct_make_query(value)
    except ValueError:
        return None
    if topology != "COPY" or kind != "face":
        return None
    derived = definition.get("derivedFrom")
    if derived is None:
        return None
    try:
        _source, source_owner, source_topology, source_kind, source_definition = _direct_make_query(derived)
    except ValueError:
        return None
    if source_topology != "CAP_FACE" or source_kind != "face":
        return None
    pattern_frame = feature_frames.get(pattern_owner) or {}
    transform = pattern_frame.get("copy_transform") or {}
    if transform.get("type") != "mirror" or source_owner not in pattern_frame.get("copy_source_features", []):
        return None
    source_frame = feature_frames.get(source_owner)
    if source_frame is None or "start" not in source_frame or "end" not in source_frame:
        return None
    cap = source_frame["start" if _bool(source_definition.get("isStart")) else "end"]
    plane = transform.get("plane")
    if not isinstance(plane, dict):
        return None
    reflected = _reflect_frame(cap, plane)
    # 镜像会把 source frame 变成左手系；CDSL workplane 必须始终由
    # normal × x_dir 推导局部 y 轴。翻转 x_dir 后，镜像 CAP 上新草图的
    # source-local y 方向保持物理不变，FeatureScript 导出的镜像侧 x 坐标
    # 也能落回正确的世界位置。
    reflected["x_dir"] = [-value for value in reflected["x_dir"]]
    return reflected


def _plane_from_query(
    value: Any,
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]] | None = None,
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]] | None = None,
) -> dict[str, Any]:
    for call in walk_calls(value):
        if call.name in {"makeId", "qCreatedBy"}:
            text = " ".join(symbolic_string(arg) for arg in call.args)
            for name, plane in PLANES.items():
                if f"{name}.planeOp" in text: return dict(plane)
    copied_cap = _pattern_copy_cap_plane(value, feature_frames)
    if copied_cap is not None:
        return copied_cap
    # Workplane materialization must follow the outer query expression. A
    # A derived topology query may contain a nested CAP/SWEPT face, but that
    # producer frame is not proof that the outer query has one active face
    # successor. ``parse_query`` visits nested calls for diagnostic context,
    # so it cannot define this boundary. The explicit mirrored COPY(CAP_FACE)
    # contract was handled above; COPY and MERGE workplanes both require a
    # dedicated runtime face relation before a sketch can attach to them.
    try:
        _call, owner, topology, outer_kind, _definition = _direct_make_query(value)
    except ValueError:
        owner = topology = outer_kind = None
    query = parse_query(value)
    direct_created_by = value
    if isinstance(direct_created_by, Call) and direct_created_by.name == "qUnion" and len(direct_created_by.args) == 1 and isinstance(direct_created_by.args[0], list) and len(direct_created_by.args[0]) == 1:
        direct_created_by = direct_created_by.args[0][0]
    if isinstance(direct_created_by, Call) and direct_created_by.name == "qCreatedBy":
        owner = query.owner_feature
    if topology == "IMPRINT" and sketch_by_source and query.source_sketch in sketch_by_source:
        return dict(sketch_by_source[query.source_sketch]["workplane"])
    if topology == "OFFSET_FACE" and sketch_by_source is not None and entity_by_sketch is not None:
        return _offset_face_plane(value, feature_frames, sketch_by_source, entity_by_sketch)
    if topology == "COPY" and outer_kind == "face":
        raise ValueError(
            "COPY(FACE) workplane requires a dedicated complete/proven runtime face relation"
        )
    if topology == "MERGE" and outer_kind == "face":
        raise ValueError(
            "MERGE(FACE) workplane requires a dedicated complete/proven runtime face relation"
        )
    frame = feature_frames.get(owner or "")
    if frame and topology == "CAP_FACE":
        cap = "start" if query.is_start is not False else "end"
        return dict(frame.get(f"{cap}_attachment") or frame[cap])
    if frame and frame.get("start") == frame.get("end") and isinstance(direct_created_by, Call) and direct_created_by.name == "qCreatedBy":
        return dict(frame.get("start_attachment") or frame["start"])
    raise ValueError("unsupported or unresolved sketch workplane")


def _bound_name(value: Any) -> str:
    return str(value or "BLIND").split(".")[-1].upper()


def _is_new_body_operation(value: str) -> bool:
    # FeatureScript ``NewBodyOperationType.NEW`` creates an independent
    # context body.  ``ADD`` is a boolean union into its merge scope, so it
    # must keep CDSL's default fusing result mode rather than being rewritten
    # as an independent member.
    normalized = str(value or "").upper()
    return normalized.rsplit(".", 1)[-1] == "NEW"


def _has_active_body(features: list[dict[str, Any]]) -> bool:
    """Whether the lowered history already has a result body to extend."""
    return any(feature.get("atomic_id") not in {"reference_plane", "reference_axis"} for feature in features)


def _end_condition(value: Any) -> dict[str, Any]:
    name = _bound_name(value)
    if name == "BLIND": return {"type": "blind", "solidworks_code": 0}
    if name == "SYMMETRIC": return {"type": "mid_plane", "solidworks_code": 8}
    if name == "THROUGH_ALL": return {"type": "through_all", "solidworks_code": 1}
    if name == "UP_TO_NEXT": return {"type": "through_next", "solidworks_code": 4}
    if name == "UP_TO_SURFACE": return {"type": "up_to_surface", "solidworks_code": 2}
    if name == "UP_TO_BODY": return {"type": "up_to_body", "solidworks_code": 6}
    if name == "UP_TO_VERTEX": return {"type": "up_to_vertex", "solidworks_code": 5}
    raise UnsupportedCapability(f"extrude_extent:{name.lower()}", f"current CDSL atomic set has no exact extrusion operation for {name}")


def _extent_reference(
    value: Any,
    expected_kind: str,
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    *,
    feature_by_id: dict[str, dict[str, Any]] | None = None,
    sketches_by_id: dict[str, dict[str, Any]] | None = None,
    previous: list[str] | None = None,
    allow_cap_output_role: bool = False,
    allow_primary_add_up_to_surface: bool = False,
    allow_direct_prism_swept_lineage: bool = False,
    featurescript_version: str | None = None,
) -> dict[str, Any]:
    # qOwnerBody projects a selected topology member to its containing active
    # body.  Its nested makeQuery retains the member kind, so recognize the
    # narrow executable bridge before checking the outer extent kind.
    if expected_kind == "body":
        owner_body = _direct_owner_body_extent_selector(
            value,
            feature_by_id=feature_by_id or {},
            feature_frames=feature_frames,
            sketch_by_source=sketch_by_source,
            sketches_by_id=sketches_by_id or {},
            entity_by_sketch=entity_by_sketch,
            previous=previous or [],
            featurescript_version=featurescript_version,
        )
        if owner_body is not None:
            return owner_body
    query = parse_query(value)
    if query.kind not in {expected_kind, f"entitytype.{expected_kind}"}:
        raise ValueError(f"extrude extent target is not a {expected_kind}")
    if expected_kind == "face":
        # An up-to-surface reference may consume a direct cap only while its
        # producing prism is the active preceding result. A later body
        # mutation, composed query, or unsupported producer keeps the source
        # query as deferred evidence instead of choosing a similar face.
        cap_output_role = (
            _cap_face_output_role_selector(value, feature_by_id or {}, sketches_by_id or {})
            if feature_by_id is not None and sketches_by_id is not None
            else None
        )
        if (
            allow_cap_output_role
            and cap_output_role is not None
            and previous[-1:] == [cap_output_role["owner_feature_id"]]
        ):
            return cap_output_role
        # A primary ADD prism is transient: its cap only becomes selectable
        # after the exact union topology delta proves one active successor.
        # This is intentionally a separate consumer opt-in from the direct
        # new-body cap bridge, and remains limited to the immediately
        # following one-sided up-to-surface extent.
        primary_add_cap_output_role = (
            _cap_face_output_role_selector(
                value,
                feature_by_id or {},
                sketches_by_id or {},
                allow_primary_add_up_to_surface=True,
            )
            if feature_by_id is not None and sketches_by_id is not None
            else None
        )
        if (
            allow_primary_add_up_to_surface
            and primary_add_cap_output_role is not None
            and previous[-1:] == [primary_add_cap_output_role["owner_feature_id"]]
        ):
            return primary_add_cap_output_role
        # A direct blind prism side wall is not an output-role shortcut. Its
        # source edge and every later continuation must be proven by the
        # topology registry. This bounded consumer only emits the executable
        # intent for a one-sided extent; all other face queries stay deferred.
        if (
            allow_direct_prism_swept_lineage
            and query.topology_type == "SWEPT_FACE"
            and query.owner_feature
            and feature_by_id is not None
            and sketches_by_id is not None
        ):
            swept_lineage = _direct_prism_swept_selector(
                value,
                owner=query.owner_feature,
                selector_kind="face",
                feature_by_id=feature_by_id,
                feature_frames=feature_frames,
                sketch_by_source=sketch_by_source,
                sketches_by_id=sketches_by_id,
                entity_by_sketch=entity_by_sketch,
                previous=previous or [],
                featurescript_version=featurescript_version,
                allow_continuation=True,
                allow_immediate_retained_source_edge=True,
            )
            if swept_lineage is not None:
                return swept_lineage
    if expected_kind == "body":
        swept_body = _direct_swept_body_extent_selector(
            value,
            feature_by_id=feature_by_id or {},
            previous=previous or [],
            featurescript_version=featurescript_version,
        )
        if swept_body is not None:
            return swept_body
    # A direct source owner alone is not evidence for an active result
    # topology member. In particular, a deferred CAP/SWEPT query cannot be
    # converted into an extent reference via a stable ID or a geometric
    # fallback: that would authorize an arbitrary later/current body and can
    # also leave an owner that was never lowered. Keep the feature deferred
    # until a bounded provenance contract above proves the exact reference.
    raise UnsupportedCapability(
        f"extrude_extent_{expected_kind}_selector",
        f"current CDSL {expected_kind} extent requires a complete/proven active selector reference",
    )


def _direct_make_query(value: Any) -> tuple[Call, str, str, str, dict[str, Any]]:
    """Return one direct CADFS makeQuery without flattening its provenance."""
    current = value
    if isinstance(current, Call) and current.name == "qUnion" and len(current.args) == 1 and isinstance(current.args[0], list):
        if len(current.args[0]) != 1: raise ValueError("query union does not identify one topology item")
        current = current.args[0][0]
    if not isinstance(current, Call) or current.name != "makeQuery" or len(current.args) < 3:
        raise ValueError("topology query is unresolved")
    owner_text = symbolic_string(current.args[0])
    if "F" not in owner_text: raise ValueError("topology query owner is unresolved")
    owner = owner_text[owner_text.find("F"):].split(".", 1)[0]
    topology = str(current.args[1]).split(".")[-1].upper()
    kind = str(current.args[2]).split(".")[-1].lower()
    definition = next((arg for arg in current.args if isinstance(arg, dict)), {})
    return current, owner, topology, kind, definition


def _direct_swept_body_extent_selector(
    value: Any,
    *,
    feature_by_id: dict[str, dict[str, Any]],
    previous: list[str],
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Lower one direct active body query for a one-sided ``up_to_body`` extent.

    A single-item ``qUnion`` is the FeatureScript set identity, but it does not
    grant general query composition. The producer has to be the immediately
    active independent prism, so runtime can prove the selected body from the
    body graph without using a stable ID, aggregate body, or geometry score.
    """
    if featurescript_version != "1511":
        return None
    try:
        _call, owner, topology, kind, _definition = _direct_make_query(value)
    except ValueError:
        return None
    producer_id = f"f_{owner}"
    producer = feature_by_id.get(producer_id) or {}
    params = producer.get("params") or {}
    if (
        topology != "SWEPT_BODY"
        or kind not in {"body", "entitytype.body"}
        or previous[-1:] != [producer_id]
        or producer.get("atomic_id") != "extrude_add_blind"
        or params.get("result_mode") != "new_body"
        or (params.get("end_condition") or {}).get("type") not in {"blind", "through_all"}
        or params.get("draft") is not None
    ):
        return None
    intent = _selector_intent(
        value,
        query_family="SWEPT_BODY",
        kind="body",
        evidence="active_body_member",
        allowed=("boundary",),
    )
    intent["body_member_contract"] = "direct_new_body"
    return {
        "kind": "body",
        "owner_feature_id": producer_id,
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "selector_intent": intent,
    }


def _direct_prism_cap_vertex_extent_selector(
    value: Any,
    *,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    previous: list[str],
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Lower one immediate direct-prism CAP_VERTEX target to kernel history.

    A CAP vertex is not identified by its cap-plane coordinates.  The two
    source profile edges must name exactly one original shared endpoint, and
    OCC must carry that source vertex to the requested prism cap.  This first
    contract deliberately excludes continuation, draft, multi-profile, and
    additive/cutting body lifecycles.
    """
    if featurescript_version != "1511":
        return None
    try:
        _call, owner, topology, kind, _definition = _direct_make_query(value)
    except ValueError:
        return None
    query = parse_query(value)
    producer_id = f"f_{owner}"
    producer = feature_by_id.get(producer_id) or {}
    params = producer.get("params") or {}
    frame = feature_frames.get(owner) or {}
    profile_source = frame.get("profile_source")
    profile_sketch = sketches_by_id.get(str(producer.get("sketch_id") or ""))
    source_sketch = sketch_by_source.get(profile_source) if isinstance(profile_source, str) else None
    if producer_id not in previous:
        return None
    producer_index = previous.index(producer_id)
    intervening = previous[producer_index + 1:]
    # An independent member can remain selectable across datum features and
    # later independent new-body creation. Any operation that may mutate,
    # fuse, delete, copy, or transform the producer is deliberately excluded;
    # runtime still has to prove the exact member-preservation relation.
    preserves_member = all(
        (feature_by_id.get(feature_id) or {}).get("atomic_id") == "reference_plane"
        or (
            (feature_by_id.get(feature_id) or {}).get("atomic_id") == "extrude_add_blind"
            and ((feature_by_id.get(feature_id) or {}).get("params") or {}).get("result_mode") == "new_body"
            and (((feature_by_id.get(feature_id) or {}).get("params") or {}).get("end_condition") or {}).get("type") == "blind"
            and ((feature_by_id.get(feature_id) or {}).get("params") or {}).get("draft") is None
        )
        for feature_id in intervening
    )
    if (
        topology != "CAP_VERTEX"
        or kind not in {"vertex", "entitytype.vertex"}
        or query.is_start is None
        or not preserves_member
        or producer.get("atomic_id") != "extrude_add_blind"
        or params.get("result_mode") != "new_body"
        or (params.get("end_condition") or {}).get("type") not in {"blind", "through_all"}
        or params.get("draft") is not None
        or not isinstance(profile_source, str)
        or source_sketch is None
        or profile_sketch is None
        or profile_sketch.get("source_sketch_id") != profile_source
        or not _profile_matches_direct_source(profile_sketch, source_sketch)
    ):
        return None
    refs = _source_refs(value)
    if len(refs) != 2 or {source for source, _token in refs} != {profile_source}:
        return None
    source_ids = _direct_profile_source_entity_ids(profile_sketch)
    resolved_ids: list[str] = []
    for source, token in refs:
        resolved = _source_ref_entity(source, token, entity_by_sketch)
        if resolved is None:
            return None
        entity_id, entity = resolved
        if entity.get("construction") or entity_id not in source_ids or entity_id in resolved_ids:
            return None
        resolved_ids.append(entity_id)
    if _shared_source_endpoint(refs, profile_source, entity_by_sketch) is None:
        return None
    intent = _selector_intent(
        value,
        query_family="CAP_VERTEX",
        kind="vertex",
        evidence="kernel_history",
        allowed=("boundary", "continuation") if intervening else ("boundary",),
    )
    intent.pop("source_entity", None)
    intent["source_entities"] = [
        {"sketch_id": profile_source, "entity_id": entity_id}
        for entity_id in sorted(resolved_ids)
    ]
    intent["lineage_role"] = f"extrude.{'start' if query.is_start else 'end'}"
    return {
        "kind": "vertex",
        "owner_feature_id": producer_id,
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "selector_intent": intent,
    }


def _direct_source_vertex_extent_reference(
    value: Any,
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    *,
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Capture one direct source-sketch vertex as an immutable extent datum.

    This is deliberately not a topology selector. A direct ``sQuery`` vertex
    is defined by the source sketch's explicit workplane and entity endpoint,
    so it can supply an extrusion distance without asking the runtime to find
    a similarly placed B-rep vertex. Composed, derived, runtime-topology, and
    multi-item query forms stay outside this datum contract.
    """
    if featurescript_version != "1511":
        return None
    queries = _queries(value)
    if len(queries) != 1 or not _is_direct_hole_location_query(queries[0]):
        return None
    source = _direct_hole_location(queries[0], sketch_by_source, entity_by_sketch)
    if source is None:
        return None
    local_point, plane = source
    info = parse_query(queries[0])
    if not isinstance(info.source_sketch, str) or not isinstance(info.source_entity, str):
        return None
    return {
        "kind": "source_vertex",
        "source_sketch_id": info.source_sketch,
        "source_entity_id": info.source_entity,
        "point_mm": _global(plane, local_point[:2]),
    }


def _direct_prism_cap_vertex_datum_point(
    value: Any,
    *,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    previous: list[str],
    featurescript_version: str | None,
) -> list[float] | None:
    """Calculate one source-defined direct-prism cap vertex for a datum.

    This is deliberately separate from runtime selector resolution.  A datum
    frame needs a physical source point, while an extent needs a live active
    B-rep vertex.  Both nevertheless require the same direct prism and OSD
    proof; no stale frame, transformed body, geometry search, or STEP result
    may stand in for a CAP_VERTEX query.
    """
    if featurescript_version != "1511":
        return None
    try:
        _call, owner, topology, kind, _definition = _direct_make_query(value)
    except ValueError:
        return None
    query = parse_query(value)
    producer_id = f"f_{owner}"
    producer = feature_by_id.get(producer_id) or {}
    params = producer.get("params") or {}
    frame = feature_frames.get(owner) or {}
    profile_source = frame.get("profile_source")
    profile_sketch = sketches_by_id.get(str(producer.get("sketch_id") or ""))
    source_sketch = sketch_by_source.get(profile_source) if isinstance(profile_source, str) else None
    if producer_id not in previous:
        return None
    producer_index = previous.index(producer_id)
    intervening = previous[producer_index + 1:]

    def preserves_datum_source(feature_id: str) -> bool:
        feature = feature_by_id.get(feature_id) or {}
        atomic_id = feature.get("atomic_id")
        params = feature.get("params") or {}
        if atomic_id == "reference_plane":
            return True
        if (
            atomic_id == "extrude_add_blind"
            and params.get("result_mode") == "new_body"
            and (params.get("end_condition") or {}).get("type") == "blind"
            and params.get("draft") is None
        ):
            return True
        # A direct one-cap shell can intervene for a datum-only CAP_VERTEX:
        # makeQuery(owner.opExtrude, CAP_VERTEX) names the source-defined
        # producer cap position, not a current shell-result vertex. Restrict
        # it to one exact producer cap role; side/set shells lack that proof.
        selectors = feature.get("selectors") or ()
        return (
            atomic_id == "shell"
            and len(selectors) == 1
            and isinstance(selectors[0], dict)
            and selectors[0].get("kind") == "face"
            and selectors[0].get("owner_feature_id") == producer_id
            and selectors[0].get("output_role") in {"extrude.start", "extrude.end"}
            and (selectors[0].get("selector_intent") or {}).get("query_family") == "CAP_FACE"
            and (selectors[0].get("selector_intent") or {}).get("evidence") == "operation_role"
        )

    preserves_source_datum = all(
        preserves_datum_source(feature_id)
        for feature_id in intervening
    )
    if (
        topology != "CAP_VERTEX"
        or kind not in {"vertex", "entitytype.vertex"}
        or query.is_start is None
        or not preserves_source_datum
        or producer.get("atomic_id") != "extrude_add_blind"
        or params.get("result_mode") != "new_body"
        or (params.get("end_condition") or {}).get("type") != "blind"
        or params.get("draft") is not None
        or not isinstance(profile_source, str)
        or source_sketch is None
        or profile_sketch is None
        or profile_sketch.get("source_sketch_id") != profile_source
        or not _profile_matches_direct_source(profile_sketch, source_sketch)
    ):
        return None
    refs = _source_refs(value)
    if len(refs) != 2 or {source for source, _token in refs} != {profile_source}:
        return None
    source_ids = _direct_profile_source_entity_ids(profile_sketch)
    resolved_ids: set[str] = set()
    for source, token in refs:
        resolved = _source_ref_entity(source, token, entity_by_sketch)
        if resolved is None:
            return None
        entity_id, entity = resolved
        if entity.get("construction") or entity_id not in source_ids or entity_id in resolved_ids:
            return None
        resolved_ids.add(entity_id)
    local_point = _shared_source_endpoint(refs, profile_source, entity_by_sketch)
    cap = frame.get("start" if query.is_start else "end")
    profile = frame.get("profile")
    if (
        local_point is None
        or not isinstance(cap, dict)
        or not isinstance(profile, dict)
        or not isinstance(cap.get("origin_mm"), list)
    ):
        return None
    return _global({**profile, "origin_mm": list(cap["origin_mm"])}, local_point)


def _q_owner_body_input(value: Any) -> Any | None:
    """Return the sole source input of a direct ``qOwnerBody`` expression."""
    if not isinstance(value, Call) or value.name != "qOwnerBody" or len(value.args) != 1:
        return None
    return value.args[0]


def _direct_owner_body_extent_selector(
    value: Any,
    *,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    previous: list[str],
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Lower one exact topology-to-active-body ``qOwnerBody`` extent.

    This is deliberately an ownership projection over a direct, already
    executable topology selector.  It does not infer an owner from the
    current aggregate, an OCC proximity search, or a body-producing feature.
    """
    if featurescript_version != "1511":
        return None
    query_input = _q_owner_body_input(value)
    if query_input is None:
        return None
    try:
        _call, owner, topology, kind, _definition = _direct_make_query(query_input)
    except ValueError:
        return None
    if kind != "face" or topology not in {"CAP_FACE", "SWEPT_FACE"}:
        return None
    producer_id = f"f_{owner}"
    if topology == "SWEPT_FACE":
        input_selector = _direct_prism_swept_selector(
            query_input,
            owner=owner,
            selector_kind="face",
            feature_by_id=feature_by_id,
            feature_frames=feature_frames,
            sketch_by_source=sketch_by_source,
            sketches_by_id=sketches_by_id,
            entity_by_sketch=entity_by_sketch,
            previous=previous,
            featurescript_version=featurescript_version,
        )
    else:
        input_selector = _cap_face_output_role_selector(
            query_input, feature_by_id, sketches_by_id,
        ) if previous[-1:] == [producer_id] else None
    if input_selector is None:
        return None
    intent = _selector_intent(
        value,
        query_family="OWNER_BODY",
        kind="body",
        evidence="kernel_history",
        allowed=("boundary",),
    )
    intent.update({
        "owner_body_contract": "exact_input_owner",
        "body_scope": "active_member",
        "empty_policy": "reject",
        "multiple_policy": "one",
    })
    return {
        "kind": "body",
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "query_input": input_selector,
        "selector_intent": intent,
    }


def _face_reference(
    value: Any,
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    *,
    owner_feature_id: str | None = None,
    binding_feature_id: str | None = None,
    match_mode: str | None = None,
    rotation: tuple[dict[str, list[float]], float] | None = None,
) -> dict[str, Any]:
    """Lower one CAP/SWEPT face query into a bindable CDSL selector."""
    _call, owner, topology, kind, _definition = _direct_make_query(value)
    if kind != "face" or topology not in {"CAP_FACE", "SWEPT_FACE"}:
        raise ValueError("intersection source is not a supported face query")
    source = parse_query(value)
    selector_owner = owner_feature_id or f"f_{owner}"
    reference: dict[str, Any] = {
        "kind": "face",
        "owner_feature_id": selector_owner,
        "stable_id": f"cadfs_{selector_owner}_{topology.lower()}",
        "source": "solidworks",
        "confidence": 1.0,
    }
    frame = feature_frames.get(owner)
    geometry: dict[str, Any]
    point: list[float]
    if topology == "CAP_FACE":
        if frame is None or "start" not in frame or "end" not in frame:
            raise ValueError("cap face source frame is unresolved")
        cap = frame["start" if source.is_start else "end"]
        point, normal = list(cap["origin_mm"]), list(cap["normal"])
        if rotation is not None:
            axis, angle = rotation; point, normal = _rotate_point(point, axis, angle), _rotate(normal, axis["direction"], angle)
        geometry = {"normal": normal, "plane_offset_mm": _dot(normal, point)}
        # 同一 feature 的多个圆形端盖可以共面。仅用平面方程会把它们误判为
        # 同一个 selector；保留由 source circle 给出的物理圆心和最小面积，
        # 使 pattern COPY(CAP_FACE) 在 prefix B-rep 中仍可唯一绑定。
        for sketch_id, entity_id in _source_refs(value):
            entity = (entity_by_sketch.get(sketch_id) or {}).get(entity_id)
            sketch = sketch_by_source.get(sketch_id)
            if entity is None or sketch is None or entity.get("type") != "circle":
                continue
            center = _global(cap, entity["center"])
            if rotation is not None:
                axis, angle = rotation; center = _rotate_point(center, axis, angle)
            geometry["center_mm"] = center
            geometry["minimum_area_mm2"] = math.pi * float(entity["radius_mm"]) ** 2 * 0.5
            break
    else:
        sketch = sketch_by_source.get(source.source_sketch or "")
        entity = (entity_by_sketch.get(source.source_sketch or "") or {}).get(source.source_entity or "")
        if sketch is None or entity is None:
            raise ValueError("swept face source geometry is unresolved")
        # 直接 source 草图可能已被后续 transform 烘焙到 feature profile。
        # SWEPT_FACE 必须在该实际 profile workplane 上还原，不能回退到变换前
        # 的草图坐标系，否则 pattern copy 的平面 selector 会落在错误位置。
        plane = (frame or {}).get("profile") or sketch["workplane"]
        if entity["type"] == "circle":
            point, direction = _global(plane, entity["center"]), list(plane["normal"])
            if rotation is not None:
                axis, angle = rotation; point, direction = _rotate_point(point, axis, angle), _rotate(direction, axis["direction"], angle)
            geometry = {"axis_origin_mm": point, "axis_direction": direction, "radius_mm": entity["radius_mm"]}
        elif entity["type"] == "line":
            point = _global(plane, entity["start"]); end = _global(plane, entity["end"])
            normal = _unit(_cross(_sub(end, point), plane["normal"]), "swept face source line is degenerate")
            if rotation is not None:
                axis, angle = rotation; point, normal = _rotate_point(point, axis, angle), _rotate(normal, axis["direction"], angle)
            geometry = {"normal": normal, "plane_offset_mm": _dot(normal, point)}
            if rotation is None and frame and frame.get("start") and frame.get("end"):
                span = math.dist(frame["start"]["origin_mm"], frame["end"]["origin_mm"])
                length = math.dist(point, end)
                if span > 1e-6 and length > 1e-6:
                    # 后续圆角和布尔可能将一个侧壁分裂成同平面的多个 face。
                    # 原始 SWEPT_FACE 的母线长度与拉伸跨度给出确定的面积下界，
                    # 可排除与其共面的微小端盖，而不要求内核保留原始面积。
                    geometry["minimum_area_mm2"] = length * span * 0.5
        else:
            raise ValueError("swept face source entity is unsupported")
    reference["geometry"] = geometry
    reference["selector_intent"] = _deferred_featurescript_selector_intent(value, kind="face")
    if binding_feature_id is not None: reference["binding_feature_id"] = binding_feature_id
    if match_mode is not None: reference["match_mode"] = match_mode
    return reference


def _direct_linear_extrude_swept_face_shell_reference(
    value: Any,
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    feature_by_id: dict[str, dict[str, Any]],
    previous: list[str],
    featurescript_version: str | None,
) -> dict[str, Any]:
    """Lower one source-proven linear-extrude side wall for a shell removal.

    This is deliberately narrower than generic ``SWEPT_FACE`` replay. The
    original sketch line defines an exact planar side wall only while its
    direct blind/two-sided extrusion is the immediately preceding producer;
    boolean, dress-up, copy, and transformed continuations have different
    ownership and are left to future topology-history contracts.
    """
    _call, owner, topology, kind, _definition = _direct_make_query(value)
    producer_id = f"f_{owner}"
    producer = feature_by_id.get(producer_id) or {}
    frame = feature_frames.get(owner) or {}
    params = producer.get("params") or {}
    atomic_id = str(producer.get("atomic_id") or "")
    supported_atomics = {
        "extrude_add_blind", "extrude_add_two_sided",
        "extrude_cut_blind", "extrude_cut_two_sided",
    }
    profile_source = frame.get("profile_source")
    source_sketch = sketch_by_source.get(profile_source) if isinstance(profile_source, str) else None
    profile_sketch = sketches_by_id.get(str(producer.get("sketch_id") or ""))
    immediate_producer = previous[-1:] == [producer_id]
    immediate_primary_cut = False
    if len(previous) >= 2 and previous[-2] == producer_id:
        cut = feature_by_id.get(previous[-1]) or {}
        cut_params = cut.get("params") or {}
        immediate_primary_cut = (
            cut.get("atomic_id") == "extrude_cut_blind"
            and cut.get("depends_on") == [producer_id]
            and (cut_params.get("end_condition") or {}).get("type") == "blind"
            and cut_params.get("draft") is None
        )
    if (
        topology != "SWEPT_FACE"
        or kind not in {"face", "entitytype.face"}
        or atomic_id not in supported_atomics
        or not (immediate_producer or immediate_primary_cut)
        or not isinstance(frame.get("profile"), dict)
        or not isinstance(frame.get("start"), dict)
        or not isinstance(frame.get("end"), dict)
        or source_sketch is None
        or profile_sketch is None
        or not _profile_matches_direct_source(profile_sketch, source_sketch)
        or (params.get("end_condition") or {}).get("type") != "blind"
        or (
            atomic_id.endswith("two_sided")
            and (params.get("reverse_end_condition") or {}).get("type") != "blind"
        )
    ):
        raise UnsupportedCapability(
            "shell_face_selector",
            "current CDSL shell SWEPT_FACE requires the immediately preceding direct blind/two-sided linear extrusion",
        )

    query = parse_query(value)
    refs = _source_refs(value)
    if (
        len(refs) != 1
        or refs[0][0] != profile_source
        or query.source_sketch != profile_source
        or query.source_entity != refs[0][1]
    ):
        raise UnsupportedCapability(
            "shell_face_selector",
            "current CDSL shell SWEPT_FACE requires one direct source-profile line",
        )
    entity = (entity_by_sketch.get(profile_source) or {}).get(refs[0][1])
    if not entity or entity.get("type") != "line" or entity.get("construction"):
        raise UnsupportedCapability(
            "shell_face_selector",
            "current CDSL shell SWEPT_FACE requires one original non-construction source line",
        )
    lineage_selector = _direct_prism_swept_selector(
        value,
        owner=owner,
        selector_kind="face",
        feature_by_id=feature_by_id,
        feature_frames=feature_frames,
        sketch_by_source=sketch_by_source,
        sketches_by_id=sketches_by_id,
        entity_by_sketch=entity_by_sketch,
        previous=previous,
        featurescript_version=featurescript_version,
        # The only non-immediate shell tuple keeps one exact target-side
        # BRepAlgoAPI_Cut continuation between the prism and shell.
        allow_continuation=immediate_primary_cut,
    )
    if lineage_selector is not None:
        return lineage_selector
    return _face_reference(value, feature_frames, sketch_by_source, entity_by_sketch)


def _shell_offset_face_output_role_selector(
    value: Any,
    feature_by_id: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    previous: list[str],
) -> dict[str, Any]:
    """Lower a shell OFFSET_FACE only through its explicit CAP true dependency.

    An OFFSET_FACE is a generated B-rep face, so a bare geometric signature is
    not enough: a shell may generate several offset faces.  CADFS can retain
    the exact semantic source as a nested true-dependency CAP query.  Preserve
    that relation for the runtime topology registry instead of choosing a
    nearby shell face.
    """
    _call, owner, topology, kind, _definition = _direct_make_query(value)
    owner_feature_id = f"f_{owner}"
    producer = feature_by_id.get(owner_feature_id)
    if (
        topology != "OFFSET_FACE"
        or kind not in {"face", "entitytype.face"}
        or producer is None
        or producer.get("atomic_id") != "shell"
        or previous[-1:] != [owner_feature_id]
    ):
        raise UnsupportedCapability(
            "shell_offset_face_selector",
            "current CDSL shell OFFSET_FACE requires the immediately preceding direct shell owner",
        )
    # Only a true-dependency disambiguation may establish a source relation.
    # ``walk_calls`` is deliberately not used here: arbitrary nested CAP_FACE
    # queries can describe ordering or source-profile evidence, but do not
    # prove which shell offset face they produced.
    source_roles = []
    disambiguation = _definition.get("disambiguationData")
    for item in disambiguation if isinstance(disambiguation, list) else ():
        if (
            not isinstance(item, Call)
            or item.name not in {"TDD", "trueDependencyDisambiguation"}
            or len(item.args) != 1
            or not isinstance(item.args[0], list)
        ):
            continue
        for candidate in item.args[0]:
            try:
                cap = _cap_face_output_role_selector(candidate, feature_by_id, sketches_by_id)
            except ValueError:
                continue
            if cap is not None:
                source_roles.append(cap)
    unique_roles = {
        (item["owner_feature_id"], item["output_role"]): item
        for item in source_roles
    }
    if len(unique_roles) != 1:
        raise UnsupportedCapability(
            "shell_offset_face_selector",
            "current CDSL shell OFFSET_FACE requires one direct builder CAP_FACE true dependency",
        )
    source = next(iter(unique_roles.values()))
    return {
        "kind": "face",
        "owner_feature_id": owner_feature_id,
        "output_role": "shell.offset_face",
        "output_role_source": {
            "owner_feature_id": source["owner_feature_id"],
            "output_role": source["output_role"],
        },
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "selector_intent": _selector_intent(
            value,
            query_family="OFFSET_FACE",
            kind="face",
            evidence="operation_role",
            allowed=("boundary", "replacement"),
            output_role="shell.offset_face",
            disambiguation={"type": "true_dependency", "sources": [
                {"owner_feature_id": source["owner_feature_id"], "output_role": source["output_role"]},
            ]},
        ),
    }


def _shell_retained_direct_prism_cap_offset_face_profile_selector(
    value: Any,
    feature_by_id: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    previous: list[str],
    *,
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Use a retained shell cap as an extrusion profile only with full source proof.

    This is deliberately distinct from the TDD OFFSET_FACE selector bridge.
    The exported query names the entire original direct-prism profile through
    one OSD set, while the immediately preceding shell removes the opposite
    cap.  The runtime still has to prove the retained cap -> offset-face
    kernel relation; source-profile membership alone never selects a wall.
    """
    if featurescript_version != "1511":
        return None
    try:
        _call, shell_name, topology, kind, definition = _direct_make_query(value)
    except ValueError:
        return None
    shell_id = f"f_{shell_name}"
    shell = feature_by_id.get(shell_id) or {}
    if (
        topology != "OFFSET_FACE"
        or kind not in {"face", "entitytype.face"}
        or previous[-1:] != [shell_id]
        or shell.get("atomic_id") != "shell"
    ):
        return None

    # This contract describes one retained cap only.  More than one removal
    # target can alter the cap's topology and must remain a diagnostic.
    shell_selectors = shell.get("selectors") or []
    if len(shell_selectors) != 1 or not isinstance(shell_selectors[0], dict):
        return None
    removed = shell_selectors[0]
    removed_intent = removed.get("selector_intent") or {}
    source_id = removed.get("owner_feature_id")
    removed_role = removed.get("output_role")
    if (
        not isinstance(source_id, str)
        or source_id not in feature_by_id
        or removed_role not in {"extrude.start", "extrude.end"}
        or removed_intent.get("query_family") != "CAP_FACE"
        or shell.get("depends_on") != [source_id]
    ):
        return None
    source_feature = feature_by_id[source_id]
    source_params = source_feature.get("params") or {}
    source_sketch = sketches_by_id.get(str(source_feature.get("sketch_id") or ""))
    if (
        source_feature.get("atomic_id") != "extrude_add_blind"
        or source_params.get("result_mode") != "new_body"
        or (source_params.get("end_condition") or {}).get("type") != "blind"
        or source_params.get("draft") is not None
        or not isinstance(source_sketch, dict)
    ):
        return None
    source_ids = _direct_profile_source_entity_ids(source_sketch)
    profile_source = source_sketch.get("source_sketch_id")
    query = parse_query(value)
    refs = _source_refs(value)
    if (
        not source_ids
        or not isinstance(profile_source, str)
        or query.source_sketch != profile_source
        or len(refs) != len(source_ids)
        or {sketch_id for sketch_id, _entity_id in refs} != {profile_source}
        or {entity_id for _sketch_id, entity_id in refs} != source_ids
    ):
        return None
    disambiguation = definition.get("disambiguationData")
    if (
        not isinstance(disambiguation, list)
        or len(disambiguation) != 1
        or not isinstance(disambiguation[0], Call)
        or disambiguation[0].name not in {"OSD", "originalSetDisambiguation"}
        or len(disambiguation[0].args) != 1
        or not isinstance(disambiguation[0].args[0], list)
    ):
        return None

    retained_role = "extrude.end" if removed_role == "extrude.start" else "extrude.start"
    intent = _selector_intent(
        value,
        query_family="OFFSET_FACE",
        kind="face",
        evidence="operation_role",
        allowed=("boundary", "replacement"),
        output_role="shell.offset_face",
        disambiguation={
            "source_profile_entity_ids": sorted(source_ids),
            "removed_cap_role": removed_role,
        },
    )
    intent["consumer_contract"] = "shell_retained_direct_prism_cap_offset_face_profile"
    return {
        "kind": "face",
        "owner_feature_id": shell_id,
        "output_role": "shell.offset_face",
        "output_role_source": {
            "owner_feature_id": source_id,
            "output_role": retained_role,
        },
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "selector_intent": intent,
    }


def _pattern_copy_face_reference(
    value: Any,
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    feature_by_id: dict[str, dict[str, Any]],
) -> dict[str, Any]:
    """Preserve a circular-pattern COPY face as one specific replay instance."""
    _call, pattern_owner, topology, kind, definition = _direct_make_query(value)
    if topology != "COPY" or kind != "face": raise ValueError("intersection copy source is unresolved")
    derived = definition.get("derivedFrom")
    if derived is None: raise ValueError("pattern copy has no derived face")
    _source_call, source_owner, _source_topology, source_kind, _source_definition = _direct_make_query(derived)
    if source_kind != "face": raise ValueError("pattern copy source is not a face")
    pattern_id = f"f_{pattern_owner}"; source_id = f"f_{source_owner}"
    pattern = feature_by_id.get(pattern_id)
    if pattern is None or pattern.get("atomic_id") != "pattern_circular": raise ValueError("pattern copy owner is not a circular pattern")
    if source_id not in (pattern.get("params") or {}).get("source_feature_ids", []):
        raise ValueError("pattern copy source feature is not replayed by its owner")
    try: instance = int(str(definition.get("instanceName")))
    except (TypeError, ValueError) as error: raise ValueError("pattern copy instance is unresolved") from error
    axis = (pattern.get("params") or {}).get("axis")
    count = int((pattern.get("params") or {}).get("pattern_count") or 0)
    if not isinstance(axis, dict) or count < 1 or instance < 0 or instance >= count:
        raise ValueError("pattern copy instance transform is unresolved")
    angle = math.radians(float((pattern.get("params") or {}).get("sweep_angle_deg") or 360.0) * instance / count)
    reference = _face_reference(
        derived, feature_frames, sketch_by_source, entity_by_sketch,
        owner_feature_id=f"{pattern_id}.c{instance}.{source_id}",
        binding_feature_id=pattern_id,
        rotation=(axis, angle),
    )
    reference["owner_match_required"] = True
    # The outer COPY query, not its CAP/SWEPT source, defines the semantic
    # request for the pattern instance.
    reference["selector_intent"] = _deferred_featurescript_selector_intent(value, kind="face")
    return reference


def _intersection_vertex_reference(
    value: Any,
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    feature_by_id: dict[str, dict[str, Any]],
    feature_id: str,
) -> dict[str, Any]:
    """Lower a CADFS INTERSECT vertex without replacing it with a coordinate."""
    _call, owner, topology, kind, definition = _direct_make_query(value)
    if topology != "INTERSECT" or kind != "vertex": raise ValueError("up-to-vertex target is not an INTERSECT vertex")
    derived = definition.get("derivedFrom")
    if not isinstance(derived, list) or len(derived) < 2:
        raise ValueError("intersection vertex has no complete face provenance")
    components = []
    for item in derived:
        _item_call, item_owner, item_topology, item_kind, _item_definition = _direct_make_query(item)
        if item_kind != "face": raise ValueError("intersection vertex source is not a face")
        if item_topology == "COPY":
            components.append(_pattern_copy_face_reference(item, feature_frames, sketch_by_source, entity_by_sketch, feature_by_id))
        elif item_topology == "SWEPT_FACE":
            components.append(_face_reference(
                item, feature_frames, sketch_by_source, entity_by_sketch,
                owner_feature_id=f"f_{item_owner}", binding_feature_id=f"f_{item_owner}", match_mode="all",
            ))
        else:
            raise ValueError(f"intersection vertex source topology {item_topology} is unsupported")
    return {
        "kind": "vertex",
        "owner_feature_id": f"f_{owner}",
        "stable_id": f"cadfs_f_{feature_id}_intersect_vertex",
        "source": "solidworks",
        "confidence": 1.0,
        "intersection_of": components,
        "selector_intent": _deferred_featurescript_selector_intent(value, kind="vertex"),
    }


def _arc(start: list[float], mid: list[float], end: list[float]) -> dict[str, Any]:
    ax, ay = start; bx, by = mid; cx, cy = end
    d = 2 * (ax*(by-cy) + bx*(cy-ay) + cx*(ay-by))
    if abs(d) < 1e-9: raise ValueError("collinear arc points")
    ux = ((ax*ax+ay*ay)*(by-cy)+(bx*bx+by*by)*(cy-ay)+(cx*cx+cy*cy)*(ay-by))/d
    uy = ((ax*ax+ay*ay)*(cx-bx)+(bx*bx+by*by)*(ax-cx)+(cx*cx+cy*cy)*(bx-ax))/d
    cross = (mid[0]-start[0])*(end[1]-mid[1])-(mid[1]-start[1])*(end[0]-mid[0])
    clockwise = cross < 0
    # CADFS 的倒圆角会把中点按显示精度写回 FeatureScript。端点已经完整
    # 表达等半径直角圆弧时，优先从端点恢复原始圆心，避免把显示精度误作
    # 几何精度；任意三点圆弧仍保持原来的外接圆求解。
    for center in ([ax, cy], [cx, ay]):
        first = [ax - center[0], ay - center[1]]; second = [cx - center[0], cy - center[1]]
        radius = math.hypot(*first)
        if radius <= 1e-9 or abs(math.hypot(*second) - radius) > 1e-9 or abs(_dot(first, second)) > 1e-9:
            continue
        start_angle = math.atan2(first[1], first[0]); end_angle = math.atan2(second[1], second[0])
        sweep = end_angle - start_angle
        if clockwise and sweep >= 0: sweep -= math.tau
        elif not clockwise and sweep <= 0: sweep += math.tau
        expected = [center[0] + radius * math.cos(start_angle + sweep / 2), center[1] + radius * math.sin(start_angle + sweep / 2)]
        if math.dist(mid, expected) <= max(1e-6, radius * 5e-4):
            return {"type": "arc", "start": start, "end": end, "center": center, "radius_mm": radius, "clockwise": clockwise}
    return {"type": "arc", "start": start, "end": end, "center": [ux, uy], "radius_mm": math.hypot(ax-ux, ay-uy), "clockwise": clockwise}


def _endpoint(segment: dict[str, Any], end: bool = False) -> tuple[int, int]:
    point = segment["end" if end else "start"]; return round(point[0]*1e5), round(point[1]*1e5)


def _reverse_segment(segment: dict[str, Any]) -> dict[str, Any]:
    output = dict(segment)
    output["start"], output["end"] = segment["end"], segment["start"]
    if output["type"] == "arc": output["clockwise"] = not bool(segment["clockwise"])
    elif output["type"] == "bspline":
        # OCC 的 periodic interpolator 对 reversed point list 会求出另一条
        # 曲线。半边图只需要反转其拓扑走向，保留原插值点并以私有标记供
        # 切线和面积计算使用；该标记不会进入 CDSL profile。
        if output.get("periodic"):
            output["_reversed"] = not bool(segment.get("_reversed"))
        else:
            output["points"] = list(reversed(segment["points"]))
            parameters = output.get("parameters")
            if parameters is not None:
                final_parameter = float(parameters[-1])
                output["parameters"] = [final_parameter - float(value) for value in reversed(parameters)]
            start_tangent = output.pop("start_tangent", None)
            end_tangent = output.pop("end_tangent", None)
            if end_tangent is not None:
                output["start_tangent"] = [-float(value) for value in end_tangent]
            if start_tangent is not None:
                output["end_tangent"] = [-float(value) for value in start_tangent]
    return output


def _segment_tangent(segment: dict[str, Any]) -> tuple[float, float]:
    if segment["type"] == "line":
        return segment["end"][0] - segment["start"][0], segment["end"][1] - segment["start"][1]
    if segment["type"] == "arc":
        radius = [segment["start"][0] - segment["center"][0], segment["start"][1] - segment["center"][1]]
        return (radius[1], -radius[0]) if segment["clockwise"] else (-radius[1], radius[0])
    points = segment["points"]
    if segment.get("periodic") and segment.get("_reversed"):
        return points[0][0] - points[-2][0], points[0][1] - points[-2][1]
    return points[1][0] - points[0][0], points[1][1] - points[0][1]


def _contour_area(segments: list[dict[str, Any]]) -> float:
    points: list[list[float]] = []
    for segment in segments:
        points.append(segment["start"])
        if segment["type"] == "arc":
            start = segment["start"]; end = segment["end"]; center = segment["center"]
            start_angle = math.atan2(start[1] - center[1], start[0] - center[0])
            end_angle = math.atan2(end[1] - center[1], end[0] - center[0])
            sweep = end_angle - start_angle
            if segment["clockwise"] and sweep >= 0: sweep -= 2 * math.pi
            if not segment["clockwise"] and sweep <= 0: sweep += 2 * math.pi
            angle = start_angle + sweep / 2
            points.append([center[0] + segment["radius_mm"] * math.cos(angle), center[1] + segment["radius_mm"] * math.sin(angle)])
        elif segment["type"] == "bspline":
            interior = segment["points"][1:-1]
            points.extend(reversed(interior) if segment.get("_reversed") else interior)
    return sum(points[index][0] * points[(index + 1) % len(points)][1] - points[(index + 1) % len(points)][0] * points[index][1] for index in range(len(points))) / 2


def _split_line_vertices(edges: list[dict[str, Any]]) -> list[dict[str, Any]]:
    # FeatureScript 允许小轮廓端点落在一条未显式分段的长线上。面环遍历前将
    # 长线按这些顶点切开，避免 T 形连接被误判为开链。
    points = [point for edge in edges for point in (edge["start"], edge["end"])]
    output: list[dict[str, Any]] = []
    for edge in edges:
        if edge["type"] != "line":
            output.append(edge); continue
        start, end = edge["start"], edge["end"]
        direction = [end[0] - start[0], end[1] - start[1]]
        length_squared = direction[0] * direction[0] + direction[1] * direction[1]
        if length_squared <= 1e-16:
            output.append(edge); continue
        cuts = {0.0, 1.0}
        for point in points:
            delta = [point[0] - start[0], point[1] - start[1]]
            parameter = (delta[0] * direction[0] + delta[1] * direction[1]) / length_squared
            cross = abs(delta[0] * direction[1] - delta[1] * direction[0])
            if 1e-8 < parameter < 1.0 - 1e-8 and cross <= 1e-7 * max(1.0, math.sqrt(length_squared)):
                cuts.add(parameter)
        ordered = sorted(cuts)
        # A line cut by an intervening profile vertex no longer maps one-to-one
        # to its FeatureScript source entity. Keep the semantic source anchor
        # only when this operation retained the original B-rep edge intact.
        preserve_source = len(ordered) == 2 and isinstance(edge.get("source_entity_id"), str)
        output.extend({
            "type": "line",
            "start": [start[0] + direction[0] * left, start[1] + direction[1] * left],
            "end": [start[0] + direction[0] * right, start[1] + direction[1] * right],
            **({"source_entity_id": edge["source_entity_id"]} if preserve_source else {}),
        } for left, right in zip(ordered, ordered[1:]))
    return output


def _contours(segments: list[dict[str, Any]]) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
    closed_curves = [{"role": "unknown", "closed": True, "segments": [item]} for item in segments if item["type"] in {"circle", "ellipse"}]
    edges = _split_line_vertices([item for item in segments if item["type"] not in {"circle", "ellipse"}])
    # CADFS 草图可包含共享边和多个 qSketchRegion。逐条贪心接线会在第一个
    # 分叉处吃掉共用边，使其余合法区域退化为“open”。这里按局部切线建立平面
    # 半边图；每条有向边沿入射顶点的左侧继续，稳定枚举所有有界面环。
    half_edges: list[dict[str, Any]] = []
    outgoing: dict[tuple[int, int], list[int]] = {}
    for edge_index, edge in enumerate(edges):
        for forward, segment in ((True, edge), (False, _reverse_segment(edge))):
            index = len(half_edges)
            half_edges.append({"edge_index": edge_index, "forward": forward, "segment": segment})
            outgoing.setdefault(_endpoint(segment), []).append(index)
    for vertex, indexes in outgoing.items():
        del vertex
        indexes.sort(key=lambda index: (math.atan2(*reversed(_segment_tangent(half_edges[index]["segment"]))), index))
    next_edge: dict[int, int] = {}
    for index, item in enumerate(half_edges):
        arrivals = outgoing[_endpoint(item["segment"], True)]
        twin = next(candidate for candidate in arrivals if half_edges[candidate]["edge_index"] == item["edge_index"] and half_edges[candidate]["forward"] != item["forward"])
        next_edge[index] = arrivals[(arrivals.index(twin) - 1) % len(arrivals)]
    visited: set[int] = set(); used_edges: set[int] = set(); contours = []
    for start in range(len(half_edges)):
        if start in visited: continue
        chain: list[int] = []; current = start
        while current not in visited:
            visited.add(current); chain.append(current); current = next_edge[current]
        if current != start: continue
        contour = [half_edges[index]["segment"] for index in chain]
        if contour and _contour_area(contour) > 1e-8:
            # `_reversed` belongs only to the planar half-edge traversal.
            # A periodic B-spline remains the same physical closed profile
            # regardless of the retained OCC edge orientation.
            public_segments = [{key: value for key, value in segment.items() if key != "_reversed"} for segment in contour]
            contours.append({"role": "unknown", "closed": True, "segments": public_segments})
            used_edges.update(half_edges[index]["edge_index"] for index in chain)
    construction = [edge for index, edge in enumerate(edges) if index not in used_edges]
    return contours + closed_curves, construction


def _recover_imperial_grid(items: list[dict[str, Any]], point_records: list[dict[str, Any]]) -> None:
    # 部分 CADFS 导出会将英制草图的个别坐标截断为两位小数，但其余坐标仍
    # 保留 0.001 in 网格。只在同一草图已能证明该网格时恢复相邻显示值；
    # 半径和 feature 参数不属于这一坐标恢复规则，绝不能在这里猜测或改写。
    grid = 0.0254; tolerance = grid / 5
    coordinates: list[float] = []

    def collect(point: list[float] | None) -> None:
        if isinstance(point, list): coordinates.extend(float(value) for value in point[:2])

    for item in items:
        if item["type"] in {"line", "arc"}: collect(item.get("start")); collect(item.get("end"))
        if item["type"] in {"circle", "ellipse"}: collect(item.get("center"))
    for point_record in point_records: collect(point_record.get("point"))

    nonzero = [value for value in coordinates if abs(value) > 1e-9]
    if not nonzero: return
    error = lambda value: abs(value - round(value / grid) * grid)
    aligned = [value for value in nonzero if error(value) <= tolerance]
    exact = [value for value in nonzero if error(value) <= 1e-8]
    if len(aligned) / len(nonzero) < 0.9 or len(exact) * 2 < len(nonzero): return

    def recover(point: list[float] | None) -> None:
        if not isinstance(point, list): return
        for index, value in enumerate(point[:2]):
            if error(float(value)) <= tolerance: point[index] = round(float(value) / grid) * grid

    for item in items:
        if item["type"] in {"line", "arc"}: recover(item.get("start")); recover(item.get("end"))
        if item["type"] in {"circle", "ellipse"}: recover(item.get("center"))
    for point_record in point_records: recover(point_record.get("point"))


def _centripetal_parameters(points: list[list[float]]) -> list[float]:
    parameters = [0.0]
    for start, end in zip(points, points[1:]):
        distance = math.dist(start, end)
        if distance <= 1e-9: raise ValueError("fit spline has coincident interpolation points")
        parameters.append(parameters[-1] + math.sqrt(distance))
    total = parameters[-1]
    return [value / total for value in parameters]


def _lower_sketch(sketch: SketchIR, plane: dict[str, Any], allow_open: bool = False) -> tuple[dict[str, Any], dict[str, dict[str, Any]]]:
    segments: list[dict[str, Any]] = []; explicit_construction: list[dict[str, Any]] = []; entities: dict[str, dict[str, Any]] = {}; points: list[dict[str, Any]] = []; unsupported = []

    def sketch_result(profile: dict[str, Any], *, role: str | None = None) -> dict[str, Any]:
        result = {
            "id": f"sketch_{sketch.feature_id}",
            "name": sketch.feature_id,
            "source_sketch_id": sketch.feature_id,
            "workplane": plane,
            "profile": profile,
        }
        if role is not None:
            result["role"] = role
        return result

    for entity in sketch.entities:
        p = entity.params
        if entity.operation == "skPoint":
            item = {"type": "point", "point": _point(p["position"])}; entities[entity.feature_id] = item; points.append(item); continue
        if entity.operation == "skLineSegment": item = {"type": "line", "start": _point(p["start"]), "end": _point(p["end"])}
        elif entity.operation == "skCircle": item = {"type": "circle", "center": _point(p["center"]), "radius_mm": _number(p["radius"], True)}
        elif entity.operation == "skEllipse":
            major_axis = _unit(_point(p["majorAxis"]), "ellipse major axis is degenerate")
            item = {"type": "ellipse", "center": _point(p["center"]), "major_radius_mm": _number(p["majorRadius"], True), "minor_radius_mm": _number(p["minorRadius"], True), "major_axis": major_axis}
        elif entity.operation == "skArc": item = _arc(_point(p["start"]), _point(p["mid"]), _point(p["end"]))
        elif entity.operation == "skFitSpline":
            spline_points = [_point(point) for point in p.get("points") or []]
            if len(spline_points) < 2: raise ValueError("fit spline needs at least 2 points")
            start_derivative = p.get("startDerivative")
            end_derivative = p.get("endDerivative")
            if len(spline_points) == 2:
                if _same_point(spline_points[0], spline_points[1]):
                    raise ValueError("two-point fit spline endpoints must be distinct")
                if start_derivative is None or end_derivative is None:
                    raise ValueError("two-point fit spline requires both endpoint derivatives")
            # FeatureScript 的 skFitSpline 以根号弦长参数化。参数域既决定
            # 插值曲线，也决定端点导数的长度语义；半边遍历反转轮廓时会将
            # 它按反向参数域同步变换，不能交给 OCC 默认重新计算。
            item = {
                "type": "bspline", "start": spline_points[0], "end": spline_points[-1],
                "points": spline_points, "parameterization": "centripetal",
                "parameters": _centripetal_parameters(spline_points),
            }
            # skFitSpline uses a periodic curve when the author closes it by
            # repeating the first interpolation point. Passing that repeated
            # point into a non-periodic interpolator changes the profile area
            # and produces a seam that does not exist in CADFS.
            if _same_point(spline_points[0], spline_points[-1]):
                item["periodic"] = True
            if start_derivative is not None: item["start_tangent"] = _point(start_derivative)
            if end_derivative is not None: item["end_tangent"] = _point(end_derivative)
        else: unsupported.append(entity.operation); continue
        if _bool(p.get("construction")):
            # Keep construction provenance available to topology-query lowering,
            # but never let it participate in a planar IMPRINT arrangement.
            # ``construction`` is runtime-only mapping metadata and must not
            # leak into the public analytic-segment schema.
            entities[entity.feature_id] = {**item, "construction": True}
            explicit_construction.append(item)
        else:
            # This is source construction provenance, not a geometric
            # selector hint. Derived or split segments deliberately do not
            # inherit this identity later in lowering.
            item["source_entity_id"] = entity.feature_id
            entities[entity.feature_id] = item
            segments.append(item)
    if unsupported: raise ValueError("unsupported sketch entities: " + ",".join(sorted(set(unsupported))))
    _recover_imperial_grid(segments + explicit_construction, points)
    if not segments:
        profile: dict[str, Any] = {"type": "analytic_contours", "contours": []}
        if explicit_construction: profile["construction"] = explicit_construction
        return sketch_result(profile, role="reference"), entities
    if len(segments) == 1 and segments[0]["type"] == "circle" and not explicit_construction:
        profile = {
            "type": "circle",
            "center": segments[0]["center"],
            "radius_mm": segments[0]["radius_mm"],
            "source_entity_id": segments[0]["source_entity_id"],
        }
    else:
        contours, open_segments = _contours(segments)
        if open_segments:
            # qSketchRegion 只会选取闭合区域。与之无关的开链必须保留为
            # reference geometry，不能因为它们存在就丢弃同一草图中的合法
            # 区域；若草图没有任何闭合区域，则仍按原有规则拒绝实体 profile。
            if not contours:
                if not allow_open: raise OpenSketchProfileError(f"sketch has {len(open_segments)} open non-construction segment(s)")
                profile = {"type": "analytic_contours", "contours": [], "construction": explicit_construction + open_segments}
                return sketch_result(profile, role="reference"), entities
            explicit_construction = [*explicit_construction, *open_segments]
        construction = list(explicit_construction)
        if not contours:
            profile = {"type": "analytic_contours", "contours": [], "construction": construction}
            return sketch_result(profile, role="reference"), entities
        profile = {"type": "analytic_contours", "contours": contours}
        if construction: profile["construction"] = construction
    return sketch_result(profile), entities


def _queries(value: Any) -> list[Any]:
    if isinstance(value, Call) and value.name == "qUnion" and value.args and isinstance(value.args[0], list): return value.args[0]
    return [value]


def _direct_query_set_operands(value: Any) -> tuple[str, str, list[Any]] | None:
    """Return a direct source set only when its operand boundary is explicit."""
    if not isinstance(value, Call):
        return None
    if value.name == "qUnion":
        if len(value.args) != 1 or not isinstance(value.args[0], list):
            return None
        operands = value.args[0]
        contract = "proven_operand_union"
        operator = "union"
    elif value.name == "qIntersection":
        operands = value.args[0] if len(value.args) == 1 and isinstance(value.args[0], list) else value.args
        contract = "proven_operand_intersection"
        operator = "intersection"
    elif value.name == "qSubtraction":
        operands = value.args
        contract = "proven_operand_subtraction"
        operator = "subtraction"
    else:
        return None
    if (
        not isinstance(operands, list)
        or len(operands) < 2
        or contract == "proven_operand_subtraction" and len(operands) != 2
    ):
        return None
    return contract, operator, operands


def _query_set_leaf_values(value: Any) -> list[Any]:
    """Flatten only the leaves of an explicit recursive source set tree.

    The flattened list is an implementation detail of lowering: it lets the
    existing direct-provenance constructors handle every ``makeQuery`` leaf.
    ``_proven_query_set_selector`` below reconstructs the exact source tree,
    so flattening here never turns nested FeatureScript set semantics into an
    unstructured selector list.
    """
    source_set = _direct_query_set_operands(value)
    if source_set is None:
        return [value]
    return [leaf for operand in source_set[2] for leaf in _query_set_leaf_values(operand)]


def _proven_query_set_selector(value: Any, selectors: list[dict[str, Any]]) -> dict[str, Any] | None:
    """Preserve a recursive FeatureScript query set with proven operands.

    A selector set is not a list of equivalent single-selector decisions.
    Every set node retains its own source expression and runtime composes only
    already-proven direct leaf results. Filters and non-``makeQuery`` leaves
    stay deferred, but unions/intersections/subtractions can be freely nested
    when every branch has the same exact source provenance contract.
    """
    if _direct_query_set_operands(value) is None:
        return None

    def direct_leaf(selector_value: Any, selector: dict[str, Any]) -> set[str] | None:
        """Return the leaf derivations only for an executable provenance leaf."""
        intent = selector.get("selector_intent")
        policy = intent.get("derivation_policy") if isinstance(intent, dict) else None
        expression = intent.get("query_expr") if isinstance(intent, dict) else None
        if (
            not isinstance(selector_value, Call)
            or selector_value.name != "makeQuery"
            or
            selector.get("source") != "runtime_snapshot"
            or any(selector.get(key) is not None for key in (
                "stable_id", "snapshot_id", "geometry", "binding_feature_id",
            ))
            or not isinstance(intent, dict)
            or intent.get("query_family") in {None, "GEOMETRIC", "QUERY_SET"}
            or not isinstance(policy, dict)
            or policy.get("multiplicity") == "none"
            or not isinstance(expression, dict)
            or expression.get("root") != query_expr(selector_value)["root"]
        ):
            return None
        return {item for item in policy.get("allowed") or () if isinstance(item, str)}

    cursor = 0

    def build(node: Any) -> tuple[dict[str, Any], set[str]] | None:
        nonlocal cursor
        source_set = _direct_query_set_operands(node)
        if source_set is None:
            if cursor >= len(selectors):
                return None
            selector = selectors[cursor]
            cursor += 1
            allowed = direct_leaf(node, selector)
            return (selector, allowed) if allowed else None

        contract, _operator, operands = source_set
        children: list[dict[str, Any]] = []
        allowed: set[str] = set()
        for operand in operands:
            child = build(operand)
            if child is None:
                return None
            child_selector, child_allowed = child
            children.append(child_selector)
            allowed.update(child_allowed)
        kinds = {child.get("kind") for child in children}
        if len(kinds) != 1 or next(iter(kinds), None) not in {"face", "edge"} or not allowed:
            return None
        kind = next(iter(kinds))
        intent = _selector_intent(
            node,
            query_family="QUERY_SET",
            kind=kind,
            evidence="kernel_history",
            allowed=tuple(item for item in (
                "continuation", "fragment", "merge", "intersection", "boundary", "replacement",
            ) if item in allowed),
            multiplicity="source_qualified",
        )
        # A parent set has no singular source anchor. The exact anchors remain
        # in its recursively matched child selectors.
        intent.pop("source_entity", None)
        intent.update({
            "query_set_contract": contract,
            "set_kind": kind,
            "body_scope": "active_member",
            "empty_policy": "reject",
            "multiple_policy": "all",
        })
        return {
            "kind": kind,
            "source": "runtime_snapshot",
            "confidence": 1.0,
            "query_operands": children,
            "selector_intent": intent,
        }, allowed

    result = build(value)
    if result is None or cursor != len(selectors):
        return None
    return result[0]


def _source_refs(value: Any) -> list[tuple[str, str]]:
    refs = []
    for call in walk_calls(value):
        if call.name in {"sQuery", "sketchEntityQuery"} and len(call.args) >= 3:
            refs.append((symbolic_string(call.args[0]).split(".", 1)[0], str(call.args[2])))
    return refs


def _source_ref_entity(
    sketch_id: str,
    token: str,
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> tuple[str, dict[str, Any]] | None:
    """Resolve an original sketch entity without accepting derived-name aliases."""
    entities = entity_by_sketch.get(sketch_id) or {}
    if token in entities:
        return token, entities[token]
    entity_id = max((key for key in entities if token.startswith(key + ".")), key=len, default="")
    if not entity_id:
        return None
    suffix = token[len(entity_id) + 1:]
    # A named source endpoint is still direct provenance.  Other suffixes
    # (trim offspring, mirrored construction, generated fillet arcs, ...) do
    # not identify one source-local endpoint and must not be guessed.
    if suffix not in {"start", "end"}:
        return None
    return entity_id, entities[entity_id]


def _source_ref_endpoint_points(entity_id: str, token: str, entity: dict[str, Any]) -> list[list[float]]:
    """Return only endpoint coordinates that FeatureScript explicitly exposes."""
    if entity.get("type") == "point" and token == entity_id:
        point = entity.get("point")
        return [point] if isinstance(point, list) and len(point) == 2 else []
    start, end = entity.get("start"), entity.get("end")
    if not all(isinstance(point, list) and len(point) == 2 for point in (start, end)):
        return []
    if token == entity_id:
        return [start, end]
    suffix = token[len(entity_id) + 1:]
    return [start] if suffix == "start" else [end] if suffix == "end" else []


def _shared_source_endpoint(
    refs: list[tuple[str, str]],
    sketch_id: str,
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> list[float] | None:
    """Find the one explicit endpoint shared by a set of source curves.

    ``SWEPT_EDGE`` provenance from CADFS uses an original-set disambiguation
    containing the source curves incident at a profile vertex.  A single curve
    has two possible ends, so it cannot identify a swept edge by itself.  This
    routine deliberately accepts only one shared endpoint from distinct direct
    source entities, with the direct ``skPoint`` case retained for point-based
    provenance.
    """
    selected: dict[str, tuple[str, dict[str, Any]]] = {}
    for source, token in refs:
        if source != sketch_id:
            continue
        resolved = _source_ref_entity(source, token, entity_by_sketch)
        if resolved is None:
            return None
        entity_id, entity = resolved
        selected.setdefault(entity_id, (token, entity))
    if not selected:
        return None
    if len(selected) == 1:
        entity_id, (token, entity) = next(iter(selected.items()))
        if entity.get("type") == "point":
            points = _source_ref_endpoint_points(entity_id, token, entity)
            return points[0] if len(points) == 1 else None
        return None

    endpoints: list[tuple[str, list[float]]] = []
    for entity_id, (token, entity) in selected.items():
        points = _source_ref_endpoint_points(entity_id, token, entity)
        if not points:
            return None
        endpoints.extend((entity_id, point) for point in points)
    candidates: list[list[float]] = []
    for _entity_id, point in endpoints:
        incident = {
            candidate_id
            for candidate_id, candidate_point in endpoints
            if math.dist(point, candidate_point) <= 1e-5
        }
        if len(incident) < 2 or any(math.dist(point, candidate) <= 1e-5 for candidate in candidates):
            continue
        candidates.append(point)
    return candidates[0] if len(candidates) == 1 else None


def _endpoint_bbox(start: list[float], end: list[float], *, known_line: bool) -> dict[str, Any] | None:
    if math.dist(start, end) <= 1e-8:
        return None
    geometry = {"bbox_mm": [min(start[i], end[i]) for i in range(3)] + [max(start[i], end[i]) for i in range(3)]}
    if known_line:
        geometry["curve_type"] = "line"
    return geometry


def _swept_edge_line_selector_geometry(
    owner: str,
    refs: list[tuple[str, str]],
    frame: dict[str, Any],
    feature_by_id: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> dict[str, Any] | None:
    """Lower a directly proven ``SWEPT_EDGE`` into an endpoint-bbox selector.

    This is intentionally not a general topology replay.  It covers an edge
    created by a translational extrude from one profile vertex, or by a direct
    two-section loft whose source query identifies one profile vertex on each
    section.  Both constructions provide exact source-local endpoints.  A
    sweep, revolve, multi-section loft, generated/trimmed source, or any
    ambiguous original-set remains unsupported rather than selecting a nearby
    B-rep edge.
    """
    producer = feature_by_id.get(f"f_{owner}") or {}
    atomic_id = str(producer.get("atomic_id") or "")
    source_ids = {source for source, _token in refs}
    if atomic_id in {"extrude_add_blind", "extrude_add_two_sided", "extrude_cut_blind", "extrude_cut_two_sided"}:
        profile_source = frame.get("profile_source")
        profile = frame.get("profile")
        if (
            not isinstance(profile_source, str)
            or source_ids != {profile_source}
            or not isinstance(profile, dict)
            or not isinstance(frame.get("start"), dict)
            or not isinstance(frame.get("end"), dict)
        ):
            return None
        local = _shared_source_endpoint(refs, profile_source, entity_by_sketch)
        if local is None:
            return None
        base = _global(profile, local)
        start = [base[index] + frame["start"]["origin_mm"][index] - profile["origin_mm"][index] for index in range(3)]
        end = [base[index] + frame["end"]["origin_mm"][index] - profile["origin_mm"][index] for index in range(3)]
        return _endpoint_bbox(start, end, known_line=True)
    if atomic_id != "loft_add":
        return None
    profile_sources = frame.get("loft_profile_sources")
    if not isinstance(profile_sources, list) or len(profile_sources) != 2 or len(set(profile_sources)) != 2:
        return None
    if source_ids != set(profile_sources):
        return None
    points = [
        _shared_source_endpoint(refs, source, entity_by_sketch)
        for source in profile_sources
    ]
    if any(point is None or source not in sketch_by_source for point, source in zip(points, profile_sources)):
        return None
    start = _global(sketch_by_source[profile_sources[0]]["workplane"], points[0])
    end = _global(sketch_by_source[profile_sources[1]]["workplane"], points[1])
    # A ThruSections loft may represent this side edge as a B-spline even
    # though its endpoint correspondence is exact. Do not claim a line type.
    return _endpoint_bbox(start, end, known_line=False)


def _swept_edge_revolve_circle_selector_geometry(
    owner: str,
    refs: list[tuple[str, str]],
    frame: dict[str, Any],
    feature_by_id: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> dict[str, Any] | None:
    """Lower one direct full-revolve profile vertex to a circular edge signature.

    This deliberately accepts only an independent full solid revolve from its
    original sketch and original in-sketch axis.  Its source query must prove
    exactly one profile endpoint, and that endpoint must have positive radial
    distance to the explicit axis.  Partial/surface/additive revolutions and
    generated or transformed profile provenance have different topology and
    remain unsupported instead of being geometrically guessed.
    """
    producer = feature_by_id.get(f"f_{owner}") or {}
    if (
        producer.get("atomic_id") != "revolve_add"
        or (producer.get("params") or {}).get("result_mode") != "new_body"
        or not frame.get("revolve_full")
    ):
        return None
    profile_source = frame.get("profile_source")
    axis = frame.get("revolve_axis")
    if (
        not isinstance(profile_source, str)
        or {source for source, _token in refs} != {profile_source}
        or profile_source not in sketch_by_source
        or not isinstance(axis, dict)
    ):
        return None
    local = _shared_source_endpoint(refs, profile_source, entity_by_sketch)
    if local is None:
        return None
    try:
        origin = [float(value) for value in axis["origin_mm"]]
        direction = [float(value) for value in axis["direction"]]
    except (KeyError, TypeError, ValueError):
        return None
    if len(origin) != 3 or len(direction) != 3 or not all(math.isfinite(value) for value in origin + direction):
        return None
    direction_length = math.sqrt(sum(value * value for value in direction))
    if direction_length <= 1e-9:
        return None
    direction = [value / direction_length for value in direction]
    point = _global(sketch_by_source[profile_source]["workplane"], local)
    projection = sum((point[index] - origin[index]) * direction[index] for index in range(3))
    center = [origin[index] + projection * direction[index] for index in range(3)]
    radius = math.dist(point, center)
    if not math.isfinite(radius) or radius <= 1e-8:
        return None
    return {"curve_type": "circle", "circle_center_mm": center, "radius_mm": radius}


def _profile_matches_direct_source(selected: dict[str, Any], source: dict[str, Any]) -> bool:
    """Prove that a materialized profile selection changed no source geometry.

    ``IMPRINT`` is sometimes only the FeatureScript representation of selecting
    the one existing sketch region. It may also select a proper subset. The
    latter must not inherit a source-profile SWEPT_EDGE contract, so accept the
    former only when its physical workplane and complete profile are exactly
    the original lowered mappings.
    """
    return (
        selected.get("workplane") == source.get("workplane")
        and selected.get("profile") == source.get("profile")
    )


def _direct_profile_source_entity_ids(profile_sketch: dict[str, Any]) -> set[str]:
    """Return only source entities still represented by one direct profile edge.

    This follows the explicit source labels carried by the CDSL profile. A
    source entity dropped by region selection or split during contour
    preparation is intentionally absent instead of being recovered by shape
    comparison.
    """
    profile = profile_sketch.get("profile") or {}
    source_ids: set[str] = set()
    direct_circle = profile.get("source_entity_id") if profile.get("type") == "circle" else None
    if isinstance(direct_circle, str) and direct_circle:
        source_ids.add(direct_circle)
    for contour in profile.get("contours") or ():
        if not isinstance(contour, dict):
            continue
        for segment in contour.get("segments") or ():
            source_entity_id = segment.get("source_entity_id") if isinstance(segment, dict) else None
            if isinstance(source_entity_id, str) and source_entity_id:
                source_ids.add(source_entity_id)
    return source_ids


def _has_one_exact_retained_source_edge(
    selected: dict[str, Any],
    source: dict[str, Any],
    source_entity_id: str,
) -> bool:
    """Prove one source curve remains one unchanged selected profile edge.

    A bounded IMPRINT region may deliberately omit other source loops while
    retaining an original outer boundary.  That is not a complete-direct-
    profile contract, but it can still supply one source-qualified prism wall
    when the exact curve survives unchanged and the adapter preserves its OCC
    handle.  Do not use labels alone: transformed, split, duplicate, or
    cross-frame curves are not equivalent source edges.
    """
    if selected.get("workplane") != source.get("workplane"):
        return False

    def segments(sketch: dict[str, Any]) -> list[dict[str, Any]]:
        profile = sketch.get("profile") or {}
        if profile.get("type") != "analytic_contours":
            return []
        return [
            segment
            for contour in profile.get("contours") or ()
            if isinstance(contour, dict)
            for segment in contour.get("segments") or ()
            if isinstance(segment, dict) and segment.get("source_entity_id") == source_entity_id
        ]

    source_segments = segments(source)
    selected_segments = segments(selected)
    return len(source_segments) == len(selected_segments) == 1 and selected_segments[0] == source_segments[0]


def _direct_prism_swept_selector(
    value: Any,
    *,
    owner: str,
    selector_kind: str,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    previous: list[str],
    featurescript_version: str | None,
    allow_continuation: bool = False,
    allow_immediate_retained_source_edge: bool = False,
) -> dict[str, Any] | None:
    """Lower one direct source-profile prism query to kernel lineage intent.

    This is deliberately narrower than generic SWEPT support. By default the
    producer must be the immediately preceding independent blind prism. A
    specifically enabled consumer may opt into proven continuation: it still
    requires the complete direct source sketch, and the runtime must prove
    every boundary/continuation edge to the active body. Any
    IMPRINT-derived subset, split source edge, draft, fused result, or other
    generator keeps the existing bounded diagnostic path.
    """
    query = parse_query(value)
    topology = query.topology_type
    if topology not in {"CAP_EDGE", "SWEPT_FACE", "SWEPT_EDGE"}:
        return None
    producer_id = f"f_{owner}"
    producer = feature_by_id.get(producer_id) or {}
    params = producer.get("params") or {}
    frame = feature_frames.get(owner) or {}
    profile_source = frame.get("profile_source")
    profile_sketch = sketches_by_id.get(str(producer.get("sketch_id") or ""))
    source_sketch = sketch_by_source.get(profile_source) if isinstance(profile_source, str) else None
    two_sided_cap_contract = (
        topology == "CAP_EDGE"
        and featurescript_version == "2491"
        and producer.get("atomic_id") == "extrude_add_two_sided"
        and (params.get("reverse_end_condition") or {}).get("type") == "blind"
    )
    if featurescript_version != "1511" and not two_sided_cap_contract:
        return None
    immediate_producer = previous[-1:] == [producer_id]
    result_mode = params.get("result_mode")
    # A primary ADD is represented by the default/fuse result mode. Its
    # direct prism result may continue into the active body only when the
    # runtime's singular OCC union records a complete relation. Lowering
    # keeps the source contract identical to an independent prism; it merely
    # permits the resolver to demand that extra continuation proof.
    is_primary_add = (
        topology == "CAP_EDGE"
        and producer.get("atomic_id") == "extrude_add_blind"
        and result_mode != "new_body"
    )
    direct_profile = _profile_matches_direct_source(profile_sketch or {}, source_sketch or {})
    if (
        producer.get("atomic_id") not in (
            {"extrude_add_two_sided"}
            if two_sided_cap_contract
            else {"extrude_add_blind", "extrude_cut_blind"}
        )
        or (not immediate_producer and (not allow_continuation or producer_id not in previous))
        or (result_mode != "new_body" and not is_primary_add)
        or (params.get("end_condition") or {}).get("type") != "blind"
        or params.get("draft") is not None
        or not isinstance(profile_source, str)
        or source_sketch is None
        or profile_sketch is None
        or profile_sketch.get("source_sketch_id") != profile_source
        or not direct_profile
        and not (
            allow_immediate_retained_source_edge
            and immediate_producer
            and topology == "SWEPT_FACE"
        )
    ):
        return None
    source_ids = _direct_profile_source_entity_ids(profile_sketch)
    refs = _source_refs(value)
    if topology == "CAP_EDGE":
        if (
            selector_kind != "edge"
            or query.is_start is None
            or len(refs) != 1
            or refs[0][0] != profile_source
            or query.source_sketch != profile_source
            or query.source_entity != refs[0][1]
            or refs[0][1] not in source_ids
        ):
            return None
        entity = (entity_by_sketch.get(profile_source) or {}).get(refs[0][1])
        if not entity or entity.get("construction"):
            return None
        intent = _selector_intent(
            value,
            query_family="CAP_EDGE",
            kind="edge",
            evidence="kernel_history",
            allowed=("boundary",) if two_sided_cap_contract else (
                ("boundary", "continuation") if (allow_continuation or is_primary_add) else ("boundary",)
            ),
        )
        intent["lineage_role"] = f"extrude.{'start' if query.is_start else 'end'}"
        return {
            "kind": "edge",
            "owner_feature_id": producer_id,
            "source": "runtime_snapshot",
            "confidence": 1.0,
            "selector_intent": intent,
        }
    if topology == "SWEPT_FACE":
        if (
            selector_kind != "face"
            or len(refs) != 1
            or refs[0][0] != profile_source
            or query.source_sketch != profile_source
            or query.source_entity != refs[0][1]
            or refs[0][1] not in source_ids
        ):
            return None
        entity = (entity_by_sketch.get(profile_source) or {}).get(refs[0][1])
        if not entity or entity.get("construction"):
            return None
        retained_source_edge = not direct_profile
        if retained_source_edge and not _has_one_exact_retained_source_edge(
            profile_sketch, source_sketch, refs[0][1],
        ):
            return None
        intent = _selector_intent(
            value,
            query_family="SWEPT_FACE",
            kind="face",
            evidence="kernel_history",
            allowed=("boundary",) if retained_source_edge else (
                ("boundary", "continuation") if allow_continuation else ("boundary",)
            ),
        )
        if retained_source_edge:
            intent["consumer_contract"] = "immediate_retained_source_prism_swept_face_up_to_surface"
        return {
            "kind": "face",
            "owner_feature_id": producer_id,
            "source": "runtime_snapshot",
            "confidence": 1.0,
            "selector_intent": intent,
        }
    if selector_kind != "edge" or len(refs) < 2 or {source for source, _token in refs} != {profile_source}:
        return None
    resolved_ids: list[str] = []
    for source, token in refs:
        resolved = _source_ref_entity(source, token, entity_by_sketch)
        if resolved is None:
            return None
        entity_id, entity = resolved
        if entity.get("construction") or entity_id not in source_ids:
            return None
        if entity_id not in resolved_ids:
            resolved_ids.append(entity_id)
    if len(resolved_ids) < 2 or _shared_source_endpoint(refs, profile_source, entity_by_sketch) is None:
        return None
    intent = _selector_intent(
        value,
        query_family="SWEPT_EDGE",
        kind="edge",
        evidence="kernel_history",
        allowed=("boundary", "continuation") if allow_continuation else ("boundary",),
    )
    intent.pop("source_entity", None)
    intent["source_entities"] = [
        {"sketch_id": profile_source, "entity_id": entity_id}
        for entity_id in sorted(resolved_ids)
    ]
    return {
        "kind": "edge",
        "owner_feature_id": producer_id,
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "selector_intent": intent,
    }


def _direct_prism_shell_offset_edge_tdd_selector(
    value: Any,
    *,
    owner: str,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    previous: list[str],
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Lower one retained direct-prism cap edge from an outer shell OFFSET_EDGE.

    The TDD form is not a request for the shell's inner wall.  It names a
    CAP_EDGE on the cap retained by an immediately following shell, so the
    executable witness is the direct-prism cap boundary followed by one exact
    shell continuation.  OSD-only pairs, generated inner-wall edges, and
    delayed shell consumers deliberately remain deferred.
    """
    if featurescript_version != "1511":
        return None
    try:
        _call, shell_owner, topology, kind, definition = _direct_make_query(value)
    except ValueError:
        return None
    if shell_owner != owner or topology != "OFFSET_EDGE" or kind not in {"edge", "entitytype.edge"}:
        return None
    disambiguation = definition.get("disambiguationData")
    if not isinstance(disambiguation, list) or len(disambiguation) != 2:
        return None
    original_set, tdd = disambiguation
    if (
        not isinstance(original_set, Call) or original_set.name != "OSD" or len(original_set.args) != 1
        or not isinstance(original_set.args[0], list) or len(original_set.args[0]) != 1
        or not isinstance(tdd, Call) or tdd.name != "TDD" or len(tdd.args) != 1
        or not isinstance(tdd.args[0], list) or len(tdd.args[0]) != 1
    ):
        return None
    outer_refs = _source_refs(original_set)
    nested = tdd.args[0][0]
    try:
        _nested_call, producer_owner, nested_topology, nested_kind, nested_definition = _direct_make_query(nested)
    except ValueError:
        return None
    if nested_topology != "CAP_EDGE" or nested_kind not in {"edge", "entitytype.edge"}:
        return None
    nested_disambiguation = nested_definition.get("disambiguationData")
    if (
        len(outer_refs) != 1
        or not isinstance(nested_disambiguation, list) or len(nested_disambiguation) != 1
        or not isinstance(nested_disambiguation[0], Call) or nested_disambiguation[0].name != "OSD"
        or len(nested_disambiguation[0].args) != 1
        or not isinstance(nested_disambiguation[0].args[0], list) or len(nested_disambiguation[0].args[0]) != 1
        or _source_refs(nested_disambiguation[0]) != outer_refs
    ):
        return None
    cap_selector = _direct_prism_swept_selector(
        nested,
        owner=producer_owner,
        selector_kind="edge",
        feature_by_id=feature_by_id,
        feature_frames=feature_frames,
        sketch_by_source=sketch_by_source,
        sketches_by_id=sketches_by_id,
        entity_by_sketch=entity_by_sketch,
        previous=previous,
        featurescript_version=featurescript_version,
        allow_continuation=True,
    )
    if cap_selector is None:
        return None
    producer_id = f"f_{producer_owner}"
    shell_id = f"f_{shell_owner}"
    shell = feature_by_id.get(shell_id) or {}
    cap_intent = cap_selector.get("selector_intent") or {}
    cap_role = cap_intent.get("lineage_role")
    shell_selectors = shell.get("selectors") or []
    if (
        previous[-1:] != [shell_id]
        or shell.get("atomic_id") != "shell"
        or shell.get("depends_on") != [producer_id]
        or (shell.get("params") or {}).get("inward") is not True
        or len(shell_selectors) != 1
        or not isinstance(shell_selectors[0], dict)
        or shell_selectors[0].get("owner_feature_id") != producer_id
        or shell_selectors[0].get("output_role")
        != ("extrude.end" if cap_role == "extrude.start" else "extrude.start")
    ):
        return None
    source_entity = cap_intent.get("source_entity")
    if not isinstance(source_entity, dict):
        return None
    intent = _selector_intent(
        value,
        query_family="OFFSET_EDGE",
        kind="edge",
        evidence="kernel_history",
        allowed=("boundary", "continuation"),
        disambiguation={
            "type": "offset_edge_tdd_cap_continuation",
            "shell_feature_id": shell_id,
            "outer_owner_feature_id": shell_id,
            "tdd_cap_owner_feature_id": producer_id,
            "tdd_cap_role": cap_role,
            "source_entity": dict(source_entity),
        },
    )
    intent["source_entity"] = dict(source_entity)
    intent["lineage_role"] = cap_role
    intent["consumer_contract"] = "direct_prism_shell_offset_edge_tdd"
    return {
        "kind": "edge",
        "owner_feature_id": producer_id,
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "selector_intent": intent,
    }


def _direct_prism_shell_offset_edge_vertex_selector(
    value: Any,
    *,
    owner: str,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    previous: list[str],
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Lower an OSD-only shell ``OFFSET_EDGE`` anchored at one profile vertex.

    This is deliberately distinct from the retained-cap TDD form. Two
    incident source profile edges name one source vertex, whose direct-prism
    swept edge must survive the immediately following shell by a complete
    kernel continuation. A shell-wall generated from a removed cap edge is
    neither this source vertex nor a substitute for it.
    """
    if featurescript_version != "1511":
        return None
    try:
        _call, shell_owner, topology, kind, definition = _direct_make_query(value)
    except ValueError:
        return None
    if shell_owner != owner or topology != "OFFSET_EDGE" or kind not in {"edge", "entitytype.edge"}:
        return None
    disambiguation = definition.get("disambiguationData")
    if (
        not isinstance(disambiguation, list) or len(disambiguation) != 1
        or not isinstance(disambiguation[0], Call) or disambiguation[0].name != "OSD"
        or len(disambiguation[0].args) != 1 or not isinstance(disambiguation[0].args[0], list)
    ):
        return None
    refs = _source_refs(disambiguation[0])
    shell_id = f"f_{shell_owner}"
    shell = feature_by_id.get(shell_id) or {}
    depends_on = shell.get("depends_on") or []
    if previous[-1:] != [shell_id] or len(depends_on) != 1:
        return None
    producer_id = depends_on[0]
    producer = feature_by_id.get(producer_id) or {}
    producer_owner = producer_id.removeprefix("f_")
    frame = feature_frames.get(producer_owner) or {}
    profile_source = frame.get("profile_source")
    profile_sketch = sketches_by_id.get(str(producer.get("sketch_id") or ""))
    source_sketch = sketch_by_source.get(profile_source) if isinstance(profile_source, str) else None
    params = producer.get("params") or {}
    source_ids = _direct_profile_source_entity_ids(profile_sketch or {})
    if (
        producer.get("atomic_id") != "extrude_add_blind"
        or params.get("result_mode") != "new_body"
        or (params.get("end_condition") or {}).get("type") != "blind"
        or params.get("draft") is not None
        or not isinstance(profile_source, str)
        or source_sketch is None
        or profile_sketch is None
        or profile_sketch.get("source_sketch_id") != profile_source
        or not _profile_matches_direct_source(profile_sketch, source_sketch)
        or len(refs) != 2
        or {source for source, _token in refs} != {profile_source}
        or _shared_source_endpoint(refs, profile_source, entity_by_sketch) is None
    ):
        return None
    resolved_ids: list[str] = []
    for source, token in refs:
        resolved = _source_ref_entity(source, token, entity_by_sketch)
        if resolved is None:
            return None
        entity_id, entity = resolved
        if entity.get("construction") or entity_id not in source_ids or entity_id in resolved_ids:
            return None
        resolved_ids.append(entity_id)
    shell_selectors = shell.get("selectors") or []
    if (
        shell.get("atomic_id") != "shell"
        or (shell.get("params") or {}).get("inward") is not True
        or len(shell_selectors) != 1
        or not isinstance(shell_selectors[0], dict)
        or shell_selectors[0].get("kind") != "face"
        or shell_selectors[0].get("owner_feature_id") != producer_id
        or shell_selectors[0].get("output_role") not in {"extrude.start", "extrude.end"}
    ):
        return None
    source_entities = [
        {"sketch_id": profile_source, "entity_id": entity_id}
        for entity_id in sorted(resolved_ids)
    ]
    intent = _selector_intent(
        value,
        query_family="OFFSET_EDGE",
        kind="edge",
        evidence="kernel_history",
        allowed=("boundary", "continuation"),
        disambiguation={
            "type": "offset_edge_vertex_continuation",
            "shell_feature_id": shell_id,
            "outer_owner_feature_id": shell_id,
            "prism_owner_feature_id": producer_id,
            "removed_cap_role": shell_selectors[0]["output_role"],
            "source_entities": source_entities,
        },
    )
    intent.pop("source_entity", None)
    intent["source_entities"] = source_entities
    intent["consumer_contract"] = "direct_prism_shell_offset_edge_vertex"
    return {
        "kind": "edge",
        "owner_feature_id": producer_id,
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "selector_intent": intent,
    }


def _direct_blend_edge_selector(
    value: Any,
    *,
    owner: str,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    previous: list[str],
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Lower one exact direct-prism dress-up ``BLEND_EDGE`` source tuple.

    The FeatureScript query names both the original edge and the original face
    that the first dress-up blends into.  Retain those source semantics rather
    than collapsing the result to a nearby patch boundary edge.  This accepts
    only one source edge, one complete direct-prism CAP_FACE or same-anchor
    SWEPT_FACE, and one immediate native fillet/chamfer producer; split,
    merge/COPY and mixed query sets stay deferred for a later component
    contract.
    """
    try:
        _call, outer_owner, topology, kind, definition = _direct_make_query(value)
    except ValueError:
        return None
    if topology != "BLEND_EDGE" or kind not in {"edge", "entitytype.edge"} or outer_owner != owner:
        return None
    blended_from = definition.get("blendedFrom")
    blended_into = definition.get("blendedInto")
    if not isinstance(blended_from, list) or len(blended_from) != 2 or not isinstance(blended_into, list) or len(blended_into) != 1:
        return None
    edge_value, source_face_value = blended_from
    target_face_value = blended_into[0]
    try:
        _edge_call, edge_owner, edge_topology, edge_kind, _edge_definition = _direct_make_query(edge_value)
        _face_call, face_owner, face_topology, face_kind, _face_definition = _direct_make_query(source_face_value)
        _target_call, target_owner, target_topology, target_kind, _target_definition = _direct_make_query(target_face_value)
    except ValueError:
        return None
    face_family = face_topology if face_topology == target_topology else None
    if (
        edge_topology != "CAP_EDGE" or edge_kind not in {"edge", "entitytype.edge"}
        or face_family not in {"CAP_FACE", "SWEPT_FACE"}
        or face_kind not in {"face", "entitytype.face"}
        or target_kind not in {"face", "entitytype.face"}
        or len({edge_owner, face_owner, target_owner}) != 1
    ):
        return None
    source_feature_id = f"f_{edge_owner}"
    dressup_feature_id = f"f_{owner}"
    dressup = feature_by_id.get(dressup_feature_id) or {}
    if (
        previous[-1:] != [dressup_feature_id]
        or dressup.get("atomic_id") not in {"fillet", "chamfer"}
        or source_feature_id not in previous
    ):
        return None
    edge_selector = _direct_prism_swept_selector(
        edge_value,
        owner=edge_owner,
        selector_kind="edge",
        feature_by_id=feature_by_id,
        feature_frames=feature_frames,
        sketch_by_source=sketch_by_source,
        sketches_by_id=sketches_by_id,
        entity_by_sketch=entity_by_sketch,
        previous=previous,
        featurescript_version=featurescript_version,
        allow_continuation=True,
    )
    if face_family == "CAP_FACE":
        source_face_selector = _cap_face_output_role_selector(
            source_face_value, feature_by_id, sketches_by_id,
        )
        target_face_selector = _cap_face_output_role_selector(
            target_face_value, feature_by_id, sketches_by_id,
        )
    else:
        source_face_selector = _direct_prism_swept_selector(
            source_face_value,
            owner=face_owner,
            selector_kind="face",
            feature_by_id=feature_by_id,
            feature_frames=feature_frames,
            sketch_by_source=sketch_by_source,
            sketches_by_id=sketches_by_id,
            entity_by_sketch=entity_by_sketch,
            previous=previous,
            featurescript_version=featurescript_version,
            allow_continuation=True,
        )
        target_face_selector = _direct_prism_swept_selector(
            target_face_value,
            owner=target_owner,
            selector_kind="face",
            feature_by_id=feature_by_id,
            feature_frames=feature_frames,
            sketch_by_source=sketch_by_source,
            sketches_by_id=sketches_by_id,
            entity_by_sketch=entity_by_sketch,
            previous=previous,
            featurescript_version=featurescript_version,
            allow_continuation=True,
        )
    if edge_selector is None or source_face_selector is None or target_face_selector is None:
        return None
    edge_intent = edge_selector.get("selector_intent") or {}
    source_face_intent = source_face_selector.get("selector_intent") or {}
    target_face_intent = target_face_selector.get("selector_intent") or {}
    if (
        edge_intent.get("query_family") != "CAP_EDGE"
        or source_face_intent.get("query_family") != face_family
        or target_face_intent.get("query_family") != face_family
        or source_face_selector.get("owner_feature_id") != source_feature_id
        or target_face_selector.get("owner_feature_id") != source_feature_id
    ):
        return None
    if face_family == "CAP_FACE" and source_face_selector.get("output_role") != target_face_selector.get("output_role"):
        return None
    source_profile = sketches_by_id.get(str((feature_by_id.get(source_feature_id) or {}).get("sketch_id") or "")) or {}
    source_profile_ids = _direct_profile_source_entity_ids(source_profile)
    source_sketch_id = (feature_frames.get(edge_owner) or {}).get("profile_source")
    if face_family == "CAP_FACE":
        source_refs = _source_refs(source_face_value)
        target_refs = _source_refs(target_face_value)
        required_refs = {(source_sketch_id, entity_id) for entity_id in source_profile_ids}
        if (
            not isinstance(source_sketch_id, str)
            or not source_profile_ids
            or set(source_refs) != required_refs
            or set(target_refs) != required_refs
            or len(source_refs) != len(source_profile_ids)
            or len(target_refs) != len(source_profile_ids)
        ):
            return None
    edge_source = edge_intent.get("source_entity")
    edge_role = edge_intent.get("lineage_role")
    face_source_entity = source_face_intent.get("source_entity")
    target_face_entity = target_face_intent.get("source_entity")
    face_role = source_face_selector.get("output_role")
    if not isinstance(edge_source, dict) or edge_role not in {"extrude.start", "extrude.end"}:
        return None
    if face_family == "CAP_FACE":
        if face_role not in {"extrude.start", "extrude.end"}:
            return None
    elif not isinstance(face_source_entity, dict) or face_source_entity != target_face_entity:
        return None
    intent = _selector_intent(
        value,
        query_family="BLEND_EDGE",
        kind="edge",
        evidence="kernel_history",
        allowed=("boundary",),
    )
    intent["blend_sources"] = {
        "edge": {
            "query_family": "CAP_EDGE",
            "owner_feature_id": source_feature_id,
            "source_entity": dict(edge_source),
            "lineage_role": edge_role,
        },
        "face": (
            {
                "query_family": "CAP_FACE",
                "owner_feature_id": source_feature_id,
                "output_role": face_role,
            }
            if face_family == "CAP_FACE" else {
                "query_family": "SWEPT_FACE",
                "owner_feature_id": source_feature_id,
                "source_entity": dict(face_source_entity),
            }
        ),
    }
    return {
        "kind": "edge",
        "owner_feature_id": dressup_feature_id,
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "selector_intent": intent,
    }


def _direct_prism_blend_face_attachment(
    value: Any,
    *,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    previous: list[str],
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Attach one immediate direct-prism ``BLEND_FACE`` sketch at runtime.

    ``BLEND_FACE`` is the patch generated by a dress-up input edge, rather
    than an arbitrary face adjacent to that edge.  Accept it only when the
    preceding native dress-up already selected one role-qualified direct-prism
    cap edge.  The runtime then requires that exact ``Generated(edge ->
    patch_face)`` relation in the active snapshot before it materializes the
    sketch frame.
    """
    if featurescript_version != "1511":
        return None
    try:
        _call, dressup_owner, topology, kind, definition = _direct_make_query(value)
    except ValueError:
        return None
    refs = _source_refs(definition.get("disambiguationData"))
    dressup_id = f"f_{dressup_owner}"
    dressup = feature_by_id.get(dressup_id) or {}
    if (
        topology != "BLEND_FACE"
        or kind not in {"face", "entitytype.face"}
        or previous[-1:] != [dressup_id]
        or dressup.get("atomic_id") not in {"fillet", "chamfer"}
        or len(dressup.get("depends_on") or ()) != 1
        or len(refs) != 1
    ):
        return None
    source_sketch_id, source_token = refs[0]
    resolved_source = _source_ref_entity(source_sketch_id, source_token, entity_by_sketch)
    if resolved_source is None or resolved_source[0] != source_token:
        return None
    source_entity_id, source_entity = resolved_source
    producer_id = (dressup.get("depends_on") or [None])[0]
    producer = feature_by_id.get(str(producer_id)) or {}
    params = producer.get("params") or {}
    profile = sketches_by_id.get(str(producer.get("sketch_id") or ""))
    source_sketch = sketch_by_source.get(source_sketch_id)
    if (
        not isinstance(producer_id, str)
        or producer.get("atomic_id") != "extrude_add_blind"
        or params.get("result_mode") != "new_body"
        or (params.get("end_condition") or {}).get("type") != "blind"
        or params.get("draft") is not None
        or profile is None
        or source_sketch is None
        or profile.get("source_sketch_id") != source_sketch_id
        or not _profile_matches_direct_source(profile, source_sketch)
        or source_entity.get("construction")
        or source_entity_id not in _direct_profile_source_entity_ids(profile)
    ):
        return None

    def leaves(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
        output: list[dict[str, Any]] = []
        for selector in items:
            nested = selector.get("query_operands")
            if isinstance(nested, list):
                output.extend(leaves([item for item in nested if isinstance(item, dict)]))
            else:
                output.append(selector)
        return output

    matches = []
    for selector in leaves([item for item in dressup.get("selectors") or () if isinstance(item, dict)]):
        intent = selector.get("selector_intent") or {}
        if (
            selector.get("kind") == "edge"
            and selector.get("owner_feature_id") == producer_id
            and selector.get("source") == "runtime_snapshot"
            and intent.get("query_family") == "CAP_EDGE"
            and intent.get("source_entity") == {
                "sketch_id": source_sketch_id,
                "entity_id": source_entity_id,
            }
            and intent.get("lineage_role") in {"extrude.start", "extrude.end"}
        ):
            matches.append(selector)
    if len(matches) != 1:
        return None
    cap_intent = matches[0]["selector_intent"]
    intent = _selector_intent(
        value,
        query_family="BLEND_FACE",
        kind="face",
        evidence="kernel_history",
        allowed=("boundary",),
    )
    intent["blend_face_source"] = {
        "query_family": "CAP_EDGE",
        "owner_feature_id": producer_id,
        "source_entity": dict(cap_intent["source_entity"]),
        "lineage_role": cap_intent["lineage_role"],
    }
    return {
        "kind": "face",
        "owner_feature_id": dressup_id,
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "selector_intent": intent,
    }


def _direct_full_revolve_swept_edge_selector(
    value: Any,
    *,
    owner: str,
    selector_kind: str,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    previous: list[str],
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Lower one full-revolve source vertex to exact ``MakeRevol`` history.

    This is intentionally separate from the direct-prism contract. A full
    independent solid revolve has one usable native witness only:
    ``BRepPrimAPI_MakeRevol.Generated(source_vertex)``. The profile vertex is
    identified by the complete incident set in the FeatureScript OSD query;
    circle centre/radius remains diagnostic geometry and never binds the edge.
    """
    query = parse_query(value)
    if query.topology_type != "SWEPT_EDGE" or selector_kind != "edge":
        return None
    # The full-revolve contract is separately registered for each source
    # tuple. Do not infer other revisions from a merely similar makeQuery AST.
    if featurescript_version not in {"1511", "2491"}:
        return None
    producer_id = f"f_{owner}"
    producer = feature_by_id.get(producer_id) or {}
    frame = feature_frames.get(owner) or {}
    profile_source = frame.get("profile_source")
    profile_sketch = sketches_by_id.get(str(producer.get("sketch_id") or ""))
    source_sketch = sketch_by_source.get(profile_source) if isinstance(profile_source, str) else None
    if (
        producer.get("atomic_id") != "revolve_add"
        or (producer.get("params") or {}).get("result_mode") != "new_body"
        or not frame.get("revolve_full")
        or not isinstance(frame.get("revolve_axis"), dict)
        or producer_id not in previous
        or not isinstance(profile_source, str)
        or source_sketch is None
        or profile_sketch is None
        or profile_sketch.get("source_sketch_id") != profile_source
        or not _profile_matches_direct_source(profile_sketch, source_sketch)
        or frame.get("revolve_profile_contract") not in {
            "original_source",
            "verified_complete_materialization",
        }
        # The 1511 contract does not let an IMPRINT profile borrow the source
        # sketch's vertex identities merely because lowering reuses equal
        # profile data.  2491 separately admits its verified complete form.
        or (
            featurescript_version == "1511"
            and frame.get("revolve_profile_contract") != "original_source"
        )
    ):
        return None
    refs = _source_refs(value)
    if len(refs) < 2 or {source for source, _token in refs} != {profile_source}:
        return None
    source_ids = _direct_profile_source_entity_ids(profile_sketch)
    resolved_ids: list[str] = []
    for source, token in refs:
        resolved = _source_ref_entity(source, token, entity_by_sketch)
        if resolved is None:
            return None
        entity_id, entity = resolved
        if entity.get("construction") or entity_id not in source_ids:
            return None
        if entity_id not in resolved_ids:
            resolved_ids.append(entity_id)
    if len(resolved_ids) < 2 or _shared_source_endpoint(refs, profile_source, entity_by_sketch) is None:
        return None
    intent = _selector_intent(
        value,
        query_family="SWEPT_EDGE",
        kind="edge",
        evidence="kernel_history",
        # Earlier dress-ups may preserve this edge through exact one-to-one
        # OCC history. The resolver rejects any split, merge or missing branch.
        allowed=("boundary", "continuation"),
    )
    intent.pop("source_entity", None)
    intent["source_entities"] = [
        {"sketch_id": profile_source, "entity_id": entity_id}
        for entity_id in sorted(resolved_ids)
    ]
    return {
        "kind": "edge",
        "owner_feature_id": producer_id,
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "selector_intent": intent,
    }


def _direct_primary_cut_copy_cap_edge_selector(
    value: Any,
    *,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    previous: list[str],
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Lower one primary-cut ``COPY(CAP_EDGE)`` to its proven input lineage.

    FeatureScript's boolean COPY query is not permission to select a similar
    final edge. This narrow form keeps its outer COPY AST and delegates only
    its explicit CAP_EDGE source to the transient-prism and cut-builder chain
    already registered in the same replay. The tool is never active topology.
    """
    if featurescript_version != "1511":
        return None
    try:
        _outer_call, owner, topology, kind, definition = _direct_make_query(value)
    except ValueError:
        return None
    derived = definition.get("derivedFrom") if isinstance(definition, dict) else None
    if topology != "COPY" or kind not in {"edge", "entitytype.edge"} or derived is None:
        return None
    try:
        _inner_call, inner_owner, inner_topology, inner_kind, _inner_definition = _direct_make_query(derived)
    except ValueError:
        return None
    producer_id = f"f_{owner}"
    producer = feature_by_id.get(producer_id) or {}
    params = producer.get("params") or {}
    frame = feature_frames.get(owner) or {}
    profile_source = frame.get("profile_source")
    profile_sketch = sketches_by_id.get(str(producer.get("sketch_id") or ""))
    source_sketch = sketch_by_source.get(profile_source) if isinstance(profile_source, str) else None
    inner_query = parse_query(derived)
    refs = _source_refs(derived)
    if (
        inner_owner != owner
        or inner_topology != "CAP_EDGE"
        or inner_kind not in {"edge", "entitytype.edge"}
        or inner_query.is_start is None
        or previous[-1:] != [producer_id]
        or producer.get("atomic_id") != "extrude_cut_blind"
        or params.get("result_mode") is not None
        or (params.get("end_condition") or {}).get("type") != "blind"
        or params.get("draft") is not None
        or not isinstance(profile_source, str)
        or source_sketch is None
        or profile_sketch is None
        or profile_sketch.get("source_sketch_id") != profile_source
        or not _profile_matches_direct_source(profile_sketch, source_sketch)
        or len(refs) != 1
        or refs[0][0] != profile_source
        or inner_query.source_sketch != profile_source
        or inner_query.source_entity != refs[0][1]
        or refs[0][1] not in _direct_profile_source_entity_ids(profile_sketch)
    ):
        return None
    entity = (entity_by_sketch.get(profile_source) or {}).get(refs[0][1])
    if not entity or entity.get("construction"):
        return None
    input_intent = _selector_intent(
        derived,
        query_family="CAP_EDGE",
        kind="edge",
        evidence="kernel_history",
        allowed=("boundary", "continuation"),
    )
    input_intent["lineage_role"] = f"extrude.{'start' if inner_query.is_start else 'end'}"
    intent = _selector_intent(
        value,
        query_family="COPY",
        kind="edge",
        evidence="kernel_history",
        allowed=("boundary", "continuation"),
    )
    # The anchor belongs to the nested CAP_EDGE, not the outer boolean COPY.
    intent.pop("source_entity", None)
    intent["copy_contract"] = "primary_cut_cap_edge"
    return {
        "kind": "edge",
        "owner_feature_id": producer_id,
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "query_input": {
            "kind": "edge",
            "owner_feature_id": producer_id,
            "source": "runtime_snapshot",
            "confidence": 1.0,
            "selector_intent": input_intent,
        },
        "selector_intent": intent,
    }


def _direct_primary_cut_copy_cap_face_attachment(
    value: Any,
    *,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    previous: list[str],
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Lower an immediate primary-cut ``COPY(CAP_FACE)`` sketch attachment.

    The emitted selector names no face by geometry or static cap frame.  It
    instead requires the runtime to prove the direct tool cap and its exact
    same-owner subtract successor before materializing the sketch workplane.
    """
    if featurescript_version != "1511":
        return None
    try:
        _outer, owner, topology, kind, definition = _direct_make_query(value)
    except ValueError:
        return None
    derived = definition.get("derivedFrom") if isinstance(definition, dict) else None
    if topology != "COPY" or kind not in {"face", "entitytype.face"} or derived is None:
        return None
    try:
        _inner, inner_owner, inner_topology, inner_kind, _inner_definition = _direct_make_query(derived)
    except ValueError:
        return None
    producer_id = f"f_{owner}"
    producer = feature_by_id.get(producer_id) or {}
    params = producer.get("params") or {}
    frame = feature_frames.get(owner) or {}
    profile_source = frame.get("profile_source")
    profile_sketch = sketches_by_id.get(str(producer.get("sketch_id") or ""))
    source_sketch = sketch_by_source.get(profile_source) if isinstance(profile_source, str) else None
    inner_query = parse_query(derived)
    refs = _source_refs(derived)
    source_ids = _direct_profile_source_entity_ids(profile_sketch or {})
    if (
        inner_owner != owner
        or inner_topology != "CAP_FACE"
        or inner_kind not in {"face", "entitytype.face"}
        or inner_query.is_start is None
        or previous[-1:] != [producer_id]
        or producer.get("atomic_id") != "extrude_cut_blind"
        or params.get("result_mode") is not None
        or (params.get("end_condition") or {}).get("type") != "blind"
        or params.get("draft") is not None
        or not isinstance(profile_source, str)
        or source_sketch is None
        or profile_sketch is None
        or profile_sketch.get("source_sketch_id") != profile_source
        or not _profile_matches_direct_source(profile_sketch, source_sketch)
        or not source_ids
        or len(refs) != len(source_ids)
        or {source for source, _token in refs} != {profile_source}
        or {token for _source, token in refs} != source_ids
    ):
        return None
    for entity_id in source_ids:
        entity = (entity_by_sketch.get(profile_source) or {}).get(entity_id)
        if not entity or entity.get("construction"):
            return None
    role = f"extrude.{'start' if inner_query.is_start else 'end'}"
    input_intent = _selector_intent(
        derived, query_family="CAP_FACE", kind="face", evidence="kernel_history",
        allowed=("boundary", "continuation"),
    )
    input_intent.pop("source_entity", None)
    input_intent["source_entities"] = [
        {"sketch_id": profile_source, "entity_id": entity_id} for entity_id in sorted(source_ids)
    ]
    input_intent["lineage_role"] = role
    intent = _selector_intent(
        value, query_family="COPY", kind="face", evidence="kernel_history",
        allowed=("boundary", "continuation"),
    )
    intent.pop("source_entity", None)
    intent["copy_contract"] = "primary_cut_cap_face_workplane"
    return {
        "kind": "face", "owner_feature_id": producer_id,
        "source": "runtime_snapshot", "confidence": 1.0,
        "query_input": {
            "kind": "face", "owner_feature_id": producer_id,
            "source": "runtime_snapshot", "confidence": 1.0,
            "selector_intent": input_intent,
        },
        "selector_intent": intent,
    }


def _direct_prism_cap_face_attachment(
    value: Any,
    *,
    feature_by_id: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    previous: list[str],
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Attach a following sketch to one exact direct-prism cap at runtime.

    The direct CAP role is a builder result, not a copied static workplane.
    This bridge intentionally applies only while the independent blind prism
    remains the immediately preceding active body.  It does not interpret
    CAP_EDGE, boolean successors, or an attached profile's future splitter
    boundary; those need their own source-qualified contracts.
    """
    if featurescript_version != "1511":
        return None
    try:
        _call, _owner, topology, kind, _definition = _direct_make_query(value)
    except ValueError:
        return None
    if topology != "CAP_FACE" or kind not in {"face", "entitytype.face"}:
        return None
    selector = _cap_face_output_role_selector(value, feature_by_id, sketches_by_id)
    if selector is None or previous[-1:] != [selector.get("owner_feature_id")]:
        return None
    intent = selector.get("selector_intent") or {}
    if (
        selector.get("kind") != "face"
        or selector.get("output_role") not in {"extrude.start", "extrude.end"}
        or intent.get("query_family") != "CAP_FACE"
        or intent.get("evidence") != "operation_role"
        or intent.get("consumer_contract") is not None
    ):
        return None
    intent["consumer_contract"] = "direct_prism_cap_face_workplane"
    return selector


def _direct_primary_cut_copy_swept_face_attachment(
    value: Any,
    *,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    previous: list[str],
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Lower one direct primary-cut ``COPY(SWEPT_FACE)`` sketch attachment.

    The source edge is only an anchor for the cut tool's native prism history.
    The eventual workplane is materialized exclusively from the exact active
    face reached through that tool face's same-owner subtract continuation.
    """
    if featurescript_version != "1511":
        return None
    try:
        _outer, owner, topology, kind, definition = _direct_make_query(value)
    except ValueError:
        return None
    derived = definition.get("derivedFrom") if isinstance(definition, dict) else None
    if topology != "COPY" or kind not in {"face", "entitytype.face"} or derived is None:
        return None
    try:
        _inner, inner_owner, inner_topology, inner_kind, _inner_definition = _direct_make_query(derived)
    except ValueError:
        return None
    producer_id = f"f_{owner}"
    producer = feature_by_id.get(producer_id) or {}
    params = producer.get("params") or {}
    frame = feature_frames.get(owner) or {}
    profile_source = frame.get("profile_source")
    profile_sketch = sketches_by_id.get(str(producer.get("sketch_id") or ""))
    source_sketch = sketch_by_source.get(profile_source) if isinstance(profile_source, str) else None
    refs = _source_refs(derived)
    if (
        inner_owner != owner
        or inner_topology != "SWEPT_FACE"
        or inner_kind not in {"face", "entitytype.face"}
        or previous[-1:] != [producer_id]
        or producer.get("atomic_id") != "extrude_cut_blind"
        or params.get("result_mode") is not None
        or (params.get("end_condition") or {}).get("type") != "blind"
        or params.get("draft") is not None
        or not isinstance(profile_source, str)
        or source_sketch is None
        or profile_sketch is None
        or profile_sketch.get("source_sketch_id") != profile_source
        or not _profile_matches_direct_source(profile_sketch, source_sketch)
        or len(refs) != 1
        or refs[0][0] != profile_source
        or refs[0][1] not in _direct_profile_source_entity_ids(profile_sketch)
    ):
        return None
    entity = (entity_by_sketch.get(profile_source) or {}).get(refs[0][1])
    if not entity or entity.get("construction"):
        return None
    input_intent = _selector_intent(
        derived, query_family="SWEPT_FACE", kind="face", evidence="kernel_history",
        allowed=("boundary", "continuation"),
    )
    input_intent["source_entity"] = {"sketch_id": refs[0][0], "entity_id": refs[0][1]}
    intent = _selector_intent(
        value, query_family="COPY", kind="face", evidence="kernel_history",
        allowed=("boundary", "continuation"),
    )
    intent.pop("source_entity", None)
    intent["copy_contract"] = "primary_cut_swept_face_workplane"
    return {
        "kind": "face", "owner_feature_id": producer_id,
        "source": "runtime_snapshot", "confidence": 1.0,
        "query_input": {
            "kind": "face", "owner_feature_id": producer_id,
            "source": "runtime_snapshot", "confidence": 1.0,
            "selector_intent": input_intent,
        },
        "selector_intent": intent,
    }


def _planar_imprint_prism_selector(
    value: Any,
    *,
    owner: str,
    selector_kind: str,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    previous: list[str],
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Lower a bounded IMPRINT prism query only when its source set is exact.

    An IMPRINT profile may split one FeatureScript curve into several selected
    B-rep fragments.  The adapter records each exact fragment and the resolver
    must return the complete set.  This helper therefore does not reuse the
    direct-profile one-to-one contract or turn a set-valued query into an
    arbitrary geometric candidate.
    """
    query = parse_query(value)
    topology = query.topology_type
    if topology not in {"CAP_FACE", "SWEPT_FACE", "SWEPT_EDGE"} or featurescript_version != "1511":
        return None
    producer_id = f"f_{owner}"
    producer = feature_by_id.get(producer_id) or {}
    params = producer.get("params") or {}
    frame = feature_frames.get(owner) or {}
    profile_source = frame.get("profile_source")
    profile_sketch = sketches_by_id.get(str(producer.get("sketch_id") or ""))
    profile = (profile_sketch or {}).get("profile") or {}
    if (
        producer.get("atomic_id") not in {"extrude_add_blind", "extrude_cut_blind"}
        or previous[-1:] != [producer_id]
        or params.get("result_mode") != "new_body"
        or (params.get("end_condition") or {}).get("type") != "blind"
        or params.get("draft") is not None
        or not isinstance(profile_source, str)
        or profile_sketch is None
        or profile_sketch.get("source_sketch_id") != profile_source
        or profile.get("type") != "planar_imprint"
    ):
        return None
    source_ids = {
        str(entry.get("id"))
        for entry in profile.get("source_entities") or ()
        if isinstance(entry, dict) and isinstance(entry.get("id"), str) and entry.get("id")
    }
    refs = list(dict.fromkeys(_source_refs(value)))
    if not source_ids or not refs or {sketch_id for sketch_id, _entity_id in refs} != {profile_source}:
        return None
    ref_ids = {entity_id for _sketch_id, entity_id in refs}
    if not ref_ids.issubset(source_ids):
        return None

    if topology == "CAP_FACE":
        if selector_kind != "face" or query.is_start is None or ref_ids != source_ids:
            return None
        intent = _selector_intent(
            value,
            query_family="CAP_FACE",
            kind="face",
            evidence="kernel_history",
            allowed=("boundary", "fragment"),
            multiplicity="all_fragments",
        )
        # The complete OSD source set proves the output role. Its last parsed
        # source token is diagnostic context, not a single-edge CAP anchor.
        intent.pop("source_entity", None)
        output_role = f"extrude.{'start' if query.is_start else 'end'}"
        intent["output_role"] = output_role
        intent["disambiguation"] = {
            "type": "complete_imprint_profile_source_set",
            "source_entity_ids": sorted(source_ids),
        }
        return {
            "kind": "face",
            "owner_feature_id": producer_id,
            "output_role": output_role,
            "source": "runtime_snapshot",
            "confidence": 1.0,
            "selector_intent": intent,
        }

    if topology == "SWEPT_FACE":
        if selector_kind != "face" or len(refs) != 1:
            return None
        _source_sketch, source_entity = refs[0]
        intent = _selector_intent(
            value,
            query_family="SWEPT_FACE",
            kind="face",
            evidence="kernel_history",
            allowed=("boundary", "fragment"),
            multiplicity="all_fragments",
        )
        intent["source_entity"] = {"sketch_id": profile_source, "entity_id": source_entity}
        return {
            "kind": "face",
            "owner_feature_id": producer_id,
            "source": "runtime_snapshot",
            "confidence": 1.0,
            "selector_intent": intent,
        }

    if selector_kind != "edge" or len(refs) != 2 or len(ref_ids) != 2:
        return None
    intent = _selector_intent(
        value,
        query_family="SWEPT_EDGE",
        kind="edge",
        evidence="kernel_history",
        allowed=("boundary",),
    )
    intent.pop("source_entity", None)
    intent["source_entities"] = [
        {"sketch_id": profile_source, "entity_id": entity_id}
        for entity_id in sorted(ref_ids)
    ]
    return {
        "kind": "edge",
        "owner_feature_id": producer_id,
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "selector_intent": intent,
    }


def _intersection_source_face_descriptor(
    value: Any,
    *,
    allowed_input_features: set[str],
    primary_tool_owner: str | None = None,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Describe one exact boolean-input face without lowering a generic query.

    This is intentionally narrower than the standalone CAP/SWEPT selector
    paths.  The source must be an independently retained direct prism, or the
    one transient direct prism built by the enclosing primary REMOVE.  It
    records the semantic anchor used to locate the *input* face; section-edge
    selection is deferred to runtime builder history.
    """
    if featurescript_version != "1511":
        return None
    try:
        _call, owner, topology, kind, _definition = _direct_make_query(value)
    except ValueError:
        return None
    owner_feature_id = f"f_{owner}"
    if kind != "face" or owner_feature_id not in allowed_input_features:
        return None
    producer = feature_by_id.get(owner_feature_id) or {}
    params = producer.get("params") or {}
    is_primary_tool = owner_feature_id == primary_tool_owner
    if (
        producer.get("atomic_id") != ("extrude_cut_blind" if is_primary_tool else "extrude_add_blind")
        or (params.get("result_mode") is not None if is_primary_tool else params.get("result_mode") != "new_body")
        or (params.get("end_condition") or {}).get("type") != "blind"
        or params.get("draft") is not None
    ):
        return None
    if topology == "CAP_FACE":
        query = parse_query(value)
        if query.is_start is None:
            return None
        return {
            "query_family": "CAP_FACE",
            "owner_feature_id": owner_feature_id,
            "output_role": f"extrude.{'start' if query.is_start else 'end'}",
        }
    if topology != "SWEPT_FACE":
        return None
    frame = feature_frames.get(owner) or {}
    profile_source = frame.get("profile_source")
    profile_sketch = sketches_by_id.get(str(producer.get("sketch_id") or ""))
    source_sketch = sketch_by_source.get(profile_source) if isinstance(profile_source, str) else None
    refs = _source_refs(value)
    if (
        not isinstance(profile_source, str)
        or source_sketch is None
        or profile_sketch is None
        or profile_sketch.get("source_sketch_id") != profile_source
        or not _profile_matches_direct_source(profile_sketch, source_sketch)
        or len(refs) != 1
        or refs[0][0] != profile_source
        or parse_query(value).source_sketch != profile_source
        or parse_query(value).source_entity != refs[0][1]
        or refs[0][1] not in _direct_profile_source_entity_ids(profile_sketch)
    ):
        return None
    entity = (entity_by_sketch.get(profile_source) or {}).get(refs[0][1])
    if not entity or entity.get("construction"):
        return None
    return {
        "query_family": "SWEPT_FACE",
        "owner_feature_id": owner_feature_id,
        "source_entity": {"sketch_id": profile_source, "entity_id": refs[0][1]},
    }


def _direct_boolean_intersection_selector(
    value: Any,
    *,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Lower one source-qualified `INTERSECT EDGE` boolean query.

    The operation accepts exactly two direct prism source faces from the
    explicitly named target/tool members of a single `boolean_bodies` node.
    COPY, transformed, patterned, TDD/TD/IMPRINT-derived and primary-tool
    booleans intentionally retain deferred source intent.
    """
    if featurescript_version != "1511":
        return None
    try:
        _call, owner, topology, kind, definition = _direct_make_query(value)
    except ValueError:
        return None
    if topology != "INTERSECT" or kind != "edge":
        return None
    boolean_id = f"f_{owner}"
    boolean = feature_by_id.get(boolean_id) or {}
    params = boolean.get("params") or {}
    target_ids = params.get("target_feature_ids")
    tool_ids = params.get("tool_feature_ids")
    if (
        boolean.get("atomic_id") != "boolean_bodies"
        or params.get("operation") not in {"subtract", "intersect"}
        or bool(params.get("keep_tools"))
        or not isinstance(target_ids, list)
        or not isinstance(tool_ids, list)
        or len(target_ids) != 1
        or len(tool_ids) != 1
    ):
        return None
    derived = definition.get("derivedFrom")
    if not isinstance(derived, list) or len(derived) != 2:
        return None
    allowed_inputs = {str(target_ids[0]), str(tool_ids[0])}
    sources = [
        _intersection_source_face_descriptor(
            item,
            allowed_input_features=allowed_inputs,
            feature_by_id=feature_by_id,
            feature_frames=feature_frames,
            sketch_by_source=sketch_by_source,
            sketches_by_id=sketches_by_id,
            entity_by_sketch=entity_by_sketch,
            featurescript_version=featurescript_version,
        )
        for item in derived
    ]
    if any(source is None for source in sources):
        return None
    owners = {str(source["owner_feature_id"]) for source in sources if source is not None}
    if owners != allowed_inputs:
        return None
    return {
        "kind": "edge",
        "owner_feature_id": boolean_id,
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "selector_intent": _selector_intent(
            value,
            query_family="INTERSECT",
            kind="edge",
            evidence="kernel_history",
            allowed=("intersection",),
        ) | {
            "intersection_sources": sources,
            "disambiguation": {"type": "source_qualified_boolean_section"},
        },
    }


def _direct_primary_cut_intersection_selector(
    value: Any,
    *,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    previous: list[str],
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Lower one unique source-qualified section from a primary REMOVE.

    The primary cut's tool is not a CDSL body member. Runtime creates a
    transient direct-prism snapshot only for this exact source pair, then
    binds the final section edge through the cut builder. Any FeatureScript
    disambiguation encoding remains deferred until its API semantics are
    independently verified; OCC section-list position is not a substitute.
    """
    if featurescript_version != "1511":
        return None
    try:
        _call, owner, topology, kind, definition = _direct_make_query(value)
    except ValueError:
        return None
    if (
        topology != "INTERSECT"
        or kind != "edge"
        or definition.get("disambiguationData") not in (None, [])
    ):
        return None
    primary_id = f"f_{owner}"
    primary = feature_by_id.get(primary_id) or {}
    primary_params = primary.get("params") or {}
    if (
        primary.get("atomic_id") != "extrude_cut_blind"
        or primary_params.get("result_mode") is not None
        or (primary_params.get("end_condition") or {}).get("type") != "blind"
        or primary_params.get("draft") is not None
    ):
        return None
    derived = definition.get("derivedFrom")
    if not isinstance(derived, list) or len(derived) != 2:
        return None
    try:
        input_owners = [f"f_{_direct_make_query(item)[1]}" for item in derived]
    except ValueError:
        return None
    if input_owners.count(primary_id) != 1 or len(set(input_owners)) != 2:
        return None
    target_id = next(item for item in input_owners if item != primary_id)
    # At the primary cut, one immediately preceding body is both the runtime
    # target and the only allowed source-qualified target producer.
    if previous[-2:] != [target_id, primary_id]:
        return None
    sources = [
        _intersection_source_face_descriptor(
            item,
            allowed_input_features={target_id, primary_id},
            primary_tool_owner=primary_id,
            feature_by_id=feature_by_id,
            feature_frames=feature_frames,
            sketch_by_source=sketch_by_source,
            sketches_by_id=sketches_by_id,
            entity_by_sketch=entity_by_sketch,
            featurescript_version=featurescript_version,
        )
        for item in derived
    ]
    if any(source is None for source in sources):
        return None
    return {
        "kind": "edge",
        "owner_feature_id": primary_id,
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "selector_intent": _selector_intent(
            value,
            query_family="INTERSECT",
            kind="edge",
            evidence="kernel_history",
            allowed=("intersection",),
        ) | {
            "intersection_sources": sources,
            "disambiguation": {"type": "source_qualified_primary_section"},
        },
    }


def _uses_planar_imprint_profile(
    owner: str,
    feature_by_id: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
) -> bool:
    """Return whether a producer's profile was selected by B-rep IMPRINT."""
    feature = feature_by_id.get(f"f_{owner}") or {}
    sketch = sketches_by_id.get(str(feature.get("sketch_id") or "")) or {}
    return (sketch.get("profile") or {}).get("type") == "planar_imprint"


def _source_sketch(params: dict[str, Any]) -> str | None:
    for key in ("entities", "sheetProfilesArray", "surfaceEntities"):
        if key in params:
            query = parse_query(params[key])
            if query.source_sketch: return query.source_sketch
    return None


def _same_profile_frame(left: dict[str, Any], right: dict[str, Any]) -> bool:
    """Require identical source frames, without inventing a coordinate map."""
    for key in ("origin_mm", "x_dir", "normal"):
        first, second = left.get(key), right.get(key)
        if (
            not isinstance(first, list)
            or not isinstance(second, list)
            or len(first) != 3
            or len(second) != 3
            or any(not isinstance(value, (int, float)) or not math.isfinite(float(value)) for value in [*first, *second])
            or any(float(a) != float(b) for a, b in zip(first, second))
        ):
            return False
    return True


def _direct_sketch_region_union_leaves(value: Any) -> list[Call] | None:
    """Flatten only associative qUnion wrappers around direct region leaves."""
    if not isinstance(value, Call) or value.name != "qUnion" or len(value.args) != 1 or not isinstance(value.args[0], list):
        return None
    leaves: list[Call] = []
    for operand in value.args[0]:
        if isinstance(operand, Call) and operand.name == "qUnion":
            nested = _direct_sketch_region_union_leaves(operand)
            if nested is None:
                return None
            leaves.extend(nested)
        elif isinstance(operand, Call) and operand.name == "qSketchRegion" and len(operand.args) == 2:
            leaves.append(operand)
        else:
            return None
    return leaves


def _multi_source_sketch_region_profile(
    value: Any,
    sketch_by_source: dict[str, dict[str, Any]],
    feature_id: str,
) -> dict[str, Any] | None:
    """Materialize a direct same-frame ``qUnion(qSketchRegion(...))`` profile.

    This is profile geometry, not a topology selector: each source region is
    resolved independently by the runtime so a contour nested in a different
    sketch cannot accidentally become a hole in another sketch's region.
    """
    leaves = _direct_sketch_region_union_leaves(value)
    if leaves is None or len(leaves) < 2:
        return None
    sources: list[str] = []
    for leaf in leaves:
        if str(leaf.args[1]).lower() != "true":
            return None
        source = symbolic_string(leaf.args[0]).split(".", 1)[0]
        if not source:
            return None
        sources.append(source)
    # qUnion is a set union. Repeating the whole source region cannot create
    # another profile region, so preserve first-occurrence source ordering.
    sources = list(dict.fromkeys(sources))
    if len(sources) < 2 or any(source not in sketch_by_source for source in sources):
        return None
    sketches = [sketch_by_source[source] for source in sources]
    if any(sketch.get("attachment") is not None or not _profile_executable(sketch) for sketch in sketches):
        return None
    frame = sketches[0].get("workplane")
    if not isinstance(frame, dict) or any(not _same_profile_frame(frame, sketch.get("workplane") or {}) for sketch in sketches[1:]):
        return None
    profiles = [deepcopy(sketch["profile"]) for sketch in sketches]
    if any(profile.get("type") not in {"circle", "polygon", "analytic_contours"} for profile in profiles):
        return None
    return {
        "id": f"sketch_regions_{feature_id}",
        "name": f"regions_{feature_id}",
        "workplane": deepcopy(frame),
        "profile": {
            "type": "multi_source_regions",
            "source_sketch_ids": sources,
            "profiles": profiles,
        },
    }


def _has_composed_sketch_region_union(value: Any) -> bool:
    """Identify composed region input that must not fall back to one source."""
    leaves = _direct_sketch_region_union_leaves(value)
    if leaves is None:
        return False
    sources = {
        symbolic_string(leaf.args[0]).split(".", 1)[0]
        for leaf in leaves
    }
    return len(leaves) >= 2 and len(sources - {""}) >= 2


def _sketch_region_query(value: Any) -> Any | None:
    """Return one explicit qSketchRegion when a profile query also carries context faces."""
    matches = [
        item for item in _queries(value)
        if any(call.name == "qSketchRegion" for call in walk_calls(item))
    ]
    return matches[0] if len(matches) == 1 else None


def _imprint_sketch(value: Any) -> str | None:
    for call in walk_calls(value):
        if call.name != "makeQuery" or not call.args: continue
        owner = symbolic_string(call.args[0])
        if owner.endswith(".imprint"): return owner.split(".", 1)[0]
    return None


def _profile_selection_side(value: Any) -> float | None:
    def numbers(item: Any):
        if isinstance(item, (int, float)): yield float(item)
        elif isinstance(item, list):
            for child in item: yield from numbers(child)
        elif isinstance(item, dict):
            for child in item.values(): yield from numbers(child)
    for call in walk_calls(value):
        if call.name in {"TD", "topologyDisambiguation"}:
            return next(numbers(call.args), None)
    return None


def _profile_selection_sides(value: Any) -> list[float]:
    """Return every explicit topology side from one nested IMPRINT query."""
    def numbers(item: Any):
        if isinstance(item, (int, float)): yield float(item)
        elif isinstance(item, list):
            for child in item: yield from numbers(child)
        elif isinstance(item, dict):
            for child in item.values(): yield from numbers(child)
    sides = []
    for call in walk_calls(value):
        if call.name in {"TD", "topologyDisambiguation"}:
            side = next(numbers(call.args), None)
            if side is not None: sides.append(side)
    return sides


def _partitioned_imprint_sketch(
    value: Any,
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> str | None:
    """Resolve a two-sided split IMPRINT union back to its bounded sketch region.

    A closed sketch curve that intersects a parent-face boundary is split into
    two IMPRINT regions. CADFS records the two halves as a qUnion, with the
    same outer face side and opposite sides around the intersection vertex.
    The union is exactly the curve's bounded sketch region. Do not accept a
    partial union, a mixed source curve, or an open curve here: each case has
    different material semantics and must remain an explicit capability gap.
    """
    roots = _queries(value)
    if len(roots) != 2:
        return None
    source_sketch: str | None = None
    source_entity: str | None = None
    nested_sides: set[float] = set()
    for root in roots:
        try:
            _call, owner, topology, kind, _definition = _direct_make_query(root)
        except ValueError:
            return None
        info = parse_query(root)
        references = {
            (sketch, entity)
            for sketch, entity in _source_refs(root)
            if sketch == owner
        }
        sides = _profile_selection_sides(root)
        if topology != "IMPRINT" or kind != "face" or owner != info.source_sketch:
            return None
        if len(references) != 1 or len(sides) != 2 or sides[0] >= 0:
            return None
        sketch, entity = next(iter(references))
        if source_sketch is None:
            source_sketch, source_entity = sketch, entity
        elif (source_sketch, source_entity) != (sketch, entity):
            return None
        nested_sides.add(sides[1])
    if source_sketch is None or source_entity is None or nested_sides != {-1.0, 1.0}:
        return None
    entities = entity_by_sketch.get(source_sketch) or {}
    source = entities.get(source_entity)
    if source is None:
        source_id = max((key for key in entities if source_entity.startswith(key + ".")), key=len, default="")
        source = entities.get(source_id)
    if source is None or source.get("type") != "bspline" or not _same_point(source["start"], source["end"]):
        return None
    return source_sketch


def _intersect_partition_profile_sketch(
    value: Any,
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    feature_id: str,
) -> dict[str, Any] | None:
    """Materialize one full circular region selected through a split diameter.

    A sketch line that crosses nested concentric circles is split at the
    selected circle intersection. CADFS can select the two face sides around
    that split edge instead of naming the circular region directly. Both
    sides together are exactly the bounded region inside the selected circle:
    either its disk or the annulus ending at the immediately inner circle.
    Keep this deliberately narrow. A non-diameter line, any non-circular
    source, a partial side selection, or an ambiguous nested query remains an
    INTERSECT capability diagnostic rather than an invented profile.
    """
    roots = _queries(value)
    if len(roots) != 2:
        return None
    source_sketch: str | None = None
    source_line: str | None = None
    source_circle: str | None = None
    outer_sides: set[float] = set()
    for root in roots:
        try:
            _call, owner, topology, kind, _definition = _direct_make_query(root)
        except ValueError:
            return None
        sides = _profile_selection_sides(root)
        if topology != "IMPRINT" or kind != "face" or len(sides) != 2 or sides[1] != -1.0:
            return None
        references = list(dict.fromkeys(_source_refs(root)))
        if len(references) != 2 or any(sketch != owner for sketch, _entity in references):
            return None
        entities = entity_by_sketch.get(owner) or {}
        line_ids = [entity_id for _sketch, entity_id in references if (entities.get(entity_id) or {}).get("type") == "line"]
        circle_ids = [entity_id for _sketch, entity_id in references if (entities.get(entity_id) or {}).get("type") == "circle"]
        if len(line_ids) != 1 or len(circle_ids) != 1:
            return None
        if source_sketch is None:
            source_sketch, source_line, source_circle = owner, line_ids[0], circle_ids[0]
        elif (source_sketch, source_line, source_circle) != (owner, line_ids[0], circle_ids[0]):
            return None
        outer_sides.add(sides[0])
    if source_sketch is None or source_line is None or source_circle is None or outer_sides != {-1.0, 1.0}:
        return None
    sketch = sketch_by_source.get(source_sketch)
    entities = entity_by_sketch.get(source_sketch) or {}
    line, circle = entities.get(source_line), entities.get(source_circle)
    if sketch is None or line is None or circle is None:
        return None
    start, end, center = line.get("start"), line.get("end"), circle.get("center")
    if not all(isinstance(point, list) and len(point) == 2 for point in (start, end, center)):
        return None
    direction = [end[index] - start[index] for index in range(2)]
    length = math.hypot(*direction)
    if length <= 1e-9:
        return None
    projection = sum((center[index] - start[index]) * direction[index] for index in range(2)) / (length * length)
    distance = abs((center[0] - start[0]) * direction[1] - (center[1] - start[1]) * direction[0]) / length
    if not 1e-6 < projection < 1.0 - 1e-6 or distance > 1e-6:
        return None
    profile = _circle_imprint_region((sketch.get("profile") or {}).get("contours") or [], circle, 1.0)
    if profile is None:
        return None
    output = deepcopy(sketch)
    output["id"] = f"{sketch['id']}__{feature_id}"
    output["name"] = f"{sketch['name']}__{feature_id}"
    output["profile"] = profile
    return output


def _definition_topology_side(definition: dict[str, Any]) -> float | None:
    """Read the directly attached ``TD`` sign from one query definition."""
    def numbers(item: Any):
        if isinstance(item, (int, float)):
            yield float(item)
        elif isinstance(item, list):
            for child in item:
                yield from numbers(child)
        elif isinstance(item, dict):
            for child in item.values():
                yield from numbers(child)

    for call in walk_calls(definition.get("disambiguationData")):
        if call.name in {"TD", "topologyDisambiguation"}:
            side = next(numbers(call.args), None)
            if side in {-1.0, 1.0}:
                return side
    return None


def _definition_order(definition: dict[str, Any]) -> int | None:
    """Read a finite non-negative ``OD`` index without guessing an intersection."""
    def numbers(item: Any):
        if isinstance(item, (int, float)):
            yield float(item)
        elif isinstance(item, list):
            for child in item:
                yield from numbers(child)
        elif isinstance(item, dict):
            for child in item.values():
                yield from numbers(child)

    for call in walk_calls(definition.get("disambiguationData")):
        if call.name in {"OD", "orderDisambiguation"}:
            value = next(numbers(call.args), None)
            if value is None or not math.isfinite(value) or value < 0 or value != round(value):
                return None
            return int(value)
    return None


def _planar_imprint_selection(value: Any) -> tuple[str, dict[str, Any]] | None:
    """Lower one IMPRINT face query to source-edge and side evidence.

    The result deliberately retains the nested edge-fragment proof instead of
    flattening it to an arbitrary original profile.  A fragment-side sign is
    only meaningful together with an exact ``INTERSECT`` vertex and optional
    FeatureScript order disambiguation; any other nested form stays outside
    this contract.
    """
    try:
        _root, owner, topology, kind, definition = _direct_make_query(value)
    except ValueError:
        return None
    face_side = _definition_topology_side(definition)
    if topology != "IMPRINT" or kind != "face" or face_side is None:
        return None

    edge_queries: list[tuple[Call, dict[str, Any]]] = []
    for call in walk_calls(definition.get("disambiguationData")):
        if call.name != "makeQuery":
            continue
        try:
            _edge, edge_owner, edge_topology, edge_kind, edge_definition = _direct_make_query(call)
        except ValueError:
            continue
        if edge_owner == owner and edge_topology == "IMPRINT" and edge_kind == "edge":
            edge_queries.append((call, edge_definition))
    if len(edge_queries) != 1:
        return None
    _edge, edge_definition = edge_queries[0]
    sources = list(dict.fromkeys(_source_refs(edge_definition.get("derivedFrom"))))
    if len(sources) != 1 or sources[0][0] != owner:
        return None
    source_entity = sources[0][1]
    selection: dict[str, Any] = {"source_entity_id": source_entity, "face_side": face_side}

    intersections: list[dict[str, Any]] = []
    for call in walk_calls(edge_definition.get("disambiguationData")):
        if call.name != "makeQuery":
            continue
        try:
            _intersection, intersection_owner, intersection_topology, intersection_kind, intersection_definition = _direct_make_query(call)
        except ValueError:
            continue
        if intersection_owner == owner and intersection_topology == "INTERSECT" and intersection_kind == "vertex":
            intersections.append(intersection_definition)
    if not intersections:
        return owner, selection
    if len(intersections) != 1:
        return None
    fragment_side = _definition_topology_side(edge_definition)
    intersection_derived = intersections[0].get("derivedFrom")
    intersection_sources = list(dict.fromkeys(_source_refs(intersection_derived)))
    if fragment_side is None or len(intersection_sources) != 2:
        return None
    same_sketch_anchor = [
        entity for sketch, entity in intersection_sources
        if sketch == owner and entity != source_entity
    ]
    fragment: dict[str, Any]
    if len(same_sketch_anchor) == 1 and all(sketch == owner for sketch, _entity in intersection_sources):
        fragment = {"anchor_entity_id": same_sketch_anchor[0], "side": fragment_side}
    else:
        external_queries: list[Call] = []
        for call in walk_calls(intersection_derived):
            if call.name != "makeQuery":
                continue
            try:
                _edge, _edge_owner, edge_topology, edge_kind, _edge_definition = _direct_make_query(call)
            except ValueError:
                continue
            if edge_topology == "CAP_EDGE" and edge_kind in {"edge", "entitytype.edge"}:
                external_queries.append(call)
        local_sources = [(sketch, entity) for sketch, entity in intersection_sources if sketch == owner]
        if len(local_sources) != 1 or local_sources[0][1] != source_entity or len(external_queries) != 1:
            return None
        # Kept only while lowering this profile. The CDSL profile receives a
        # typed selector through the external-anchor contract below.
        fragment = {"_external_anchor_query": external_queries[0], "side": fragment_side}
    order = _definition_order(intersections[0])
    if order is not None:
        fragment["intersection_index"] = order
    selection["fragment"] = fragment
    return owner, selection


def _planar_imprint_profile_sketch(
    value: Any,
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    feature_id: str,
    *,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    previous: list[str],
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Create an exact planar-arrangement profile from IMPRINT face queries.

    The adapter later splits a bounded support face with these original
    analytic curves and consumes only the selected B-rep regions.  This is a
    typed derived-profile contract, not a polygonization or a reconstruction
    of a potentially unrelated source contour.
    """
    selections: list[dict[str, Any]] = []
    external_anchors: list[dict[str, Any]] = []
    source_sketch: str | None = None
    for root in _queries(value):
        parsed = _planar_imprint_selection(root)
        if parsed is None:
            return None
        owner, selection = parsed
        if source_sketch is None:
            source_sketch = owner
        elif source_sketch != owner:
            return None
        fragment = selection.get("fragment") or {}
        external_query = fragment.pop("_external_anchor_query", None)
        if external_query is not None:
            try:
                _call, external_owner, external_topology, external_kind, _definition = _direct_make_query(external_query)
            except ValueError:
                return None
            if external_topology != "CAP_EDGE" or external_kind not in {"edge", "entitytype.edge"}:
                return None
            external_selector = _direct_prism_swept_selector(
                external_query,
                owner=external_owner,
                selector_kind="edge",
                feature_by_id=feature_by_id,
                feature_frames=feature_frames,
                sketch_by_source=sketch_by_source,
                sketches_by_id=sketches_by_id,
                entity_by_sketch=entity_by_sketch,
                previous=previous,
                featurescript_version=featurescript_version,
                allow_continuation=False,
            )
            attachment = (sketch_by_source.get(owner) or {}).get("attachment")
            attachment_intent = attachment.get("selector_intent") if isinstance(attachment, dict) else None
            external_intent = external_selector.get("selector_intent") if isinstance(external_selector, dict) else None
            if (
                external_selector is None
                or not isinstance(attachment, dict)
                or attachment.get("owner_feature_id") != external_selector.get("owner_feature_id")
                or attachment.get("output_role") != (external_intent or {}).get("lineage_role")
                or not isinstance(attachment_intent, dict)
                or attachment_intent.get("consumer_contract") != "direct_prism_cap_face_workplane"
            ):
                return None
            anchor_id = f"cap_boundary_{len(external_anchors)}"
            fragment["external_anchor_id"] = anchor_id
            external_anchors.append({"id": anchor_id, "selector": external_selector})
        selections.append(selection)
    if source_sketch is None or not selections or source_sketch not in sketch_by_source:
        return None
    entities = entity_by_sketch.get(source_sketch) or {}
    source_entities: list[dict[str, Any]] = []
    for entity_id, curve in entities.items():
        if curve.get("construction") or curve.get("type") not in {"line", "arc", "circle", "ellipse", "bspline"}:
            continue
        source_entities.append({"id": entity_id, "curve": {key: deepcopy(value) for key, value in curve.items() if key != "construction"}})
    known = {entry["id"] for entry in source_entities}
    for selection in selections:
        fragment = selection.get("fragment") or {}
        if selection["source_entity_id"] not in known or (fragment.get("anchor_entity_id") and fragment.get("anchor_entity_id") not in known):
            return None
    # A same-sketch fragment needs a second source curve as its splitter
    # anchor. The current source admission for an attached boundary is only
    # the one-circle / one-edge form: a periodic B-spline has seam ambiguity,
    # and multi-curve or multi-anchor arrangements need a set-cardinality
    # contract rather than reusing this singleton policy.
    single_external_circle_fragment = (
        len(source_entities) == 1
        and source_entities[0].get("curve", {}).get("type") == "circle"
        and bool(external_anchors)
        and len(external_anchors) == 1
        and len(external_anchors) == len(selections)
        and all(
            isinstance(selection.get("fragment"), dict)
            and isinstance(selection["fragment"].get("external_anchor_id"), str)
            and selection["fragment"]["external_anchor_id"]
            for selection in selections
        )
    )
    if external_anchors and not single_external_circle_fragment:
        return None
    if len(source_entities) < 2 and not single_external_circle_fragment:
        return None
    output = deepcopy(sketch_by_source[source_sketch])
    output["id"] = f"{output['id']}__{feature_id}"
    output["name"] = f"{output['name']}__{feature_id}"
    output["profile"] = {
        "type": "planar_imprint",
        "source_entities": source_entities,
        "selections": selections,
    }
    if external_anchors:
        output["profile"]["external_anchors"] = external_anchors
    return output


def _same_point(left: list[float], right: list[float]) -> bool:
    return math.dist(left, right) <= 1e-5


def _matching_profile_segment(segment: dict[str, Any], source: dict[str, Any]) -> int:
    if segment.get("type") != source.get("type"): return 0
    if segment["type"] == "circle":
        return 1 if _same_point(segment["center"], source["center"]) and abs(segment["radius_mm"] - source["radius_mm"]) <= 1e-5 else 0
    if segment["type"] == "ellipse":
        if not (
            _same_point(segment["center"], source["center"])
            and abs(segment["major_radius_mm"] - source["major_radius_mm"]) <= 1e-5
            and abs(segment["minor_radius_mm"] - source["minor_radius_mm"]) <= 1e-5
        ):
            return 0
        direction = _dot(segment["major_axis"], source["major_axis"])
        return 1 if direction >= 0 else -1
    if _same_point(segment["start"], source["start"]) and _same_point(segment["end"], source["end"]): return 1
    if _same_point(segment["start"], source["end"]) and _same_point(segment["end"], source["start"]): return -1
    return 0


def _circle_imprint_region(contours: list[dict[str, Any]], source: dict[str, Any], side: float | None) -> dict[str, Any] | None:
    """Materialize one bounded side of a nested circular IMPRINT edge."""
    if source.get("type") != "circle" or side is None: return None
    center = source["center"]; radius = float(source["radius_mm"])
    circles = sorted({
        float(segment["radius_mm"])
        for contour in contours
        for segment in contour.get("segments") or []
        if segment.get("type") == "circle" and _same_point(segment.get("center") or [], center)
    })
    index = next((item for item, value in enumerate(circles) if abs(value - radius) <= 1e-5), None)
    if index is None: return None
    # 标准 skCircle 的正侧位于圆内。若同心圆存在，选区应止于其直接
    # 内层边界；负侧则选择与直接外层边界之间的环域。没有相邻边界时，
    # 只有圆内区域是可由 CDSL 闭合 profile 表达的。
    inner = circles[index - 1] if side > 0 and index > 0 else radius
    outer = radius if side > 0 else (circles[index + 1] if index + 1 < len(circles) else None)
    if outer is None: return None
    if inner == 0 or (side > 0 and index == 0): return {"type": "circle", "center": list(center), "radius_mm": outer}
    return {
        "type": "analytic_contours",
        "contours": [
            {"role": "outer", "closed": True, "segments": [{"type": "circle", "center": list(center), "radius_mm": outer}]},
            {"role": "inner", "closed": True, "segments": [{"type": "circle", "center": list(center), "radius_mm": inner}]},
        ],
    }


def _circle_imprint_union_profile(
    contours: list[dict[str, Any]],
    query_values: list[Any],
    entities: dict[str, dict[str, Any]],
) -> dict[str, Any] | None:
    """Materialize one bounded union of concentric circular IMPRINT regions."""
    resolved: list[tuple[dict[str, Any], float]] = []
    for query_value in query_values:
        selection = parse_query(query_value)
        source_id = max((key for key in entities if selection.source_entity and selection.source_entity.startswith(key)), key=len, default="")
        source = entities.get(source_id)
        side = _profile_selection_side(query_value)
        if source is None or source.get("type") != "circle" or side is None:
            return None
        resolved.append((source, side))
    if not resolved:
        return None
    center = resolved[0][0]["center"]
    if any(not _same_point(source["center"], center) for source, _side in resolved[1:]):
        return None
    radii = sorted({
        float(segment["radius_mm"])
        for contour in contours
        for segment in contour.get("segments") or []
        if segment.get("type") == "circle" and _same_point(segment.get("center") or [], center)
    })
    intervals: list[tuple[float, float]] = []
    for source, side in resolved:
        radius = float(source["radius_mm"])
        index = next((item for item, value in enumerate(radii) if abs(value - radius) <= 1e-5), None)
        if index is None:
            return None
        if side > 0:
            intervals.append((radii[index - 1] if index else 0.0, radius))
        elif index + 1 < len(radii):
            intervals.append((radius, radii[index + 1]))
        else:
            # 最外圆的负侧是无界区域，不能变成任意默认实体。
            return None
    intervals.sort()
    merged: list[list[float]] = []
    for lower, upper in intervals:
        if merged and lower <= merged[-1][1] + 1e-5:
            merged[-1][1] = max(merged[-1][1], upper)
        else:
            merged.append([lower, upper])
    if len(merged) != 1:
        return None
    inner, outer = merged[0]
    outer_sources = {
        segment.get("source_entity_id")
        for contour in contours
        for segment in contour.get("segments") or []
        if (
            segment.get("type") == "circle"
            and _same_point(segment.get("center") or [], center)
            and abs(float(segment.get("radius_mm") or 0.0) - outer) <= 1e-5
            and isinstance(segment.get("source_entity_id"), str)
            and segment["source_entity_id"]
        )
    }
    # The union's outer boundary is still one original source circle when the
    # source sketch names it uniquely. Preserve that exact source identity so
    # a later direct-prism builder can expose its native swept-face history.
    # An annulus or a duplicate boundary intentionally carries no inferred
    # label: a source query then remains unresolved rather than borrowing a
    # geometrically equal circle.
    outer_source = next(iter(outer_sources)) if len(outer_sources) == 1 else None
    if inner <= 1e-5:
        return {
            "type": "circle",
            "center": list(center),
            "radius_mm": outer,
            **({"source_entity_id": outer_source} if outer_source is not None else {}),
        }
    return {
        "type": "analytic_contours",
        "contours": [
            {
                "role": "outer",
                "closed": True,
                "segments": [{
                    "type": "circle", "center": list(center), "radius_mm": outer,
                    **({"source_entity_id": outer_source} if outer_source is not None else {}),
                }],
            },
            {"role": "inner", "closed": True, "segments": [{"type": "circle", "center": list(center), "radius_mm": inner}]},
        ],
    }


def _surface_circle_radii(profile: dict[str, Any]) -> list[tuple[list[float], float]]:
    """Return the explicit circular wires retained by a surface extrusion."""
    contours = profile.get("contours") if profile.get("type") == "analytic_contours" else None
    if not isinstance(contours, list): return []
    circles = []
    for contour in contours:
        segments = contour.get("segments") or []
        if len(segments) != 1 or segments[0].get("type") != "circle": continue
        circles.append((list(segments[0].get("center") or []), float(segments[0]["radius_mm"])))
    return circles


def _surface_trimmed_imprint_profile(
    profile_sketch: dict[str, Any],
    surface_profile_sketch: dict[str, Any] | None,
    previous_surfaces: list[dict[str, Any]],
) -> dict[str, Any]:
    """Materialize the bounded solid region created by a coaxial surface split.

    CADFS can retain an earlier, bidirectional surface extrusion while a later
    mixed extrusion selects an IMPRINT face.  The selected circular face is
    then bounded by that surface, rather than by the sketch origin.  CDSL has
    no general surface/solid trim operation yet, so preserve this proven
    circular case as its actual annular profile.  Other surface combinations
    remain on the ordinary IMPRINT lowering path instead of guessing a trim.
    """
    profile = profile_sketch.get("profile") or {}
    if profile.get("type") != "circle" or surface_profile_sketch is None:
        return profile_sketch
    center = list(profile.get("center") or [])
    outer = float(profile.get("radius_mm") or 0.0)
    if len(center) != 2 or outer <= 0:
        return profile_sketch
    selected_radii = _surface_circle_radii(surface_profile_sketch.get("profile") or {})
    if not any(_same_point(item_center, center) and abs(radius - outer) <= 1e-5 for item_center, radius in selected_radii):
        return profile_sketch
    plane = profile_sketch.get("workplane") or {}
    origin = plane.get("origin_mm") or []
    x_dir = plane.get("x_dir") or []
    y_dir = _y_dir(plane)
    if len(origin) != 3 or len(x_dir) != 3:
        return profile_sketch
    world_center = [origin[index] + center[0] * x_dir[index] + center[1] * y_dir[index] for index in range(3)]
    candidates: list[float] = []
    for surface in previous_surfaces:
        surface_plane = surface["workplane"]
        normal = surface_plane["normal"]
        surface_origin = surface_plane["origin_mm"]
        span_start = -float(surface.get("reverse_distance_mm") or 0.0)
        span_end = float(surface.get("distance_mm") or 0.0)
        projection = _dot(_sub(world_center, surface_origin), normal)
        if projection < span_start - 1e-5 or projection > span_end + 1e-5:
            continue
        surface_x_dir = surface_plane["x_dir"]
        surface_y_dir = _y_dir(surface_plane)
        local_center = [_dot(_sub(world_center, surface_origin), surface_x_dir), _dot(_sub(world_center, surface_origin), surface_y_dir)]
        for surface_center, radius in _surface_circle_radii(surface["profile"]):
            if _same_point(surface_center, local_center) and 1e-5 < radius < outer - 1e-5:
                candidates.append(radius)
    if not candidates:
        return profile_sketch
    inner = max(candidates)
    output = deepcopy(profile_sketch)
    output["profile"] = {
        "type": "analytic_contours",
        "contours": [
            {"role": "outer", "closed": True, "segments": [{"type": "circle", "center": center, "radius_mm": outer}]},
            {"role": "inner", "closed": True, "segments": [{"type": "circle", "center": center, "radius_mm": inner}]},
        ],
    }
    return output


def _open_imprint_profile_sketch(
    sketch: dict[str, Any],
    value: Any,
    feature_id: str,
) -> dict[str, Any] | None:
    """Materialize an open IMPRINT contour closed by its attached host face."""
    query = parse_query(value)
    profile = sketch.get("profile") or {}
    segments = profile.get("construction") or []
    if query.topology_type != "IMPRINT" or profile.get("contours") or len(segments) < 2:
        return None
    if any(segment.get("type") not in {"line", "arc", "bspline"} for segment in segments):
        return None
    return {
        "id": f"{sketch['id']}__{feature_id}",
        "name": f"{sketch['name']}__{feature_id}",
        "workplane": dict(sketch["workplane"]),
        "profile": {
            "type": "analytic_contours",
            "contours": [{"role": "open", "closed": False, "segments": deepcopy(segments)}],
        },
    }


def _cap_face_selector(value: Any, feature_frames: dict[str, dict[str, Any]], feature_id: str, suffix: str) -> dict[str, Any] | None:
    """Capture one uniquely framed CAP_FACE/CAP_EDGE as a runtime face selector."""
    query = parse_query(value)
    if query.topology_type not in {"CAP_FACE", "CAP_EDGE"} or not query.owner_feature or query.is_start is None:
        return None
    frame = feature_frames.get(query.owner_feature)
    if frame is None:
        return None
    cap = frame.get("start" if query.is_start else "end")
    if cap is None:
        return None
    normal = list(cap["normal"])
    return {
        "kind": "face",
        "owner_feature_id": f"f_{query.owner_feature}",
        "stable_id": f"cadfs_{feature_id}_{suffix}",
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "binding_feature_id": f"f_{query.owner_feature}",
        "geometry": {"normal": normal, "plane_offset_mm": _dot(normal, cap["origin_mm"])},
        "selector_intent": _deferred_featurescript_selector_intent(value, kind="face"),
    }


def _cap_face_output_role_selector(
    value: Any,
    feature_by_id: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    *,
    allow_initial_loft: bool = False,
    allow_two_sided_circle_shell: bool = False,
    allow_primary_add_shell: bool = False,
    allow_primary_add_up_to_surface: bool = False,
    allow_primary_add_dressup: bool = False,
    allow_two_sided_up_to_surface_pair: bool = False,
    source_sketches: dict[str, dict[str, Any]] | None = None,
) -> dict[str, Any] | None:
    """Reference one direct-builder cap face without reconstructing its sketch.

    A CAP_FACE is a B-rep output, not an alias for the profile that originally
    produced it.  The selector is therefore legal only when its producer has a
    runtime builder role capable of proving the exact active face.  The runtime
    rejects it if a later mutation makes that role non-unique or unavailable.
    """
    try:
        _call, owner, topology, kind, _definition = _direct_make_query(value)
    except ValueError:
        return None
    if topology != "CAP_FACE" or kind != "face":
        return None
    query = parse_query(value)
    if query.is_start is None:
        return None
    owner_feature_id = f"f_{owner}"
    producer = feature_by_id.get(owner_feature_id)
    params = (producer or {}).get("params") or {}
    producer_sketch = sketches_by_id.get(str((producer or {}).get("sketch_id") or ""))

    # Both far caps of a symmetric direct prism are exact builder outputs, but
    # neither is independently valid as a one-sided extent target. The caller
    # admits them only as the complete opposite-role pair below.
    if allow_two_sided_up_to_surface_pair:
        profile_source = (producer_sketch or {}).get("source_sketch_id")
        source_sketch = (source_sketches or {}).get(str(profile_source or ""))
        source_ids = _direct_profile_source_entity_ids(producer_sketch or {})
        refs = list(dict.fromkeys(_source_refs(value)))
        ref_ids = {entity_id for _sketch_id, entity_id in refs}
        if (
            producer is not None
            and producer.get("atomic_id") == "extrude_add_two_sided"
            and params.get("result_mode") == "new_body"
            and (params.get("end_condition") or {}).get("type") == "blind"
            and (params.get("reverse_end_condition") or {}).get("type") == "blind"
            and params.get("draft") is None
            and isinstance(profile_source, str)
            and source_sketch is not None
            and _profile_matches_direct_source(producer_sketch or {}, source_sketch)
            and source_ids
            and refs
            and {sketch_id for sketch_id, _entity_id in refs} == {profile_source}
            and ref_ids == source_ids
            and query.source_sketch == profile_source
            and query.source_entity in source_ids
        ):
            role = f"extrude.{'start' if query.is_start else 'end'}"
            intent = _selector_intent(
                value,
                query_family="CAP_FACE",
                kind="face",
                evidence="operation_role",
                allowed=("boundary",),
                output_role=role,
                disambiguation={"source_profile_entity_ids": sorted(source_ids)},
            )
            intent["consumer_contract"] = "symmetric_direct_prism_two_sided_up_to_surface_cap_pair"
            return {
                "kind": "face",
                "owner_feature_id": owner_feature_id,
                "output_role": role,
                "source": "runtime_snapshot",
                "confidence": 1.0,
                "selector_intent": intent,
            }

    # The two builders of a symmetric prism share the source plane, so only
    # their far First/LastShape handles identify the physical CAP faces.  The
    # executor records those final-snapshot roles exactly.  Keep this bridge
    # confined to a shell removing either cap of one direct circle: unlike a
    # general CAP_FACE it has an explicit one-edge source anchor and no
    # cross-feature continuation or extent semantics.
    if allow_two_sided_circle_shell:
        profile = (producer_sketch or {}).get("profile") or {}
        source_sketch_id = (producer_sketch or {}).get("source_sketch_id")
        source_entity_id = profile.get("source_entity_id")
        refs = _source_refs(value)
        if (
            producer is not None
            and producer.get("atomic_id") == "extrude_add_two_sided"
            and params.get("result_mode") == "new_body"
            and (params.get("end_condition") or {}).get("type") == "blind"
            and (params.get("reverse_end_condition") or {}).get("type") == "blind"
            and params.get("draft") is None
            and profile.get("type") == "circle"
            and isinstance(source_sketch_id, str)
            and isinstance(source_entity_id, str)
            and refs == [(source_sketch_id, source_entity_id)]
            and query.source_sketch == source_sketch_id
            and query.source_entity == source_entity_id
        ):
            role = f"extrude.{'start' if query.is_start else 'end'}"
            return {
                "kind": "face",
                "owner_feature_id": owner_feature_id,
                "output_role": role,
                "source": "runtime_snapshot",
                "confidence": 1.0,
                "selector_intent": _selector_intent(
                    value,
                    query_family="CAP_FACE",
                    kind="face",
                    evidence="operation_role",
                    allowed=("boundary",),
                    output_role=role,
                ),
            }

    # A loft CAP is identified by its OSD profile provenance, not by
    # ``isStart``. FeatureScript's CAP naming direction is independent of
    # the ThruSections wire order.
    if producer and producer.get("atomic_id") == "loft_add":
        if not allow_initial_loft:
            return None
        profile_sources = params.get("cap_output_profile_sources")
        if (
            params.get("initial_output_roles") is not True
            or not isinstance(profile_sources, list)
            or len(profile_sources) != 2
            or len(set(profile_sources)) != 2
        ):
            return None
        imprint_owners = set()
        for call in walk_calls(_definition.get("disambiguationData")):
            if call.name != "makeQuery":
                continue
            try:
                _direct, direct_owner, direct_topology, direct_kind, _direct_definition = _direct_make_query(call)
            except ValueError:
                continue
            if direct_topology == "IMPRINT" and direct_kind == "face":
                imprint_owners.add(direct_owner)
        if len(imprint_owners) != 1:
            return None
        source = next(iter(imprint_owners))
        if source not in profile_sources:
            return None
        role = ("loft.start", "loft.end")[profile_sources.index(source)]
        return {
            "kind": "face",
            "owner_feature_id": owner_feature_id,
            "output_role": role,
            "source": "runtime_snapshot",
            "confidence": 1.0,
            "selector_intent": _selector_intent(
                value,
                query_family="CAP_FACE",
                kind="face",
                evidence="operation_role",
                allowed=("boundary",),
                output_role=role,
                disambiguation={"type": "loft_profile_source", "source_sketch_id": source},
            ),
        }

    def has_one_closed_outer_region(sketch: dict[str, Any] | None) -> bool:
        """Prove the narrowed draft builder can receive exactly one face."""
        profile = (sketch or {}).get("profile") or {}
        if profile.get("type") == "circle":
            return True
        contours = profile.get("contours")
        return (
            profile.get("type") == "analytic_contours"
            and isinstance(contours, list)
            and len(contours) == 1
            and bool((contours[0] or {}).get("closed"))
        )
    # This derived-profile contract exposes only caps that a direct, one-sided,
    # independently retained builder result can prove. The adapter supports
    # both a regular prism and the restricted one-face LocOpe drafted-prism
    # builder path. Fused/multi-extent/profile results still have no
    # unambiguous builder output in the active snapshot.
    # A primary ADD has no independently active tool body. It may expose this
    # CAP role only to its immediate shell, one-sided up-to-surface, or
    # dress-up consumer:
    # execution registers the prism as transient and the resolver must prove
    # the exact union successor in the active final member. Other CAP_FACE
    # consumers keep the existing independent-new-body contract.
    primary_add_consumer = (
        (
            allow_primary_add_shell
            or allow_primary_add_up_to_surface
            or allow_primary_add_dressup
        )
        and producer is not None
        and producer.get("atomic_id") == "extrude_add_blind"
        and params.get("result_mode") != "new_body"
    )
    if (
        producer is None
        or producer.get("atomic_id") != "extrude_add_blind"
        or (params.get("result_mode") != "new_body" and not primary_add_consumer)
        or (params.get("end_condition") or {}).get("type") != "blind"
        # LocOpe_DPrism exposes one builder cap only for the one-face path.
        # A profile with holes is valid geometry but follows the fallback
        # tapered-extrude path, which intentionally carries no cap role.
        or params.get("draft") is not None and not has_one_closed_outer_region(producer_sketch)
    ):
        return None
    role_prefix = {
        "extrude_add_blind": "extrude",
    }[str(producer["atomic_id"])]
    selector_intent = _selector_intent(
        value,
        query_family="CAP_FACE",
        kind="face",
        evidence="operation_role",
        allowed=("boundary", "continuation"),
        output_role=f"{role_prefix}.{'start' if query.is_start else 'end'}",
    )
    if primary_add_consumer:
        selector_intent["consumer_contract"] = {
            "shell": "primary_add_shell_union_continuation",
            "up_to_surface": "primary_add_up_to_surface_union_continuation",
            "dressup": "primary_add_dressup_union_continuation",
        }[
            "up_to_surface" if allow_primary_add_up_to_surface
            else "dressup" if allow_primary_add_dressup
            else "shell"
        ]
    return {
        "kind": "face",
        "owner_feature_id": owner_feature_id,
        "output_role": f"{role_prefix}.{'start' if query.is_start else 'end'}",
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "selector_intent": selector_intent,
    }


def _two_sided_up_to_surface_cap_pair(
    forward_value: Any,
    reverse_value: Any,
    *,
    feature_by_id: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    source_sketches: dict[str, dict[str, Any]],
    previous: list[str],
    featurescript_version: str | None,
) -> tuple[dict[str, Any], dict[str, Any]] | None:
    """Lower opposite direct CAP faces only as one symmetric-extent pair."""
    if featurescript_version != "1511":
        return None
    forward = _cap_face_output_role_selector(
        forward_value, feature_by_id, sketches_by_id,
        allow_two_sided_up_to_surface_pair=True, source_sketches=source_sketches,
    )
    reverse = _cap_face_output_role_selector(
        reverse_value, feature_by_id, sketches_by_id,
        allow_two_sided_up_to_surface_pair=True, source_sketches=source_sketches,
    )
    if (
        forward is None
        or reverse is None
        or forward["owner_feature_id"] != reverse["owner_feature_id"]
        or previous[-1:] != [forward["owner_feature_id"]]
        or {forward["output_role"], reverse["output_role"]} != {"extrude.start", "extrude.end"}
    ):
        return None
    forward_ids = (forward.get("selector_intent") or {}).get("disambiguation", {}).get("source_profile_entity_ids")
    reverse_ids = (reverse.get("selector_intent") or {}).get("disambiguation", {}).get("source_profile_entity_ids")
    if not isinstance(forward_ids, list) or forward_ids != reverse_ids:
        return None
    return forward, reverse


def _two_sided_up_to_surface_shell_swept_face_pair(
    forward_value: Any,
    reverse_value: Any,
    *,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    previous: list[str],
    featurescript_version: str | None,
) -> tuple[dict[str, Any], dict[str, Any]] | None:
    """Lower two retained prism side walls through one immediate shell.

    The source queries remain source-edge anchored ``SWEPT_FACE`` lineage;
    this function only admits their paired extent consumer when the shell is
    the exact current lifecycle successor. The topology registry must still
    prove each source edge -> prism wall -> shell offset-face continuation at
    runtime, so this does not select a face by geometry or body position.
    """
    if featurescript_version != "1511" or len(previous) < 2:
        return None
    try:
        _forward_call, forward_owner, forward_topology, forward_kind, _forward_definition = _direct_make_query(forward_value)
        _reverse_call, reverse_owner, reverse_topology, reverse_kind, _reverse_definition = _direct_make_query(reverse_value)
    except ValueError:
        return None
    if (
        forward_topology != "SWEPT_FACE"
        or reverse_topology != "SWEPT_FACE"
        or forward_kind not in {"face", "entitytype.face"}
        or reverse_kind not in {"face", "entitytype.face"}
        or forward_owner != reverse_owner
    ):
        return None
    producer_id = f"f_{forward_owner}"
    shell_id = previous[-1]
    shell = feature_by_id.get(shell_id) or {}
    if (
        previous[-2] != producer_id
        or shell.get("atomic_id") != "shell"
        or shell.get("depends_on") != [producer_id]
    ):
        return None
    forward = _direct_prism_swept_selector(
        forward_value,
        owner=forward_owner,
        selector_kind="face",
        feature_by_id=feature_by_id,
        feature_frames=feature_frames,
        sketch_by_source=sketch_by_source,
        sketches_by_id=sketches_by_id,
        entity_by_sketch=entity_by_sketch,
        previous=previous,
        featurescript_version=featurescript_version,
        allow_continuation=True,
    )
    reverse = _direct_prism_swept_selector(
        reverse_value,
        owner=reverse_owner,
        selector_kind="face",
        feature_by_id=feature_by_id,
        feature_frames=feature_frames,
        sketch_by_source=sketch_by_source,
        sketches_by_id=sketches_by_id,
        entity_by_sketch=entity_by_sketch,
        previous=previous,
        featurescript_version=featurescript_version,
        allow_continuation=True,
    )
    if forward is None or reverse is None:
        return None
    forward_source = (forward.get("selector_intent") or {}).get("source_entity") or {}
    reverse_source = (reverse.get("selector_intent") or {}).get("source_entity") or {}
    if (
        forward_source == reverse_source
        or not isinstance(forward_source.get("sketch_id"), str)
        or not isinstance(forward_source.get("entity_id"), str)
        or not isinstance(reverse_source.get("entity_id"), str)
    ):
        return None
    shell_source_entities = {
        (intent.get("source_entity") or {}).get("entity_id")
        for selector in shell.get("selectors") or ()
        if isinstance(selector, dict)
        for intent in [selector.get("selector_intent")]
        if isinstance(intent, dict)
        and intent.get("query_family") == "SWEPT_FACE"
        and isinstance((intent.get("source_entity") or {}).get("entity_id"), str)
    }
    if {
        forward_source["entity_id"],
        reverse_source["entity_id"],
    } & shell_source_entities:
        # A shell may retain a planar closing descendant of a removed side.
        # It is not the physical offset face requested by this bridge.
        return None
    source_sketch_id = forward_source["sketch_id"]
    forward_entity = (entity_by_sketch.get(source_sketch_id) or {}).get(forward_source["entity_id"])
    reverse_entity = (entity_by_sketch.get(source_sketch_id) or {}).get(reverse_source["entity_id"])
    if (
        forward_entity is None
        or reverse_entity is None
        or forward_entity.get("type") != "line"
        or reverse_entity.get("type") != "line"
        or forward_entity.get("construction")
        or reverse_entity.get("construction")
    ):
        return None
    for selector in (forward, reverse):
        selector["selector_intent"]["consumer_contract"] = "symmetric_direct_prism_shell_swept_face_up_to_surface_pair"
    return forward, reverse


def _initial_direct_sweep_cap_output_role_selector(
    value: Any,
    feature_by_id: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
) -> dict[str, Any] | None:
    """Bind a direct PipeShell cap by profile and path-end source anchors.

    The builder's ``FirstShape``/``LastShape`` facts identify the result. A
    CADFS CAP query additionally carries the profile edge and path endpoint;
    require that exact pair so ``isStart`` cannot select a cap by position
    alone. Only the narrow source contract emitted below for an initial,
    direct, independent sweep is accepted.
    """
    try:
        _call, owner, topology, kind, definition = _direct_make_query(value)
    except ValueError:
        return None
    if topology != "CAP_FACE" or kind != "face":
        return None
    query = parse_query(value)
    if query.is_start is None:
        return None
    producer = feature_by_id.get(f"f_{owner}")
    params = (producer or {}).get("params") or {}
    contract = params.get("cap_output_contract")
    if (
        producer is None
        or producer.get("atomic_id") != "sweep_add"
        or params.get("result_mode") != "new_body"
        or params.get("initial_output_roles") is not True
        or not isinstance(contract, dict)
    ):
        return None
    required = ("profile_source", "profile_entity", "path_source", "path_entity", "path_reversed")
    if (
        any(not isinstance(contract.get(name), str) or not contract[name] for name in required[:-1])
        or not isinstance(contract.get("path_reversed"), bool)
    ):
        return None
    sketch = sketches_by_id.get(str(producer.get("sketch_id") or "")) or {}
    if sketch.get("source_sketch_id") != contract["profile_source"]:
        return None
    refs = _source_refs(definition.get("disambiguationData"))
    profile_ref = (contract["profile_source"], contract["profile_entity"])
    path_prefix = f"{contract['path_entity']}."
    path_refs = [ref for ref in refs if ref[0] == contract["path_source"] and ref[1].startswith(path_prefix)]
    if len(refs) != 2 or profile_ref not in refs or len(path_refs) != 1:
        return None
    suffix = path_refs[0][1][len(path_prefix):]
    if suffix not in {"start", "end"}:
        return None
    expected_endpoint = "start" if query.is_start else "end"
    # ``isStart`` is a source statement about the path endpoint. If lowering
    # reversed the path to attach the profile, invert it before choosing the
    # physical PipeShell output role.
    if suffix != expected_endpoint:
        return None
    role_endpoint = suffix if not contract["path_reversed"] else ("end" if suffix == "start" else "start")
    role = f"sweep.{role_endpoint}"
    return {
        "kind": "face",
        "owner_feature_id": f"f_{owner}",
        "output_role": role,
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "selector_intent": _selector_intent(
            value,
            query_family="CAP_FACE",
            kind="face",
            evidence="operation_role",
            allowed=("boundary",),
            output_role=role,
            disambiguation={
                "type": "sweep_profile_path_endpoint",
                **{name: contract[name] for name in required},
                "path_endpoint": suffix,
            },
        ),
    }


def _initial_direct_sweep_cap_edge_selector(
    value: Any,
    feature_by_id: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    previous: list[str],
) -> dict[str, Any] | None:
    """Bind the one-edge boundary of an immediate direct PipeShell cap.

    PipeShell has no per-edge history callback. This contract consequently
    admits only the same direct source pair as the cap-face bridge and only a
    profile with one retained direct source edge. The adapter independently
    proves that the role face has one exact final boundary edge.
    """
    try:
        _call, owner, topology, kind, definition = _direct_make_query(value)
    except ValueError:
        return None
    if topology != "CAP_EDGE" or kind not in {"edge", "entitytype.edge"}:
        return None
    query = parse_query(value)
    if query.is_start is None:
        return None
    producer_id = f"f_{owner}"
    producer = feature_by_id.get(producer_id)
    params = (producer or {}).get("params") or {}
    contract = params.get("cap_output_contract")
    if (
        producer is None
        or previous[-1:] != [producer_id]
        or producer.get("atomic_id") != "sweep_add"
        or params.get("result_mode") != "new_body"
        or params.get("initial_output_roles") is not True
        or not isinstance(contract, dict)
    ):
        return None
    required = ("profile_source", "profile_entity", "path_source", "path_entity", "path_reversed")
    if (
        any(not isinstance(contract.get(name), str) or not contract[name] for name in required[:-1])
        or not isinstance(contract.get("path_reversed"), bool)
    ):
        return None
    sketch = sketches_by_id.get(str(producer.get("sketch_id") or "")) or {}
    profile = sketch.get("profile") or {}
    if (
        sketch.get("source_sketch_id") != contract["profile_source"]
        or profile.get("type") != "circle"
        or profile.get("source_entity_id") != contract["profile_entity"]
    ):
        return None
    refs = _source_refs(definition.get("disambiguationData"))
    profile_ref = (contract["profile_source"], contract["profile_entity"])
    path_prefix = f"{contract['path_entity']}."
    path_refs = [ref for ref in refs if ref[0] == contract["path_source"] and ref[1].startswith(path_prefix)]
    if len(refs) != 2 or profile_ref not in refs or len(path_refs) != 1:
        return None
    suffix = path_refs[0][1][len(path_prefix):]
    expected_endpoint = "start" if query.is_start else "end"
    if suffix != expected_endpoint:
        return None
    role_endpoint = suffix if not contract["path_reversed"] else ("end" if suffix == "start" else "start")
    role = f"sweep.{role_endpoint}"
    intent = _selector_intent(
        value,
        query_family="CAP_EDGE",
        kind="edge",
        evidence="kernel_history",
        allowed=("boundary",),
        disambiguation={
            "type": "sweep_profile_path_endpoint",
            **{name: contract[name] for name in required},
            "path_endpoint": suffix,
        },
    )
    # ``parse_query`` retains the endpoint as its convenience primary source
    # for this two-anchor OSD. CAP_EDGE lineage is anchored on the profile
    # edge; the path endpoint remains explicit disambiguation evidence.
    intent["source_entity"] = {
        "sketch_id": contract["profile_source"],
        "entity_id": contract["profile_entity"],
    }
    intent["lineage_role"] = role
    return {
        "kind": "edge",
        "owner_feature_id": producer_id,
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "selector_intent": intent,
    }


def _initial_direct_sweep_swept_face_selector(
    value: Any,
    feature_by_id: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    previous: list[str],
) -> dict[str, Any] | None:
    """Bind one direct PipeShell side face through `Generated(profile_edge)`.

    The complete direct profile/path source contract remains mandatory. The
    consumer receives only its selected profile edge as its runtime anchor:
    the path edge is retained as source disambiguation, not turned into
    geometry.  Listing every source edge in the contract prevents a partial
    or solver-rebuilt profile from looking like a direct builder history.
    """
    try:
        _call, owner, topology, kind, definition = _direct_make_query(value)
    except ValueError:
        return None
    if topology != "SWEPT_FACE" or kind not in {"face", "entitytype.face"}:
        return None
    producer_id = f"f_{owner}"
    producer = feature_by_id.get(producer_id)
    params = (producer or {}).get("params") or {}
    contract = params.get("swept_face_contract")
    if (
        producer is None
        or previous[-1:] != [producer_id]
        or producer.get("atomic_id") != "sweep_add"
        or params.get("result_mode") != "new_body"
        or params.get("initial_output_roles") is not True
        or not isinstance(contract, dict)
    ):
        return None
    required = ("profile_source", "profile_entities", "path_source", "path_entity", "path_reversed")
    if (
        any(not isinstance(contract.get(name), str) or not contract[name] for name in ("profile_source", "path_source", "path_entity"))
        or not isinstance(contract.get("profile_entities"), list)
        or not contract["profile_entities"]
        or any(not isinstance(entity, str) or not entity for entity in contract["profile_entities"])
        or len(set(contract["profile_entities"])) != len(contract["profile_entities"])
        or not isinstance(contract.get("path_reversed"), bool)
    ):
        return None
    sketch = sketches_by_id.get(str(producer.get("sketch_id") or "")) or {}
    profile_entities = _direct_sweep_profile_entities(sketch)
    if sketch.get("source_sketch_id") != contract["profile_source"] or profile_entities != contract["profile_entities"]:
        return None
    refs = _source_refs(definition.get("disambiguationData"))
    path_ref = (contract["path_source"], contract["path_entity"])
    profile_refs = [ref for ref in refs if ref[0] == contract["profile_source"] and ref[1] in profile_entities]
    if len(refs) != 2 or len(profile_refs) != 1 or path_ref not in refs:
        return None
    selected_profile_entity = profile_refs[0][1]
    intent = _selector_intent(
        value,
        query_family="SWEPT_FACE",
        kind="face",
        evidence="kernel_history",
        allowed=("boundary",),
        disambiguation={
            "type": "sweep_profile_path",
            **{name: contract[name] for name in required},
        },
    )
    intent["source_entity"] = {
        "sketch_id": contract["profile_source"],
        "entity_id": selected_profile_entity,
    }
    return {
        "kind": "face",
        "owner_feature_id": producer_id,
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "selector_intent": intent,
    }


def _direct_sweep_profile_entities(sketch: dict[str, Any]) -> list[str] | None:
    """Return one unchanged direct closed profile's complete source edge set.

    PipeShell can report `Generated(edge)` for every profile edge, but only if
    CDSL retains the full original contour.  This deliberately rejects holes,
    regions and any unlabeled/split edge rather than guessing a correspondence.
    """
    profile = sketch.get("profile") or {}
    if profile.get("type") == "circle":
        entity = profile.get("source_entity_id")
        return [entity] if isinstance(entity, str) and entity else None
    contours = profile.get("contours") if profile.get("type") == "analytic_contours" else None
    if not isinstance(contours, list) or len(contours) != 1:
        return None
    contour = contours[0] or {}
    segments = contour.get("segments") if isinstance(contour, dict) else None
    if not contour.get("closed") or not isinstance(segments, list) or not segments:
        return None
    entities = [segment.get("source_entity_id") for segment in segments if isinstance(segment, dict)]
    if len(entities) != len(segments) or any(not isinstance(entity, str) or not entity for entity in entities):
        return None
    return entities if len(set(entities)) == len(entities) else None


def _direct_sweep_profile_vertex_entity_pairs(sketch: dict[str, Any]) -> set[tuple[str, str]]:
    """Return exact adjacent source-edge pairs for a direct closed contour."""
    entities = _direct_sweep_profile_entities(sketch)
    if entities is None or len(entities) < 2:
        return set()
    return {
        tuple(sorted((entities[index], entities[(index + 1) % len(entities)])))
        for index in range(len(entities))
    }


def _initial_direct_sweep_swept_edge_selector(
    value: Any,
    feature_by_id: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    previous: list[str],
) -> dict[str, Any] | None:
    """Bind a PipeShell swept edge through `Generated(profile_vertex)`.

    CADFS identifies the source vertex by exactly two incident profile edges
    and separately supplies the direct path edge. The path remains semantic
    disambiguation: the runtime anchor is the exact profile vertex only.
    """
    try:
        _call, owner, topology, kind, definition = _direct_make_query(value)
    except ValueError:
        return None
    if topology != "SWEPT_EDGE" or kind not in {"edge", "entitytype.edge"}:
        return None
    producer_id = f"f_{owner}"
    producer = feature_by_id.get(producer_id)
    params = (producer or {}).get("params") or {}
    contract = params.get("swept_edge_contract")
    if (
        producer is None
        or previous[-1:] != [producer_id]
        or producer.get("atomic_id") != "sweep_add"
        or params.get("result_mode") != "new_body"
        or params.get("initial_output_roles") is not True
        or not isinstance(contract, dict)
    ):
        return None
    required = ("profile_source", "profile_entities", "path_source", "path_entity", "path_reversed")
    if (
        any(not isinstance(contract.get(name), str) or not contract[name] for name in ("profile_source", "path_source", "path_entity"))
        or contract["profile_source"] == contract["path_source"]
        or not isinstance(contract.get("profile_entities"), list)
        or len(contract["profile_entities"]) < 2
        or any(not isinstance(entity, str) or not entity for entity in contract["profile_entities"])
        or len(set(contract["profile_entities"])) != len(contract["profile_entities"])
        or not isinstance(contract.get("path_reversed"), bool)
    ):
        return None
    sketch = sketches_by_id.get(str(producer.get("sketch_id") or "")) or {}
    profile_entities = _direct_sweep_profile_entities(sketch)
    if sketch.get("source_sketch_id") != contract["profile_source"] or profile_entities != contract["profile_entities"]:
        return None
    refs = _source_refs(definition.get("disambiguationData"))
    path_ref = (contract["path_source"], contract["path_entity"])
    profile_refs = [ref for ref in refs if ref[0] == contract["profile_source"] and ref[1] in profile_entities]
    vertex_entities = tuple(sorted(ref[1] for ref in profile_refs))
    if (
        len(refs) != 3
        or len(set(refs)) != 3
        or len(profile_refs) != 2
        or len(set(vertex_entities)) != 2
        or path_ref not in refs
        or vertex_entities not in _direct_sweep_profile_vertex_entity_pairs(sketch)
    ):
        return None
    intent = _selector_intent(
        value,
        query_family="SWEPT_EDGE",
        kind="edge",
        evidence="kernel_history",
        allowed=("boundary",),
        disambiguation={
            "type": "sweep_profile_vertex_path",
            **{name: contract[name] for name in required},
            "profile_vertex_entities": list(vertex_entities),
        },
    )
    intent.pop("source_entity", None)
    intent["source_entities"] = [
        {"sketch_id": contract["profile_source"], "entity_id": entity_id}
        for entity_id in vertex_entities
    ]
    return {
        "kind": "edge",
        "owner_feature_id": producer_id,
        "source": "runtime_snapshot",
        "confidence": 1.0,
        "selector_intent": intent,
    }


def _profile_query_union_leaves(value: Any) -> list[Any]:
    """Flatten only associative query unions used to select one profile.

    FeatureScript histories can wrap a qUnion in a second qUnion when a local
    alias is later assigned to ``entities``.  The wrapper changes neither the
    selected topology nor the source provenance.  Keeping this normalization
    local to CAP_EDGE profile recognition avoids changing generic selector
    parsing, where query grouping may still be diagnostically meaningful.
    """
    if isinstance(value, Call) and value.name == "qUnion" and value.args and isinstance(value.args[0], list):
        return [leaf for item in value.args[0] for leaf in _profile_query_union_leaves(item)]
    return [value]


def _cap_edge_hole_profile_sketch(
    value: Any,
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    feature_frames: dict[str, dict[str, Any]],
    feature_id: str,
) -> tuple[dict[str, Any], dict[str, Any]] | None:
    """Materialize an outer IMPRINT profile with one CAP_EDGE-derived inner wire.

    The inner curve may already be a draft/offset B-rep edge, so it must be
    taken from its producer's selected cap face at runtime rather than guessed
    from the original sketch entity. This intentionally accepts one outer
    closed region and one uniquely framed cap edge only.
    """
    roots = _profile_query_union_leaves(value)
    if len(roots) != 2:
        return None
    outer_value = next((item for item in roots if parse_query(item).topology_type == "IMPRINT"), None)
    inner_value = next((item for item in roots if parse_query(item).topology_type == "CAP_EDGE"), None)
    if outer_value is None or inner_value is None:
        return None
    # 同向的 TD region query 选择的是外轮廓两侧相邻的两个 IMPRINT 区域。
    # 将二者并集解释成 "外轮廓减 CAP_EDGE" 会错误挖去中心，留下一个仅沿
    # 边接触前序实体的薄环。只有两条边的 region side 相反时，才有明确的
    # 外环 + 内孔语义可以交给受限的 CAP_EDGE profile atomic。
    outer_side = _profile_selection_side(outer_value)
    inner_side = _profile_selection_side(inner_value)
    if outer_side is not None and inner_side is not None and outer_side == inner_side:
        return None
    outer = parse_query(outer_value)
    if not outer.source_sketch or outer.source_sketch not in sketch_by_source:
        return None
    outer_sketch = _profile_selection_sketch(
        sketch_by_source[outer.source_sketch], outer_value,
        entity_by_sketch[outer.source_sketch], feature_id,
    )
    profile = outer_sketch.get("profile") or {}
    contours = profile.get("contours") if profile.get("type") == "analytic_contours" else None
    if not (
        profile.get("type") == "circle"
        or isinstance(contours, list) and len(contours) == 1 and bool(contours[0].get("closed"))
    ):
        return None
    selector = _cap_face_selector(inner_value, feature_frames, feature_id, "profile_hole")
    return (outer_sketch, selector) if selector is not None else None


def _cap_edge_union_profile_sketch(
    value: Any,
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    feature_id: str,
) -> dict[str, Any] | None:
    """Materialize the complete outer region selected around one CAP_EDGE."""
    roots = _profile_query_union_leaves(value)
    if len(roots) != 2:
        return None
    outer_value = next((item for item in roots if parse_query(item).topology_type == "IMPRINT"), None)
    inner_value = next((item for item in roots if parse_query(item).topology_type == "CAP_EDGE"), None)
    if outer_value is None or inner_value is None:
        return None
    outer_side = _profile_selection_side(outer_value)
    inner_side = _profile_selection_side(inner_value)
    if outer_side is None or inner_side is None or outer_side != inner_side:
        return None
    outer = parse_query(outer_value)
    if not outer.source_sketch or outer.source_sketch not in sketch_by_source:
        return None
    return _profile_selection_sketch(
        sketch_by_source[outer.source_sketch], outer_value,
        entity_by_sketch[outer.source_sketch], feature_id,
    )


def _loft_cap_face_profile(
    params: dict[str, Any],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    feature_frames: dict[str, dict[str, Any]],
    feature_id: str,
) -> tuple[dict[str, Any], dict[str, Any], dict[str, Any]] | None:
    """Resolve one CAP_FACE outer wire followed by one sketch-imprint loft section."""
    profiles = params.get("sheetProfilesArray")
    if not isinstance(profiles, list) or len(profiles) != 2:
        return None
    values = [item.get("sheetProfileEntities") if isinstance(item, dict) else item for item in profiles]
    cap, sketch_query = (parse_query(value) for value in values)
    if cap.topology_type != "CAP_FACE" or sketch_query.topology_type != "IMPRINT":
        return None
    if not sketch_query.source_sketch or sketch_query.source_sketch not in sketch_by_source:
        return None
    selector = _cap_face_selector(values[0], feature_frames, feature_id, "loft_cap")
    frame = feature_frames.get(cap.owner_feature or "")
    cap_frame = frame and frame.get("start" if cap.is_start else "end")
    if selector is None or cap_frame is None:
        return None
    sketch = _profile_selection_sketch(
        sketch_by_source[sketch_query.source_sketch], values[1],
        entity_by_sketch[sketch_query.source_sketch], feature_id,
    )
    return sketch, selector, dict(cap_frame)


def _profile_selection_sketch(
    sketch: dict[str, Any],
    query_value: Any,
    entities: dict[str, dict[str, Any]],
    feature_id: str,
) -> dict[str, Any]:
    """Materialize a uniquely selected sketch region for an IMPRINT query."""
    query = parse_query(query_value)
    if query.topology_type != "IMPRINT" or not query.source_entity:
        return sketch
    contours = (sketch.get("profile") or {}).get("contours") or []
    query_values = _queries(query_value)
    selections = [parse_query(item) for item in query_values]

    union_profile = _circle_imprint_union_profile(contours, query_values, entities)
    if union_profile is not None:
        output = deepcopy(sketch)
        output["id"] = f"{sketch['id']}__{feature_id}"
        output["name"] = f"{sketch['name']}__{feature_id}"
        output["profile"] = union_profile
        return output

    def line_loop(contour: dict[str, Any]) -> list[list[float]] | None:
        segments = contour.get("segments") or []
        if not isinstance(segments, list) or len(segments) < 3 or not all(
            isinstance(segment, dict) and segment.get("type") == "line"
            and isinstance(segment.get("start"), list) and isinstance(segment.get("end"), list)
            for segment in segments
        ):
            return None
        points = [list(segment["start"]) for segment in segments]
        if any(math.dist(segment["end"], segments[(index + 1) % len(segments)]["start"]) > 1e-6
               for index, segment in enumerate(segments)):
            return None
        return points

    def strictly_contains(outer: list[list[float]], inner: list[list[float]]) -> bool:
        """Return whether a closed line loop contains every inner vertex.

        This is source-profile construction, not a selector fallback: both
        loops originate from the exact FeatureScript sketch entities. Boundary
        contact remains rejected because it has split/region semantics that
        cannot be represented by a single direct analytic profile.
        """
        def inside(point: list[float]) -> bool:
            crossings = 0
            for index, start in enumerate(outer):
                end = outer[(index + 1) % len(outer)]
                cross = (end[0] - start[0]) * (point[1] - start[1]) - (end[1] - start[1]) * (point[0] - start[0])
                if abs(cross) <= 1e-8 and min(start[0], end[0]) - 1e-8 <= point[0] <= max(start[0], end[0]) + 1e-8 and min(start[1], end[1]) - 1e-8 <= point[1] <= max(start[1], end[1]) + 1e-8:
                    return False
                if (start[1] > point[1]) != (end[1] > point[1]):
                    x = start[0] + (point[1] - start[1]) * (end[0] - start[0]) / (end[1] - start[1])
                    if abs(x - point[0]) <= 1e-8:
                        return False
                    if x > point[0]:
                        crossings += 1
            return bool(crossings % 2)
        return bool(inner) and all(inside(point) for point in inner)

    # A single IMPRINT query over one outer direct line loop denotes the
    # source-side region, not merely that loop's curve. If every other source
    # line loop lies strictly inside it, preserve those nested boundaries so
    # the derived profile retains its holes and their CAP-edge provenance.
    # Disjoint, touching, curved, split and multiple-outer arrangements keep
    # the existing explicit-region paths below.
    if len(selections) == 1:
        source_id = max((key for key in entities if selections[0].source_entity and selections[0].source_entity.startswith(key)), key=len, default="")
        side = _profile_selection_side(query_values[0]) if query_values else None
        if source_id and side is not None:
            matches = [
                (contour, next((_matching_profile_segment(segment, entities[source_id]) for segment in contour.get("segments") or [] if _matching_profile_segment(segment, entities[source_id])), 0))
                for contour in contours
                if any(_matching_profile_segment(segment, entities[source_id]) for segment in contour.get("segments") or [])
            ]
            outer_loop = line_loop(matches[0][0]) if len(matches) == 1 and matches[0][1] == (1 if side > 0 else -1) else None
            other_loops = [line_loop(contour) for contour in contours if not matches or contour is not matches[0][0]]
            if outer_loop is not None and other_loops and all(loop is not None and strictly_contains(outer_loop, loop) for loop in other_loops):
                output = deepcopy(sketch)
                output["id"] = f"{sketch['id']}__{feature_id}"
                output["name"] = f"{sketch['name']}__{feature_id}"
                # Keep the source profile roles/segments intact. The solver
                # performs the established containment-parity classification.
                return output

    # qUnion 可以从同一草图选择多个互不相同的 IMPRINT region。此前只取
    # parse_query(qUnion(...)) 最后看到的一个 source entity，且在没有正反
    # orientation 对时退回整张草图，导致未选圆也被错误拉伸。仅当每个 source
    # entity 唯一对应一条 contour 时，直接物化该明确选择集；同源的双侧 region
    # 继续交给下方的 orientation 逻辑，避免把环形区域猜成圆盘。
    source_ids = [
        max((key for key in entities if selection.source_entity and selection.source_entity.startswith(key)), key=len, default="")
        for selection in selections
    ]
    # 单一同心圆边的 IMPRINT 查询并不总是选择圆盘。它表达的是该边
    # 一侧的 bounded region；例如 `00111611` F7 选 E6 的正侧时，真实
    # profile 是 E7/E6 环域而不是 E6 圆盘。
    if len(selections) == 1 and source_ids and source_ids[0]:
        source = entities[source_ids[0]]
        profile = _circle_imprint_region(contours, source, _profile_selection_side(_queries(query_value)[0]))
        if profile is not None:
            output = deepcopy(sketch)
            output["id"] = f"{sketch['id']}__{feature_id}"
            output["name"] = f"{sketch['name']}__{feature_id}"
            output["profile"] = profile
            return output
    if (
        len(source_ids) == len(set(source_ids))
        and all(source_ids)
        and all(selection.topology_type == "IMPRINT" and selection.source_entity for selection in selections)
    ):
        selected: list[dict[str, Any]] = []
        for selected_id in source_ids:
            source = entities[selected_id]
            matches = [
                contour for contour in contours
                if any(_matching_profile_segment(segment, source) for segment in contour.get("segments") or [])
            ]
            if len(matches) != 1:
                break
            selected.append(matches[0])
        else:
            output = deepcopy(sketch)
            output["id"] = f"{sketch['id']}__{feature_id}"
            output["name"] = f"{sketch['name']}__{feature_id}"
            output["profile"] = {**output["profile"], "contours": selected}
            return output

    source_id = max((key for key in entities if query.source_entity.startswith(key)), key=len, default="")
    source = entities.get(source_id)
    if source is None or len(contours) < 2:
        return sketch
    selection_sides = [_profile_selection_side(item) for item in _queries(query_value)]
    if source.get("type") == "circle" and all(side is not None for side in selection_sides):
        # 两个相反 orientation 的同一圆形 IMPRINT region 表示其两侧区域的
        # 并集。对于同心圆草图，CADFS 用这套写法选择内圆盘和相邻圆环；将它
        # 们规整为最小包围圆盘，不能按普通 nested-circle profile 误作圆环。
        circles = [
            segment for contour in contours for segment in contour.get("segments") or []
            if segment.get("type") == "circle" and _same_point(segment.get("center") or [], source.get("center") or [])
        ]
        radii = sorted({float(segment["radius_mm"]) for segment in circles})
        if len(radii) >= 2 and any(side < 0 for side in selection_sides) and any(side > 0 for side in selection_sides):
            outer = next((radius for radius in radii if radius > float(source["radius_mm"]) + 1e-6), None)
            if outer is not None:
                output = deepcopy(sketch)
                output["id"] = f"{sketch['id']}__{feature_id}"
                output["name"] = f"{sketch['name']}__{feature_id}"
                output["profile"] = {"type": "circle", "center": list(source["center"]), "radius_mm": outer}
                return output
    matches: list[tuple[dict[str, Any], int]] = []
    for contour in contours:
        direction = next((_matching_profile_segment(segment, source) for segment in contour.get("segments") or [] if _matching_profile_segment(segment, source)), 0)
        if direction: matches.append((contour, direction))
    side = _profile_selection_side(query_value)
    if side is None or len(matches) < 2:
        return sketch
    selected = [contour for contour, direction in matches if direction == (1 if side > 0 else -1)]
    if len(selected) != 1:
        raise UnsupportedCapability("sketch_region_selection", "IMPRINT profile selection does not resolve one sketch region")
    output = deepcopy(sketch)
    output["id"] = f"{sketch['id']}__{feature_id}"
    output["name"] = f"{sketch['name']}__{feature_id}"
    output["profile"] = {**output["profile"], "contours": [selected[0]]}
    return output


def _surface_profile_selection_sketch(
    sketch: dict[str, Any],
    query_value: Any,
    entities: dict[str, dict[str, Any]],
    feature_id: str,
    *,
    allow_open_wire: bool = False,
) -> dict[str, Any]:
    """Materialize explicitly selected source wires from ``surfaceEntities``.

    Mixed solid/surface extrusion continues to accept one or more circular wires.
    A pure ``ToolBodyType.SURFACE`` extrusion may additionally carry one or
    more original lines.  Each connected, non-branching open chain becomes
    one shell wire; it never becomes a solid profile or active-body member.
    """
    references = _source_refs(query_value)
    selected: list[tuple[str, dict[str, Any]]] = []
    seen = set()
    duplicate_source = False
    for source, entity_id in references:
        if source != sketch["name"]:
            raise UnsupportedCapability(
                "extrude_surface_profile",
                "surface extrude source wires must come from one source sketch",
            )
        if entity_id in seen:
            duplicate_source = True
            continue
        entity = entities.get(entity_id)
        if entity is None or entity.get("construction"):
            raise UnsupportedCapability(
                "extrude_surface_profile",
                "current CDSL surface extrude requires one explicit original source wire",
            )
        selected.append((entity_id, entity)); seen.add(entity_id)
    if not selected:
        raise ValueError("surface extrude profile query is unresolved")
    output = deepcopy(sketch)
    output["id"] = f"{sketch['id']}__{feature_id}_surface"
    output["name"] = f"{sketch['name']}__{feature_id}_surface"
    if allow_open_wire and all(entity.get("type") == "line" for _entity_id, entity in selected):
        if duplicate_source:
            raise UnsupportedCapability(
                "extrude_surface_profile",
                "pure ToolBodyType.SURFACE open-wire extrusion requires distinct source lines",
            )
        records: list[tuple[str, dict[str, Any], list[float], list[float]]] = []
        for entity_id, entity in selected:
            start, end = entity.get("start"), entity.get("end")
            if (
                not isinstance(start, list)
                or not isinstance(end, list)
                or len(start) != 2
                or len(end) != 2
                or not all(isinstance(value, (int, float)) and math.isfinite(float(value)) for value in [*start, *end])
                or _same_point(start, end)
            ):
                raise UnsupportedCapability(
                    "extrude_surface_profile",
                    "pure ToolBodyType.SURFACE open-wire extrusion requires finite non-degenerate source lines",
                )
            records.append((entity_id, entity, list(start), list(end)))

        # A query set may deliberately contain disconnected wires, but each
        # component must itself have one unambiguous pair of terminal points.
        # Query encounter order is only a tie-breaker for a proven chain's
        # direction; it is never used to join or choose nearby geometry.
        remaining_components = set(range(len(records)))
        contours: list[dict[str, Any]] = []
        while remaining_components:
            seed = min(remaining_components)
            component = {seed}
            frontier = [seed]
            while frontier:
                index = frontier.pop()
                _entity_id, _entity, start, end = records[index]
                for candidate in remaining_components - component:
                    _candidate_id, _candidate, candidate_start, candidate_end = records[candidate]
                    if any(
                        _same_point(point, candidate_point)
                        for point in (start, end)
                        for candidate_point in (candidate_start, candidate_end)
                    ):
                        component.add(candidate)
                        frontier.append(candidate)
            remaining_components -= component

            def incident_count(point: list[float]) -> int:
                return sum(
                    int(_same_point(point, start)) + int(_same_point(point, end))
                    for index in component
                    for _entity_id, _entity, start, end in [records[index]]
                )

            terminals = [
                endpoint
                for index in sorted(component)
                for endpoint in records[index][2:]
                if incident_count(endpoint) == 1
            ]
            if len(terminals) != 2:
                raise UnsupportedCapability(
                    "extrude_surface_profile",
                    "pure ToolBodyType.SURFACE source lines must form non-branching open chains",
                )
            current = terminals[0]
            component_remaining = set(component)
            segments: list[dict[str, Any]] = []
            while component_remaining:
                matches = [
                    index for index in component_remaining
                    if _same_point(current, records[index][2]) or _same_point(current, records[index][3])
                ]
                if len(matches) != 1:
                    raise UnsupportedCapability(
                        "extrude_surface_profile",
                        "pure ToolBodyType.SURFACE source lines must form non-branching open chains",
                    )
                index = matches[0]
                entity_id, entity, start, end = records[index]
                if _same_point(current, start):
                    segment = deepcopy(entity)
                    current = end
                else:
                    segment = _reversed_sweep_path_segment(entity)
                    current = start
                segment.setdefault("source_entity_id", entity_id)
                segments.append(segment)
                component_remaining.remove(index)
            if incident_count(current) != 1:
                raise UnsupportedCapability(
                    "extrude_surface_profile",
                    "pure ToolBodyType.SURFACE source lines must form non-branching open chains",
                )
            contours.append({
                "role": "open", "closed": False, "surface_wire": True,
                "segments": segments,
            })
        output["profile"] = {
            "type": "analytic_contours",
            "contours": contours,
        }
        return output
    if any(entity.get("type") != "circle" for _entity_id, entity in selected):
        raise UnsupportedCapability(
            "extrude_surface_profile",
            "current CDSL mixed surface extrude requires explicitly selected circular wires",
        )
    output["profile"] = {
        "type": "analytic_contours",
        "contours": [
            {"role": "unknown", "closed": True, "segments": [deepcopy(entity)]}
            for _entity_id, entity in selected
        ],
    }
    return output


def _pattern_source_features(value: Any, previous: list[str]) -> list[str]:
    sources = []
    for call in walk_calls(value):
        if call.name != "makeQuery" or not call.args:
            continue
        owner = symbolic_string(call.args[0])
        if "F" not in owner:
            continue
        source = "f_" + owner[owner.find("F"):].split(".", 1)[0]
        if source in previous and source not in sources:
            sources.append(source)
    if not sources:
        raise ValueError("pattern source features are unresolved")
    return sources


def _pattern_body_history_sources(
    value: Any,
    sources: list[str],
    previous: list[str],
    feature_by_id: dict[str, dict[str, Any]],
    body_aliases: dict[str, str] | None = None,
) -> list[str]:
    """Resolve a selected SWEPT_BODY to its exact current member when known.

    CADFS body queries name the feature that originally created the body.  A
    following ADD sweep can already have become part of that same body before
    `circularPattern` copies it.  When the restricted one-body successor state
    proves that current member, use it directly: the runtime can transform its
    actual B-rep and retain a concrete COPY body member.  Replaying a creator
    plus its additive history would make each replay fragment look like a
    separate source, which loses the instance ownership needed by a later
    COPY(BODY) boolean/transform.

    Without that one-to-one proof, retain the older bounded replay expansion.
    It can preserve geometry for patterns with fused history, but deliberately
    does not claim individual COPY body ownership.
    """
    body_aliases = body_aliases or {}
    swept_body_sources = {
        f"f_{query.owner_feature}"
        for item in _queries(value)
        for query in [parse_query(item)]
        if query.topology_type == "SWEPT_BODY"
        and query.kind in {"body", "entitytype.body"}
        and query.owner_feature
    }
    has_swept_body = bool(swept_body_sources)
    if not has_swept_body:
        return sources
    resolved_sources = {
        source: _resolved_body_alias(source, body_aliases)
        for source in swept_body_sources
    }
    if any(resolved != source for source, resolved in resolved_sources.items()):
        return list(dict.fromkeys(
            resolved_sources.get(source, source)
            for source in sources
        ))
    replayable_adds = {
        "extrude_add_blind", "extrude_add_two_sided", "loft_add",
        "loft_add_with_cap_face", "sweep_add", "revolve_add",
        "sphere_add", "box_add", "cylinder_add",
    }
    output = list(sources)
    source_indexes = [previous.index(source) for source in sources if source in previous]
    if not source_indexes:
        return output
    for feature_id in previous[max(source_indexes) + 1:]:
        feature = feature_by_id.get(feature_id) or {}
        if feature.get("atomic_id") not in replayable_adds:
            continue
        if (feature.get("params") or {}).get("result_mode") == "new_body":
            continue
        output.append(feature_id)
    return list(dict.fromkeys(output))


def _sweep_cap_frames(profile: dict[str, Any], path: dict[str, Any]) -> dict[str, dict[str, Any]] | None:
    """Record physical CAP_FACE frames for one direct open sweep path."""
    segment = path.get("segment") or {}
    path_plane = path.get("workplane") or {}
    profile_plane = profile.get("workplane") or {}
    # A cross-sketch spatial path deliberately has no single planar frame.
    # Its source capture can execute a sweep, but it has not established the
    # planar cap-frame contract used by downstream CAP_FACE lowering.
    if not isinstance(path_plane, dict) or not path_plane:
        return None
    points = segment.get("points") if segment.get("type") == "bspline" else [segment.get("start"), segment.get("end")]
    if not isinstance(points, list) or len(points) < 2 or any(not isinstance(point, list) or len(point) != 2 for point in points):
        return None
    y_dir = _y_dir(path_plane)

    def point(value: list[float]) -> list[float]:
        return [
            path_plane["origin_mm"][index] + path_plane["x_dir"][index] * value[0] + y_dir[index] * value[1]
            for index in range(3)
        ]

    def direction(value: Any, fallback: list[float]) -> list[float]:
        if isinstance(value, list) and len(value) == 2:
            return _unit([
                path_plane["x_dir"][index] * value[0] + y_dir[index] * value[1]
                for index in range(3)
            ], "sweep cap tangent is degenerate")
        return _unit(fallback, "sweep path is degenerate")

    start, end = point(points[0]), point(points[-1])
    if segment.get("type") == "arc":
        center = segment.get("center")
        if not isinstance(center, list) or len(center) != 2:
            return None
        start_radial = [float(points[0][0]) - float(center[0]), float(points[0][1]) - float(center[1])]
        end_radial = [float(points[-1][0]) - float(center[0]), float(points[-1][1]) - float(center[1])]
        if bool(segment.get("clockwise", False)):
            start_tangent, end_tangent = [start_radial[1], -start_radial[0]], [end_radial[1], -end_radial[0]]
        else:
            start_tangent, end_tangent = [-start_radial[1], start_radial[0]], [-end_radial[1], end_radial[0]]
        start_direction = direction(start_tangent, _sub(end, start))
        end_direction = direction(end_tangent, _sub(end, start))
    else:
        start_direction = direction(segment.get("start_tangent"), _sub(point(points[1]), start))
        end_direction = direction(segment.get("end_tangent"), _sub(end, point(points[-2])))
    x_dir = list(profile_plane["x_dir"])
    return {
        # OCC keeps the source profile as the start cap of a solid sweep. Its
        # plane follows the profile workplane, not the tangent of a curved
        # spine. The profile centre may lie at the path point while the plane
        # origin is elsewhere, so retain the actual profile plane frame.
        "start": _frame(list(profile_plane["origin_mm"]), x_dir, list(profile_plane["normal"])),
        "end": _frame(end, x_dir, end_direction),
        "profile": dict(profile_plane),
    }


def _reversed_sweep_path_segment(segment: dict[str, Any]) -> dict[str, Any]:
    """Reverse one CADFS line/arc/B-spline sweep path without changing its curve."""
    output = deepcopy(segment)
    if output.get("type") in {"line", "arc"}:
        output["start"], output["end"] = segment["end"], segment["start"]
    if output.get("type") == "arc":
        output["clockwise"] = not bool(segment.get("clockwise", False))
    if output.get("type") == "bspline":
        output["points"] = list(reversed(segment.get("points") or []))
        if "start" in segment and "end" in segment:
            output["start"], output["end"] = segment["end"], segment["start"]
        parameters = segment.get("parameters")
        if isinstance(parameters, list) and parameters:
            start_parameter, end_parameter = float(parameters[0]), float(parameters[-1])
            output["parameters"] = [start_parameter + end_parameter - float(value) for value in reversed(parameters)]
        start_tangent, end_tangent = segment.get("start_tangent"), segment.get("end_tangent")
        if isinstance(start_tangent, list) and isinstance(end_tangent, list):
            output["start_tangent"] = [-float(value) for value in end_tangent]
            output["end_tangent"] = [-float(value) for value in start_tangent]
    return output


def _reversed_spatial_sweep_path_segment(segment: dict[str, Any]) -> dict[str, Any]:
    """Reverse one globally captured source curve without changing its locus."""
    output = deepcopy(segment)
    if output.get("type") in {"line", "arc"}:
        output["start_mm"], output["end_mm"] = segment["end_mm"], segment["start_mm"]
    if output.get("type") == "arc":
        output["clockwise"] = not bool(segment.get("clockwise", False))
    if output.get("type") == "bspline":
        output["points_mm"] = list(reversed(segment.get("points_mm") or []))
        parameters = segment.get("parameters")
        if isinstance(parameters, list) and parameters:
            start_parameter, end_parameter = float(parameters[0]), float(parameters[-1])
            output["parameters"] = [start_parameter + end_parameter - float(value) for value in reversed(parameters)]
        start_tangent, end_tangent = segment.get("start_tangent_mm"), segment.get("end_tangent_mm")
        if isinstance(start_tangent, list) and isinstance(end_tangent, list):
            output["start_tangent_mm"] = [-float(value) for value in end_tangent]
            output["end_tangent_mm"] = [-float(value) for value in start_tangent]
    return output


def _sweep_path_endpoint(segment: dict[str, Any], endpoint: str) -> list[float] | None:
    if endpoint not in {"start", "end"}:
        return None
    if segment.get("type") == "bspline":
        points = segment.get("points")
        value = points[0 if endpoint == "start" else -1] if isinstance(points, list) and points else None
    else:
        value = segment.get(endpoint)
    if (
        not isinstance(value, list)
        or len(value) != 2
        or not all(isinstance(component, (int, float)) and math.isfinite(float(component)) for component in value)
    ):
        return None
    return [float(value[0]), float(value[1])]


def _same_sweep_path_point(left: list[float], right: list[float]) -> bool:
    return math.dist(left, right) <= 1e-8


def _reversed_sweep_path(path: dict[str, Any]) -> dict[str, Any]:
    output = deepcopy(path)
    segments = output.get("segments")
    if isinstance(segments, list):
        reverse_segment = (
            _reversed_spatial_sweep_path_segment
            if "workplane" not in output
            else _reversed_sweep_path_segment
        )
        output["segments"] = [reverse_segment(segment) for segment in reversed(segments)]
    else:
        segment = output.get("segment")
        if not isinstance(segment, dict):
            raise ValueError("sweep path has no reversible segment")
        output["segment"] = _reversed_sweep_path_segment(segment)
    return output


def _sweep_profile_attaches_at_path_end(profile: dict[str, Any], path: dict[str, Any]) -> bool:
    """Detect a circle profile placed at the terminal point of a CADFS path."""
    profile_plane = profile.get("workplane") or {}
    profile_shape = profile.get("profile") or {}
    segments = path.get("segments")
    if isinstance(segments, list):
        sequence = segments
    else:
        segment = path.get("segment")
        sequence = [segment] if isinstance(segment, dict) else []
    if profile_shape.get("type") != "circle" or not sequence:
        return False
    center = profile_shape.get("center") or [0.0, 0.0]
    if not isinstance(center, list) or len(center) != 2:
        return False
    try:
        profile_center = _global(profile_plane, center)
    except (KeyError, TypeError, ValueError):
        return False
    if "workplane" not in path:
        def spatial_endpoint(segment: dict[str, Any], endpoint: str) -> list[float] | None:
            if segment.get("type") == "bspline":
                points = segment.get("points_mm")
                value = points[0 if endpoint == "start" else -1] if isinstance(points, list) and points else None
            else:
                value = segment.get(f"{endpoint}_mm")
            if (
                not isinstance(value, list)
                or len(value) != 3
                or not all(isinstance(component, (int, float)) and math.isfinite(float(component)) for component in value)
            ):
                return None
            return [float(component) for component in value]

        start_point = spatial_endpoint(sequence[0], "start")
        end_point = spatial_endpoint(sequence[-1], "end")
        if start_point is None or end_point is None:
            return False
    else:
        workplane = path.get("workplane") or {}
        start, end = _sweep_path_endpoint(sequence[0], "start"), _sweep_path_endpoint(sequence[-1], "end")
        if not all(isinstance(value, list) and len(value) == 2 for value in (start, end)):
            return False
        try:
            start_point, end_point = _global(workplane, start), _global(workplane, end)
        except (KeyError, TypeError, ValueError):
            return False
    return math.dist(profile_center, end_point) <= 1e-5 and math.dist(profile_center, start_point) > 1e-5


def _pattern_copy_body(value: Any) -> tuple[str, str, int]:
    """Resolve one CADFS circular-pattern body copy without flattening it to a feature."""
    _call, pattern_owner, topology, kind, definition = _direct_make_query(value)
    if topology != "COPY" or kind not in {"body", "entitytype.body"}:
        raise UnsupportedCapability("delete_bodies", "current CDSL deleteBodies only supports circular pattern body copies")
    derived = definition.get("derivedFrom")
    if derived is None:
        raise ValueError("pattern copy deletion has no derived body")
    _source, source_owner, source_topology, source_kind, _source_definition = _direct_make_query(derived)
    if source_topology != "SWEPT_BODY" or source_kind not in {"body", "entitytype.body"}:
        raise UnsupportedCapability("delete_bodies", "pattern copy deletion source is not a direct swept body")
    try:
        instance = int(str(definition.get("instanceName")))
    except (TypeError, ValueError) as error:
        raise ValueError("pattern copy deletion instance is unresolved") from error
    return f"f_{pattern_owner}", f"f_{source_owner}", instance


def _boolean_body_sources(value: Any) -> list[str]:
    """Resolve CADFS SWEPT_BODY query members to their producing features."""
    sources: list[str] = []
    for query_value in _queries(value):
        query = parse_query(query_value)
        if query.topology_type != "SWEPT_BODY" or query.kind not in {"body", "entitytype.body"}:
            raise ValueError("booleanBodies requires explicit SWEPT_BODY queries")
        if not query.owner_feature:
            raise ValueError("booleanBodies source feature is unresolved")
        source = f"f_{query.owner_feature}"
        if source not in sources:
            sources.append(source)
    if not sources:
        raise ValueError("booleanBodies has no selected bodies")
    return sources


def _boolean_body_references(
    value: Any,
    previous: list[str],
    feature_by_id: dict[str, dict[str, Any]],
    body_aliases: dict[str, str] | None = None,
) -> tuple[list[str], list[dict[str, Any]], list[dict[str, str]]]:
    """Keep direct pattern COPY bodies explicit for boolean selection.

    A body selected from a mirror, circular pattern, or multi-source transform
    COPY is not its producer's aggregate result. Reuse the established
    transform-query provenance parser so each selected body stays qualified by
    its source member at runtime.
    """
    sources, instance_refs, transform_copy_refs = _transform_body_references(
        value, previous, feature_by_id, body_aliases,
    )
    return sources, instance_refs, transform_copy_refs


def _ordered_boolean_body_references(
    value: Any,
    previous: list[str],
    feature_by_id: dict[str, dict[str, Any]],
    body_aliases: dict[str, str] | None = None,
) -> list[tuple[str, Any]]:
    """Resolve targetless body operands without losing FeatureScript order.

    The ordinary helper groups feature, pattern and transform-COPY references
    for the CDSL schema. That grouping is correct for an explicit target/tool
    pair but cannot select one qualified member from a targetless source set.
    Each source query must therefore resolve to exactly one qualified member
    here before the caller applies its explicit target-selection policy.
    """
    ordered: list[tuple[str, Any]] = []
    seen: set[tuple[Any, ...]] = set()
    for query_value in _queries(value):
        sources, instance_refs, transform_copy_refs = _boolean_body_references(
            query_value, previous, feature_by_id, body_aliases,
        )
        candidates = (
            [("feature", source) for source in sources]
            + [("pattern", reference) for reference in instance_refs]
            + [("transform_copy", reference) for reference in transform_copy_refs]
        )
        if len(candidates) != 1:
            raise UnsupportedCapability(
                "boolean_bodies_targets",
                "targetless booleanBodies requires each source operand to resolve one explicit body member",
            )
        kind, candidate = candidates[0]
        if kind == "feature":
            identity = (kind, candidate)
        elif kind == "pattern":
            identity = (
                kind,
                candidate["pattern_feature_id"],
                candidate["source_feature_id"],
                candidate["instance_index"],
            )
        else:
            identity = (
                kind,
                candidate["transform_feature_id"],
                candidate["source_feature_id"],
            )
        if identity not in seen:
            seen.add(identity)
            ordered.append((kind, candidate))
    return ordered


def _shell_target_body_source(
    value: Any,
    previous: list[str],
    body_aliases: dict[str, str],
    body_members: set[str],
) -> str:
    """Lower one CADFS shell ``parts`` query to its live body member.

    ``parts`` is not a hint to shell whichever aggregate currently contains
    the selected faces. It names the CADFS body that owns the shell operation.
    A direct SWEPT_BODY can follow only a lowering-time successor that already
    proves a one-to-one active member; patterns and fused aggregates deliberately
    never enter that alias map.
    """
    queries = _queries(value)
    if len(queries) != 1:
        raise UnsupportedCapability(
            "shell_parts_body_source",
            "current CDSL shell.parts requires exactly one direct SWEPT_BODY",
        )
    _call, owner, topology, kind, _definition = _direct_make_query(queries[0])
    if topology != "SWEPT_BODY" or kind not in {"body", "entitytype.body"}:
        raise UnsupportedCapability(
            "shell_parts_body_source",
            "current CDSL shell.parts requires one direct SWEPT_BODY",
        )
    source = f"f_{owner}"
    if source not in previous:
        raise ValueError("shell parts body source is unresolved")
    source = _resolved_body_alias(source, body_aliases)
    if source not in body_members:
        raise UnsupportedCapability(
            "shell_parts_body_source",
            "shell parts body no longer has one independently selectable member",
        )
    return source


def _hole_scope_body_source(
    value: Any,
    previous: list[str],
    body_aliases: dict[str, str],
    body_members: set[str],
) -> str:
    """Lower one CADFS ``hole.scope`` query to its sole live body member.

    Hole scope is an ownership constraint, not permission to cut the current
    aggregate. This first contract accepts one direct CADFS ``SWEPT_BODY``
    only while the lowering-side body graph proves that it remains the one
    independently selectable active member.
    """
    queries = _queries(value)
    if len(queries) != 1:
        raise UnsupportedCapability(
            "hole_scope_body_source",
            "current CDSL hole.scope requires exactly one direct SWEPT_BODY",
        )
    _call, owner, topology, kind, _definition = _direct_make_query(queries[0])
    if topology != "SWEPT_BODY" or kind not in {"body", "entitytype.body"}:
        raise UnsupportedCapability(
            "hole_scope_body_source",
            "current CDSL hole.scope requires one direct SWEPT_BODY",
        )
    source = f"f_{owner}"
    if source not in previous:
        raise ValueError("hole scope body source is unresolved")
    source = _resolved_body_alias(source, body_aliases)
    if source not in body_members:
        raise UnsupportedCapability(
            "hole_scope_body_source",
            "hole scope body is no longer an independently selectable member",
        )
    return source


def _is_direct_hole_location_query(value: Any) -> bool:
    """Return whether ``value`` has Hole's direct original-vertex form.

    This is intentionally narrower than ``parse_query``'s recursive source
    extraction. A wrapper can contain an ``sQuery`` leaf, but that does not
    make it a direct Hole location or turn a missing sketch frame into its
    primary diagnostic.
    """
    if not isinstance(value, Call) or value.name not in {"sQuery", "sketchEntityQuery"} or len(value.args) < 3:
        return False
    info = parse_query(value)
    return (
        info.topology_type is None
        and info.kind in {"vertex", "entitytype.vertex"}
        and isinstance(info.source_sketch, str)
        and isinstance(info.source_entity, str)
    )


def _direct_hole_location(
    value: Any,
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> tuple[list[float], dict[str, Any]] | None:
    """Resolve one original sketch vertex accepted by FeatureScript hole.

    The Hole API exposes locations as sketch vertices. A circle centre, an
    explicitly computed original arc centre, and direct line/arc endpoints
    are source vertices too, but derived suffixes,
    topology output, query combinators, and geometry proximity do not prove a
    location. Return local plane coordinates because the hole executor uses
    its host frame to construct the final 3D point.
    """
    if not _is_direct_hole_location_query(value):
        return None
    info = parse_query(value)
    sketch = sketch_by_source.get(info.source_sketch)
    entities = entity_by_sketch.get(info.source_sketch) or {}
    if sketch is None:
        return None
    token = info.source_entity
    entity_id = max((key for key in entities if token == key or token.startswith(key + ".")), key=len, default="")
    entity = entities.get(entity_id)
    if entity is None:
        return None
    suffix = "" if token == entity_id else token[len(entity_id) + 1:]
    point: list[float] | None = None
    if entity.get("type") == "point" and not suffix:
        point = entity.get("point")
    elif entity.get("type") == "circle" and suffix == "center":
        point = entity.get("center")
    elif entity.get("type") == "arc" and suffix == "center":
        # ``_arc`` derives this exact source datum from skArc's required
        # start/mid/end inputs. It remains source-sketch provenance, unlike
        # a center inferred from a runtime curve or a trimmed arc offspring.
        point = entity.get("center")
    elif entity.get("type") in {"line", "arc"} and suffix in {"start", "end"}:
        point = entity.get(suffix)
    if not isinstance(point, list) or len(point) != 2 or not all(isinstance(component, (int, float)) for component in point):
        return None
    return [float(point[0]), float(point[1]), 0.0], sketch["workplane"]


def _direct_sketch_wire_selection(
    value: Any,
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    *,
    featurescript_version: str | None,
    standard_library: str | None,
    standard_library_version: str | None,
    permit_construction: bool = False,
    allowed_curve_types: frozenset[str] = frozenset({"line", "arc", "bspline"}),
) -> tuple[str, list[tuple[str, dict[str, Any]]], dict[str, Any]] | None:
    """Resolve the exact source entities named by one direct sketch-wire query.

    ``qBodyType(qCreatedBy(sketch, EDGE), WIRE)`` filters the source sketch's
    reference-wire entities; it does not select runtime body topology. The
    optional ``qConstructionFilter(..., NO)`` is evaluated against source
    construction metadata. Without it, any construction curve in the source
    result makes a sweep-path query ambiguous and remains deferred. The
    source-only datum-axis caller may explicitly retain construction curves,
    because FeatureScript permits a construction wire as a plane axis. A single-item
    qUnion is only the set identity here, never permission to flatten or pick
    among several source sketches.
    """
    if (
        featurescript_version != "1511"
        or standard_library != "onshape/std/geometry.fs"
        or standard_library_version != "1511.0"
    ):
        return None
    if (
        not isinstance(value, Call)
        or value.name != "qUnion"
        or len(value.args) != 1
        or not isinstance(value.args[0], list)
        or not value.args[0]
    ):
        return None
    operands = value.args[0]
    # A direct union of sketch edges is already an explicit source set. It
    # has different semantics from qCreatedBy(..., WIRE): do not flatten
    # nested queries or evaluate filters here. Each leaf must identify one
    # original source curve from exactly one sketch.
    if all(
        isinstance(operand, Call)
        and operand.name in {"sQuery", "sketchEntityQuery"}
        and len(operand.args) >= 3
        for operand in operands
    ):
        infos = [parse_query(operand) for operand in operands]
        if any(
            info.topology_type is not None
            or info.kind not in {"edge", "entitytype.edge"}
            or not isinstance(info.source_sketch, str)
            or not isinstance(info.source_entity, str)
            for info in infos
        ):
            return None
        sources = {info.source_sketch for info in infos}
        if len(sources) != 1:
            return None
        source = next(iter(sources))
        sketch = sketch_by_source.get(source)
        entities = entity_by_sketch.get(source) or {}
        entity_ids = [str(info.source_entity) for info in infos]
        if (
            sketch is None
            or len(set(entity_ids)) != len(entity_ids)
            or any(entity_id not in entities for entity_id in entity_ids)
        ):
            return None
        candidates = [(entity_id, entities[entity_id]) for entity_id in entity_ids]
        if (
            any(entity.get("construction") for _entity_id, entity in candidates)
            or any(entity.get("type") not in allowed_curve_types for _entity_id, entity in candidates)
        ):
            return None
        return source, candidates, sketch
    if len(operands) != 1:
        return None
    current = operands[0]
    has_construction_filter = isinstance(current, Call) and current.name == "qConstructionFilter"
    if has_construction_filter:
        if len(current.args) != 2 or symbolic_string(current.args[1]).rsplit(".", 1)[-1].upper() != "NO":
            return None
        current = current.args[0]
    if not isinstance(current, Call) or current.name != "qBodyType" or len(current.args) != 2:
        return None
    if symbolic_string(current.args[1]).rsplit(".", 1)[-1].upper() != "WIRE":
        return None
    current = current.args[0]
    if not isinstance(current, Call) or current.name != "qCreatedBy" or len(current.args) != 2:
        return None
    if symbolic_string(current.args[1]).rsplit(".", 1)[-1].upper() != "EDGE":
        return None
    source = parse_query(current).owner_feature
    sketch = sketch_by_source.get(source or "")
    entities = entity_by_sketch.get(source or "") or {}
    if sketch is None:
        return None
    # ``qCreatedBy(..., EDGE)`` cannot select direct sketch points. They remain
    # in the source-entity map for vertex consumers, but do not participate in
    # this source wire or its construction-filter semantics.
    all_candidates = [
        (entity_id, entity)
        for entity_id, entity in entities.items()
        if entity.get("type") != "point"
    ]
    if not all_candidates:
        return None
    if (
        not permit_construction
        and not has_construction_filter
        and any(entity.get("construction") for _entity_id, entity in all_candidates)
    ):
        return None
    candidates = [
        (entity_id, entity)
        for entity_id, entity in all_candidates
        if not entity.get("construction") or (permit_construction and not has_construction_filter)
    ]
    if not candidates or any(entity.get("type") not in allowed_curve_types for _entity_id, entity in candidates):
        return None
    return str(source), candidates, sketch


def _direct_closed_sketch_wire_profile(
    value: Any,
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    *,
    featurescript_version: str | None,
    standard_library: str | None,
    standard_library_version: str | None,
    feature_id: str,
) -> dict[str, Any] | None:
    """Materialize one source-only closed wire for an independent surface loft.

    This is deliberately narrower than general ``qBodyType`` evaluation: the
    exact source query must enumerate one sketch's non-construction wire
    curves, and those curves must form exactly one closed, non-branching
    contour.  No runtime topology or geometric matching participates.
    """
    if (
        not isinstance(value, Call)
        or value.name != "qUnion"
        or len(value.args) != 1
        or not isinstance(value.args[0], list)
        or len(value.args[0]) != 1
        or not isinstance(value.args[0][0], Call)
        or value.args[0][0].name != "qConstructionFilter"
    ):
        return None
    selection = _direct_sketch_wire_selection(
        value, sketch_by_source, entity_by_sketch,
        featurescript_version=featurescript_version,
        standard_library=standard_library,
        standard_library_version=standard_library_version,
        allowed_curve_types=frozenset({"line", "arc", "bspline", "circle"}),
    )
    if selection is None:
        return None
    source, candidates, sketch = selection
    if len(candidates) == 1 and candidates[0][1].get("type") == "circle":
        entity_id, entity = candidates[0]
        segment = deepcopy(entity)
        segment["source_entity_id"] = entity_id
        contours = [{"role": "unknown", "closed": True, "segments": [segment]}]
    else:
        if any(entity.get("type") == "circle" for _entity_id, entity in candidates):
            return None
        records: list[tuple[str, dict[str, Any], list[float], list[float]]] = []
        for entity_id, entity in candidates:
            start = _sweep_path_endpoint(entity, "start")
            end = _sweep_path_endpoint(entity, "end")
            if start is None or end is None or _same_sweep_path_point(start, end):
                return None
            records.append((entity_id, entity, start, end))
        if len(records) < 2:
            return None

        def incident_count(point: list[float]) -> int:
            return sum(
                int(_same_sweep_path_point(point, start)) + int(_same_sweep_path_point(point, end))
                for _entity_id, _entity, start, end in records
            )

        if any(incident_count(point) != 2 for _entity_id, _entity, start, end in records for point in (start, end)):
            return None
        remaining = set(range(len(records)))
        first_id, first_entity, first_start, first_end = records[0]
        ordered = [{**deepcopy(first_entity), "source_entity_id": first_id}]
        remaining.remove(0)
        current = first_end
        while remaining:
            matches = [
                index for index in remaining
                if _same_sweep_path_point(current, records[index][2]) or _same_sweep_path_point(current, records[index][3])
            ]
            if len(matches) != 1:
                return None
            index = matches[0]
            entity_id, entity, start, end = records[index]
            segment = deepcopy(entity) if _same_sweep_path_point(current, start) else _reversed_sweep_path_segment(entity)
            segment["source_entity_id"] = entity_id
            current = end if _same_sweep_path_point(current, start) else start
            ordered.append(segment)
            remaining.remove(index)
        if not _same_sweep_path_point(current, first_start):
            return None
        contours = [{"role": "unknown", "closed": True, "segments": ordered}]
    output = deepcopy(sketch)
    output["id"] = f"{sketch['id']}__{feature_id}"
    output["name"] = f"{sketch['name']}__{feature_id}"
    output["source_sketch_id"] = source
    output["profile"] = {"type": "analytic_contours", "contours": contours}
    return output


def _direct_sketch_wire_path(
    value: Any,
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    *,
    featurescript_version: str | None,
    standard_library: str | None,
    standard_library_version: str | None,
) -> tuple[str, str, dict[str, Any], dict[str, Any]] | None:
    """Resolve one direct open line/arc/B-spline source-wire path contract."""
    selection = _direct_sketch_wire_selection(
        value, sketch_by_source, entity_by_sketch,
        featurescript_version=featurescript_version,
        standard_library=standard_library,
        standard_library_version=standard_library_version,
    )
    if selection is None:
        return None
    source, candidates, sketch = selection
    if len(candidates) != 1:
        return None
    entity_id, entity = candidates[0]
    # A sketch circle has coincident endpoints and is never an unambiguous
    # open sweep spine.  A source ``skArc`` carries its exact directed arc
    # data, so it is safe to retain under the same singleton query gate.
    if entity.get("type") not in {"line", "arc", "bspline"}:
        return None
    return source, entity_id, entity, sketch


def _direct_sketch_circle_wire_path(
    value: Any,
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    *,
    featurescript_version: str | None,
    standard_library: str | None,
    standard_library_version: str | None,
) -> tuple[str, str, dict[str, Any], dict[str, Any]] | None:
    """Resolve one closed source-circle wire without using a parsed leaf.

    A direct ``sQuery`` circle follows the legacy singleton path. This helper
    is deliberately for the distinct ``qBodyType(qCreatedBy(..., EDGE),
    WIRE)`` source-wire form, whose complete query result has already been
    checked by ``_direct_sketch_wire_selection``. A circle cannot enter the
    open line/arc/B-spline helper: it has no endpoint roles.
    """
    selection = _direct_sketch_wire_selection(
        value, sketch_by_source, entity_by_sketch,
        featurescript_version=featurescript_version,
        standard_library=standard_library,
        standard_library_version=standard_library_version,
        allowed_curve_types=frozenset({"circle"}),
    )
    if selection is None:
        return None
    source, candidates, sketch = selection
    if len(candidates) != 1:
        return None
    entity_id, entity = candidates[0]
    if entity.get("type") != "circle":
        return None
    return source, entity_id, entity, sketch


def _direct_segmented_sketch_wire_path(
    value: Any,
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    *,
    featurescript_version: str | None,
    standard_library: str | None,
    standard_library_version: str | None,
) -> tuple[str, list[dict[str, Any]], dict[str, Any]] | None:
    """Resolve one source-only connected, non-branching, open path wire.

    Ordering uses only exact direct source endpoints. It rejects closed,
    disconnected, branching, degenerate, and construction-ambiguous source
    sets rather than letting OCC pick a wire or infer an orientation.
    """
    selection = _direct_sketch_wire_selection(
        value, sketch_by_source, entity_by_sketch,
        featurescript_version=featurescript_version,
        standard_library=standard_library,
        standard_library_version=standard_library_version,
    )
    if selection is None:
        return None
    source, candidates, sketch = selection
    if len(candidates) < 2:
        return None
    records: list[tuple[str, dict[str, Any], list[float], list[float]]] = []
    for entity_id, entity in candidates:
        start, end = _sweep_path_endpoint(entity, "start"), _sweep_path_endpoint(entity, "end")
        if start is None or end is None or _same_sweep_path_point(start, end):
            return None
        records.append((entity_id, entity, start, end))

    def incident_count(point: list[float]) -> int:
        return sum(
            int(_same_sweep_path_point(point, start)) + int(_same_sweep_path_point(point, end))
            for _entity_id, _entity, start, end in records
        )

    terminals = [
        (index, endpoint)
        for index, (_entity_id, _entity, start, end) in enumerate(records)
        for endpoint in (start, end)
        if incident_count(endpoint) == 1
    ]
    if len(terminals) != 2:
        return None
    _start_index, current = terminals[0]
    ordered: list[dict[str, Any]] = []
    remaining = set(range(len(records)))
    while remaining:
        matching = [
            index for index in remaining
            if _same_sweep_path_point(current, records[index][2]) or _same_sweep_path_point(current, records[index][3])
        ]
        if len(matching) != 1:
            return None
        index = matching[0]
        entity_id, entity, start, end = records[index]
        if _same_sweep_path_point(current, start):
            segment = deepcopy(entity)
            current = end
        elif _same_sweep_path_point(current, end):
            segment = _reversed_sweep_path_segment(entity)
            current = start
        else:  # pragma: no cover - guarded by matching above
            return None
        segment["source_entity_id"] = entity_id
        ordered.append(segment)
        remaining.remove(index)
    if incident_count(current) != 1:
        return None
    return source, ordered, sketch


def _spatial_sweep_path_segment(
    entity_id: str,
    entity: dict[str, Any],
    sketch: dict[str, Any],
    source: str,
) -> tuple[dict[str, Any], list[float], list[float]] | None:
    """Capture one direct source sketch curve in its explicit global frame."""
    plane = sketch.get("workplane")
    if not isinstance(plane, dict):
        return None
    kind = entity.get("type")
    if kind not in {"line", "arc", "bspline"}:
        return None

    def point(value: Any) -> list[float] | None:
        if not isinstance(value, list) or len(value) != 2 or not all(isinstance(component, (int, float)) and math.isfinite(float(component)) for component in value):
            return None
        try:
            return _global(plane, [float(value[0]), float(value[1])])
        except (KeyError, TypeError, ValueError):
            return None

    def vector(value: Any) -> list[float] | None:
        if not isinstance(value, list) or len(value) != 2 or not all(isinstance(component, (int, float)) and math.isfinite(float(component)) for component in value):
            return None
        try:
            y_dir = _y_dir(plane)
            return [plane["x_dir"][index] * float(value[0]) + y_dir[index] * float(value[1]) for index in range(3)]
        except (KeyError, TypeError, ValueError):
            return None

    output: dict[str, Any] = {
        "type": kind,
        "source_sketch_id": source,
        "source_entity_id": entity_id,
    }
    if kind == "bspline":
        values = entity.get("points")
        if not isinstance(values, list) or len(values) < 2:
            return None
        points = [point(value) for value in values]
        if any(value is None for value in points) or entity.get("periodic"):
            return None
        output["points_mm"] = points
        parameters = entity.get("parameters")
        if parameters is not None:
            if not isinstance(parameters, list) or len(parameters) != len(points):
                return None
            try:
                output["parameters"] = [float(value) for value in parameters]
            except (TypeError, ValueError):
                return None
        start_tangent = entity.get("start_tangent")
        end_tangent = entity.get("end_tangent")
        if (start_tangent is None) != (end_tangent is None):
            return None
        if start_tangent is not None:
            start_vector, end_vector = vector(start_tangent), vector(end_tangent)
            if start_vector is None or end_vector is None:
                return None
            output["start_tangent_mm"] = start_vector
            output["end_tangent_mm"] = end_vector
        if len(points) == 2 and start_tangent is None:
            return None
        return output, points[0], points[-1]

    start, end = point(entity.get("start")), point(entity.get("end"))
    if start is None or end is None:
        return None
    output["start_mm"] = start
    output["end_mm"] = end
    if kind == "arc":
        center = point(entity.get("center"))
        radius = entity.get("radius_mm")
        normal = plane.get("normal")
        if (
            center is None
            or not isinstance(radius, (int, float))
            or not math.isfinite(float(radius))
            or float(radius) <= 0
            or not isinstance(normal, list)
            or len(normal) != 3
            or not all(isinstance(value, (int, float)) and math.isfinite(float(value)) for value in normal)
        ):
            return None
        output["center_mm"] = center
        output["normal"] = [float(value) for value in normal]
        output["radius_mm"] = float(radius)
        output["clockwise"] = bool(entity.get("clockwise", False))
    return output, start, end


def _direct_spatial_segmented_sketch_wire_path(
    value: Any,
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    *,
    featurescript_version: str | None,
    standard_library: str | None,
    standard_library_version: str | None,
) -> list[dict[str, Any]] | None:
    """Resolve a direct union of source sketch wires into one global open wire.

    This remains source-only. Each outer operand must be the exact versioned
    wire query accepted by ``_direct_sketch_wire_selection``. Curves are
    carried through their explicit sketch frames and may join only at exact
    global source endpoints; no datum/topology/result geometry is consulted.
    """
    if (
        not isinstance(value, Call)
        or value.name != "qUnion"
        or len(value.args) != 1
        or not isinstance(value.args[0], list)
        or len(value.args[0]) < 2
    ):
        return None
    records: list[tuple[dict[str, Any], list[float], list[float]]] = []
    source_ids: set[tuple[str, str]] = set()
    for operand in value.args[0]:
        selection = _direct_sketch_wire_selection(
            Call("qUnion", [[operand]]), sketch_by_source, entity_by_sketch,
            featurescript_version=featurescript_version,
            standard_library=standard_library,
            standard_library_version=standard_library_version,
        )
        if selection is None:
            return None
        source, candidates, sketch = selection
        for entity_id, entity in candidates:
            key = (source, entity_id)
            if key in source_ids:
                return None
            source_ids.add(key)
            captured = _spatial_sweep_path_segment(entity_id, entity, sketch, source)
            if captured is None:
                return None
            segment, start, end = captured
            if _same_point(start, end):
                return None
            records.append((segment, start, end))
    if len(records) < 2:
        return None

    def incident_count(point: list[float]) -> int:
        return sum(
            int(_same_point(point, start)) + int(_same_point(point, end))
            for _segment, start, end in records
        )

    terminals = [
        endpoint
        for _segment, start, end in records
        for endpoint in (start, end)
        if incident_count(endpoint) == 1
    ]
    if len(terminals) != 2:
        return None
    current = terminals[0]
    remaining = set(range(len(records)))
    ordered: list[dict[str, Any]] = []
    while remaining:
        matching = [
            index for index in remaining
            if _same_point(current, records[index][1]) or _same_point(current, records[index][2])
        ]
        if len(matching) != 1:
            return None
        index = matching[0]
        segment, start, end = records[index]
        if _same_point(current, start):
            current = end
        elif _same_point(current, end):
            segment = _reversed_spatial_sweep_path_segment(segment)
            current = start
        else:  # pragma: no cover - guarded by matching above
            return None
        ordered.append(segment)
        remaining.remove(index)
    return ordered if incident_count(current) == 1 else None


def _pattern_remove_source(feature: dict[str, Any]) -> None:
    # circularPattern 的 REMOVE 会把源实体及其实例作为切削工具。仅直接的
    # 加料拉伸/回转可无歧义改写为同一 profile 的切除；其他 source 需要
    # body 生命周期与工具保留策略，不能猜测成任意 boolean。
    cut_atomic = {
        "extrude_add_blind": "extrude_cut_blind",
        "extrude_add_two_sided": "extrude_cut_two_sided",
        "revolve_add": "revolve_cut",
    }.get(str(feature.get("atomic_id") or ""))
    if cut_atomic is None:
        raise UnsupportedCapability(
            "circular_pattern_remove_source",
            "current CDSL engine can only replay a REMOVE pattern from a direct additive extrusion or revolve",
        )
    feature["atomic_id"] = cut_atomic
    feature["params"].pop("result_mode", None)


def _resolved_body_alias(source: str, aliases: dict[str, str]) -> str:
    """Follow one proven direct body's current successor without guessing.

    CADFS ``SWEPT_BODY`` queries keep the original operation owner after a
    non-copy transform or a sole-body mutation. The source still names the
    same physical body, whose executable CDSL member is now the successor.
    This only follows lowering-time transitions that preserve a one-to-one
    body member. Boolean, multi-body, delete and replayed pattern output
    never enter the alias map.
    """
    resolved = source
    visited = {source}
    while resolved in aliases:
        successor = aliases[resolved]
        if successor in visited:
            raise ValueError("body transform successor aliases contain a cycle")
        visited.add(successor)
        resolved = successor
    return resolved


def _direct_transform_copy_member(
    value: Any,
    previous: list[str],
    feature_by_id: dict[str, dict[str, Any]],
    body_aliases: dict[str, str],
    visited: set[str] | None = None,
) -> tuple[str, dict[str, str] | None]:
    """Resolve an exact ``COPY`` chain emitted by explicit transform copies.

    FeatureScript represents a ``makeCopy`` transform result as
    ``owner.opPattern/COPY`` even when the owner is a plain transform rather
    than a CADFS pattern feature.  The runtime already gives that transform a
    distinct body member under its feature ID. A multi-source transform COPY
    exposes one member for each selected source, so this resolver returns a
    structured reference for that case and validates its complete derived-from
    chain. It intentionally does not infer ownership for generic pattern,
    fused, or dress-up output.
    """
    _call, owner, topology, kind, definition = _direct_make_query(value)
    if kind not in {"body", "entitytype.body"}:
        raise UnsupportedCapability("transform_pattern_copy", "CADFS transform COPY source is not a body")
    if topology == "SWEPT_BODY":
        source = f"f_{owner}"
        if source not in previous:
            raise ValueError("transform COPY source body is unresolved")
        return _resolved_body_alias(source, body_aliases), None
    if topology != "COPY":
        raise UnsupportedCapability(
            "transform_pattern_copy",
            "CADFS transform COPY source must descend from a direct swept body",
        )
    try:
        instance = int(str(definition.get("instanceName")))
    except (TypeError, ValueError) as error:
        raise ValueError("transform COPY instance is unresolved") from error
    if instance != 1:
        raise UnsupportedCapability(
            "transform_pattern_copy",
            "direct transform COPY provenance only has generated instance 1",
        )
    member_id = f"f_{owner}"
    if member_id in (visited or set()):
        raise ValueError("transform COPY provenance contains a cycle")
    transform = feature_by_id.get(member_id)
    params = (transform or {}).get("params") or {}
    source_ids = params.get("source_feature_ids") or []
    if (
        member_id not in previous
        or transform is None
        or transform.get("atomic_id") != "transform_bodies"
        or not bool(params.get("make_copy"))
        or params.get("pattern_instance_refs")
        or params.get("transform_copy_refs")
        or not isinstance(source_ids, list)
        or not source_ids
    ):
        raise UnsupportedCapability(
            "transform_pattern_copy",
            "CADFS transform COPY must name an exact preceding explicit transform copy",
        )
    derived = definition.get("derivedFrom")
    if derived is None:
        raise ValueError("transform COPY has no derived body")
    upstream, _upstream_copy_ref = _direct_transform_copy_member(
        derived, previous, feature_by_id, body_aliases, (visited or set()) | {member_id},
    )
    source_member_aliases = {
        str(alias.get("source_feature_id")): str(alias.get("active_member_feature_id"))
        for alias in params.get("source_member_aliases") or ()
        if isinstance(alias, dict)
        and isinstance(alias.get("source_feature_id"), str)
        and isinstance(alias.get("active_member_feature_id"), str)
    }
    # A transform COPY preserves the FeatureScript owner of its source body
    # even when an earlier proven single-body successor supplies the current
    # runtime member.  The explicit mapping is source provenance, not an
    # instruction to select a different body or a current-aggregate fallback.
    if len(source_ids) == 1 and (
        source_ids == [upstream]
        or source_member_aliases == {upstream: source_ids[0]}
    ):
        return member_id, None
    if len(source_ids) > 1 and upstream in source_ids:
        return member_id, {
            "transform_feature_id": member_id,
            "source_feature_id": upstream,
        }
    raise UnsupportedCapability(
        "transform_pattern_copy",
        "CADFS transform COPY derived body does not match its CDSL transform source",
    )


def _transform_copy_terminal_source(value: Any) -> str | None:
    """Return the original direct body owner at one COPY chain's root."""
    try:
        _call, owner, topology, kind, definition = _direct_make_query(value)
    except ValueError:
        return None
    if kind not in {"body", "entitytype.body"}:
        return None
    if topology == "SWEPT_BODY":
        return f"f_{owner}"
    if topology != "COPY" or definition.get("derivedFrom") is None:
        return None
    return _transform_copy_terminal_source(definition["derivedFrom"])


def _transform_source_member_aliases(
    value: Any,
    sources: list[str],
) -> list[dict[str, str]]:
    """Bind original transform query owners to their proved runtime members.

    This is only emitted for one-to-one direct body references.  Pattern and
    multi-source COPY references already have their own instance-qualified
    contracts, so they must not be collapsed into this lifecycle mapping.
    """
    query_values = _queries(value)
    if len(sources) != 1 or len(query_values) != 1:
        return []
    aliases: list[dict[str, str]] = []
    for query_value, active_member in zip(query_values, sources):
        semantic_source = _transform_copy_terminal_source(query_value)
        if semantic_source is None or semantic_source == active_member:
            continue
        alias = {
            "source_feature_id": semantic_source,
            "active_member_feature_id": active_member,
        }
        if alias not in aliases:
            aliases.append(alias)
    return aliases


def _transform_copy_query_provenance(
    value: Any,
    previous: list[str],
    feature_by_id: dict[str, dict[str, Any]],
    visited: set[str] | None = None,
) -> tuple[Any, list[dict[str, Any]], str]:
    """Return a direct source query and exact transforms for a COPY descendant.

    The copied edge/vertex must be produced by the same restricted transform
    copy chain as its selected body.  Applying the recorded CDSL transforms to
    the direct source reference preserves the physical location without a
    topology-nearest fallback.  This is deliberately separate from runtime
    selector binding: the values are only used to lower a FeatureScript
    translation vector whose source points are explicit and unique.
    """
    _call, owner, topology, _kind, definition = _direct_make_query(value)
    member_id = f"f_{owner}"
    if topology != "COPY":
        if member_id not in previous:
            raise ValueError("transform COPY reference owner is unresolved")
        return value, [], member_id
    try:
        instance = int(str(definition.get("instanceName")))
    except (TypeError, ValueError) as error:
        raise ValueError("transform COPY reference instance is unresolved") from error
    if instance != 1:
        raise UnsupportedCapability(
            "transform_translation_entity",
            "COPY reference only has exact transform provenance for instance 1",
        )
    if member_id in (visited or set()):
        raise ValueError("transform COPY reference provenance contains a cycle")
    transform = feature_by_id.get(member_id)
    params = (transform or {}).get("params") or {}
    source_ids = params.get("source_feature_ids") or []
    transform_spec = params.get("transform")
    if (
        member_id not in previous
        or transform is None
        or transform.get("atomic_id") != "transform_bodies"
        or not bool(params.get("make_copy"))
        or params.get("pattern_instance_refs")
        or not isinstance(source_ids, list)
        or len(source_ids) != 1
        or not isinstance(transform_spec, dict)
    ):
        raise UnsupportedCapability(
            "transform_translation_entity",
            "COPY reference must name an exact preceding single-source transform copy",
        )
    derived = definition.get("derivedFrom")
    if derived is None:
        raise ValueError("transform COPY reference has no derived geometry")
    source_query, transforms, upstream_member = _transform_copy_query_provenance(
        derived, previous, feature_by_id, (visited or set()) | {member_id},
    )
    if source_ids != [upstream_member]:
        raise UnsupportedCapability(
            "transform_translation_entity",
            "COPY reference derived geometry does not match its transform source",
        )
    return source_query, [*transforms, transform_spec], member_id


def _apply_body_transform_to_point(point: list[float], transform: dict[str, Any]) -> list[float]:
    """Apply one validated CDSL body transform to an explicit point."""
    kind = str(transform.get("type") or "")
    if kind == "translation":
        offset = transform.get("translation_mm")
        if not isinstance(offset, list) or len(offset) != 3:
            raise ValueError("transform COPY translation is incomplete")
        return [point[index] + float(offset[index]) for index in range(3)]
    if kind == "rotation":
        axis = transform.get("axis")
        angle = transform.get("angle_deg")
        if not isinstance(axis, dict) or not isinstance(angle, (int, float)):
            raise ValueError("transform COPY rotation is incomplete")
        return _rotate_point(point, axis, math.radians(float(angle)))
    if kind == "uniform_scale":
        center = transform.get("center_mm")
        factor = transform.get("scale_factor")
        if not isinstance(center, list) or len(center) != 3 or not isinstance(factor, (int, float)):
            raise ValueError("transform COPY uniform scale is incomplete")
        return [float(center[index]) + (point[index] - float(center[index])) * float(factor) for index in range(3)]
    raise ValueError(f"transform COPY has unsupported transform type {kind!r}")


def _transform_copy_point(
    query: Any,
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    feature_by_id: dict[str, dict[str, Any]],
    previous: list[str],
) -> list[float]:
    try:
        _call, _owner, topology, _kind, _definition = _direct_make_query(query)
    except ValueError:
        return _query_point(query, feature_frames, sketch_by_source, entity_by_sketch)
    if topology != "COPY":
        return _query_point(query, feature_frames, sketch_by_source, entity_by_sketch)
    source, transforms, _member = _transform_copy_query_provenance(query, previous, feature_by_id)
    point = _query_point(source, feature_frames, sketch_by_source, entity_by_sketch)
    for transform in transforms:
        point = _apply_body_transform_to_point(point, transform)
    return point


def _transform_copy_line(
    query: Any,
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    feature_by_id: dict[str, dict[str, Any]],
    previous: list[str],
) -> tuple[list[float], list[float]]:
    try:
        _call, _owner, topology, _kind, _definition = _direct_make_query(query)
    except ValueError:
        return _query_line(query, feature_frames, sketch_by_source, entity_by_sketch)
    if topology != "COPY":
        return _query_line(query, feature_frames, sketch_by_source, entity_by_sketch)
    source, transforms, _member = _transform_copy_query_provenance(query, previous, feature_by_id)
    start, end = _query_line(source, feature_frames, sketch_by_source, entity_by_sketch)
    for transform in transforms:
        start = _apply_body_transform_to_point(start, transform)
        end = _apply_body_transform_to_point(end, transform)
    return start, end


def _transform_source_features(value: Any, previous: list[str], body_aliases: dict[str, str] | None = None) -> list[str]:
    sources = []
    body_aliases = body_aliases or {}
    for call in walk_calls(value):
        if call.name not in {"makeQuery", "qCreatedBy"} or not call.args:
            continue
        owner = symbolic_string(call.args[0])
        if "F" not in owner:
            continue
        source = "f_" + owner[owner.find("F"):].split(".", 1)[0]
        resolved = _resolved_body_alias(source, body_aliases)
        if source in previous and resolved not in sources:
            sources.append(resolved)
    if not sources:
        raise ValueError("transform source features are unresolved")
    return sources


def _transform_body_references(
    value: Any,
    previous: list[str],
    feature_by_id: dict[str, dict[str, Any]],
    body_aliases: dict[str, str] | None = None,
) -> tuple[list[str], list[dict[str, Any]], list[dict[str, str]]]:
    """Lower direct CADFS body queries without flattening COPY provenance.

    A pattern COPY is not its pattern's aggregate result.  Keep the producer,
    source body and instance index as a structured CDSL reference so runtime
    can select a proven body member without receiving an internal state ID.
    """
    sources: list[str] = []
    instance_refs: list[dict[str, Any]] = []
    transform_copy_refs: list[dict[str, str]] = []
    body_aliases = body_aliases or {}
    query_values = _queries(value)
    # Older CADFS exports represent a directly created body as
    # qCreatedBy(id + "F1", BODY), without a makeQuery topology wrapper.
    # It has no COPY provenance, so the established source-feature contract
    # remains exact and does not need a body-member instance reference.
    if query_values and all(isinstance(item, Call) and item.name == "qCreatedBy" for item in query_values):
        return _transform_source_features(value, previous, body_aliases), instance_refs, transform_copy_refs
    for query_value in query_values:
        _call, owner, topology, kind, definition = _direct_make_query(query_value)
        if kind not in {"body", "entitytype.body"}:
            raise UnsupportedCapability("transform_body_query", "CADFS transform requires direct body queries")
        if topology == "SWEPT_BODY":
            source = f"f_{owner}"
            if source not in previous:
                raise ValueError("transform source body is unresolved")
            source = _resolved_body_alias(source, body_aliases)
            if source not in sources:
                sources.append(source)
            continue
        if topology != "COPY":
            raise UnsupportedCapability(
                "transform_body_query",
                "CADFS transform requires SWEPT_BODY or circular-pattern COPY body queries",
            )
        derived = definition.get("derivedFrom")
        if derived is None:
            raise ValueError("pattern copy transform source is unresolved")
        pattern_id = f"f_{owner}"
        owner_feature = feature_by_id.get(pattern_id)
        if owner_feature is not None and owner_feature.get("atomic_id") == "transform_bodies":
            source, transform_copy_ref = _direct_transform_copy_member(
                query_value, previous, feature_by_id, body_aliases,
            )
            if transform_copy_ref is not None:
                if transform_copy_ref not in transform_copy_refs:
                    transform_copy_refs.append(transform_copy_ref)
            elif source not in sources:
                sources.append(source)
            continue
        _source_call, source_owner, source_topology, source_kind, _source_definition = _direct_make_query(derived)
        source_id = _resolved_body_alias(f"f_{source_owner}", body_aliases)
        pattern = feature_by_id.get(pattern_id)
        if (
            source_topology == "SWEPT_BODY"
            and source_kind in {"body", "entitytype.body"}
            and pattern is not None
            and pattern.get("atomic_id") == "pattern_mirror"
            and pattern_id in previous
            and source_id in (pattern.get("params") or {}).get("source_feature_ids", [])
            and (feature_by_id.get(source_id) or {}).get("params", {}).get("result_mode") == "new_body"
        ):
            try:
                instance = int(str(definition.get("instanceName")))
            except (TypeError, ValueError) as error:
                raise ValueError("mirror copy transform instance is unresolved") from error
            if instance != 1:
                raise UnsupportedCapability(
                    "transform_pattern_copy",
                    "direct mirror COPY provenance only has generated instance 1",
                )
            reference = {
                "pattern_feature_id": pattern_id,
                "source_feature_id": source_id,
                "instance_index": instance,
            }
            if reference not in instance_refs:
                instance_refs.append(reference)
            continue
        if (
            source_topology != "SWEPT_BODY"
            or source_kind not in {"body", "entitytype.body"}
            or pattern is None
            or pattern.get("atomic_id") != "pattern_circular"
            or pattern_id not in previous
            or source_id not in (pattern.get("params") or {}).get("source_feature_ids", [])
        ):
            raise UnsupportedCapability(
                "transform_pattern_copy",
                "CADFS transform COPY body must name a direct source of a preceding circular pattern",
            )
        try:
            instance = int(str(definition.get("instanceName")))
        except (TypeError, ValueError) as error:
            raise ValueError("pattern copy transform instance is unresolved") from error
        count = int((pattern.get("params") or {}).get("pattern_count") or 0)
        excluded = {int(value) for value in (pattern.get("params") or {}).get("excluded_instance_indices") or []}
        if instance < 1 or instance >= count or instance in excluded:
            raise ValueError("pattern copy transform instance is outside the generated range")
        reference = {
            "pattern_feature_id": pattern_id,
            "source_feature_id": source_id,
            "instance_index": instance,
        }
        if reference not in instance_refs:
            instance_refs.append(reference)
    if not sources and not instance_refs and not transform_copy_refs:
        raise ValueError("transform source bodies are unresolved")
    return sources, instance_refs, transform_copy_refs


def _body_transform(
    params: dict[str, Any],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    feature_by_id: dict[str, dict[str, Any]] | None = None,
    previous: list[str] | None = None,
) -> dict[str, Any]:
    """Lower one CADFS body transform without changing the selected body."""
    transform_type = str(params.get("transformType") or "").split(".")[-1].upper()
    # FeatureScript COPY has no geometric displacement, but it does create a
    # separate body member. Represent its identity geometry explicitly and let
    # the enclosing transform_bodies operation retain the source via
    # ``make_copy``. This stays on the OCC transform/history path rather than
    # aliasing the source's runtime body.
    if transform_type == "COPY":
        return {"type": "translation", "translation_mm": [0.0, 0.0, 0.0]}
    if transform_type == "TRANSLATION_3D":
        return {
            "type": "translation",
            "translation_mm": [_number(params.get(key, 0.0), True) for key in ("dx", "dy", "dz")],
        }
    if transform_type == "TRANSLATION_DISTANCE":
        return {
            "type": "translation",
            "translation_mm": _translation_distance_vector(
                params, feature_frames, sketch_by_source, entity_by_sketch, feature_by_id, previous,
            ),
        }
    if transform_type == "TRANSLATION_ENTITY":
        return {
            "type": "translation",
            "translation_mm": _translation_entity_vector(
                params, feature_frames, sketch_by_source, entity_by_sketch, feature_by_id, previous,
            ),
        }
    if transform_type == "ROTATION":
        axis = _transform_axis(params.get("transformAxis"), feature_frames, sketch_by_source, entity_by_sketch)
        return {"type": "rotation", "axis": axis, "angle_deg": _number(params.get("angle"), True)}
    if transform_type == "SCALE_UNIFORMLY":
        scale_factor = _number(params.get("scale"))
        if not math.isfinite(scale_factor) or scale_factor <= 0:
            raise UnsupportedCapability(
                "transform_uniform_scale",
                "SCALE_UNIFORMLY requires a finite positive scale factor",
            )
        return {
            "type": "uniform_scale",
            "center_mm": _scale_center(params.get("scalePoint"), feature_frames, sketch_by_source, entity_by_sketch),
            "scale_factor": scale_factor,
        }
    raise UnsupportedCapability("transform", f"current CDSL engine cannot exactly execute {transform_type or 'unknown'} transform")


def _delete_body_source(value: Any) -> str:
    """Resolve a directly owned body output without broad query expansion."""
    _call, owner, topology, kind, _definition = _direct_make_query(value)
    if kind not in {"body", "entitytype.body"} or topology not in {"SWEPT_BODY", "COPY"}:
        raise UnsupportedCapability(
            "delete_bodies",
            "current CDSL deleteBodies requires a direct SWEPT_BODY or COPY body query",
        )
    return f"f_{owner}"


def _circular_pattern_axis(
    value: Any,
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> dict[str, list[float]]:
    query = parse_query(value)
    entity = (entity_by_sketch.get(query.source_sketch or "") or {}).get(query.source_entity or "")
    if entity is None or query.source_sketch not in sketch_by_source:
        raise ValueError("circular pattern axis is unresolved")
    plane = sketch_by_source[query.source_sketch]["workplane"]
    if entity["type"] == "line":
        start = _global(plane, entity["start"]); end = _global(plane, entity["end"])
        direction = [end[index] - start[index] for index in range(3)]
        norm = math.sqrt(sum(component * component for component in direction))
        if norm <= 1e-9:
            raise ValueError("circular pattern axis line is degenerate")
        return {"origin_mm": start, "direction": [component / norm for component in direction]}
    if entity["type"] == "circle":
        frame = feature_frames.get(query.owner_feature or "")
        if frame and query.is_start is not None:
            plane = frame["start" if query.is_start else "end"]
        return {"origin_mm": _global(plane, entity["center"]), "direction": list(plane["normal"])}
    raise ValueError("circular pattern axis must be a sketch line or circular edge")


def _loft_profile_sketches(params: dict[str, Any]) -> list[str]:
    # CADFS loft 的 profile 是草图 IMPRINT 面；几何仍来自原始闭合草图，
    # 保留草图 source，不能把前序实体的选中面近似为新的放样轮廓。
    profiles = params.get("sheetProfilesArray")
    if not isinstance(profiles, list):
        raise ValueError("loft sheetProfilesArray is unresolved")
    sources: list[str] = []
    for profile in profiles:
        query_value = profile.get("sheetProfileEntities") if isinstance(profile, dict) else profile
        query = parse_query(query_value)
        if query.topology_type and query.topology_type != "IMPRINT":
            raise UnsupportedCapability(
                f"loft_profile_topology:{query.topology_type.lower()}",
                f"current CDSL loft only supports sketch-imprint profiles, not {query.topology_type}",
            )
        if not query.source_sketch:
            raise ValueError("loft profile sketch query is unresolved")
        sources.append(query.source_sketch)
    if len(sources) < 2:
        raise ValueError("loft requires at least two profile sketches")
    if len(set(sources)) != len(sources):
        raise ValueError("loft profile sketches must be distinct")
    return sources


def _initial_direct_loft_cap_output_roles(
    params: dict[str, Any],
    sources: list[str],
    features: list[dict[str, Any]],
    featurescript_version: str | None,
) -> bool:
    """Whether an initial direct loft exposes exact endpoint CAP roles."""
    if featurescript_version != "1511" or _has_active_body(features) or len(sources) != 2 or len(set(sources)) != 2:
        return False
    operation = str(params.get("operationType") or "NEW").rsplit(".", 1)[-1].upper()
    if operation != "NEW":
        return False
    if any(params.get(key) not in (None, [], {}, False) for key in (
        "wireProfilesArray", "connections", "matchConnections", "startCondition",
        "endCondition", "startMagnitude", "endMagnitude",
    )):
        return False
    profiles = params.get("sheetProfilesArray")
    if not isinstance(profiles, list) or len(profiles) != 2:
        return False
    for source, profile in zip(sources, profiles):
        value = profile.get("sheetProfileEntities") if isinstance(profile, dict) else None
        try:
            _call, owner, topology, kind, _definition = _direct_make_query(value)
        except ValueError:
            return False
        if owner != source or topology != "IMPRINT" or kind != "face":
            return False
    return True


def _profile_query_kind(params: dict[str, Any]) -> str | None:
    for key in ("entities", "sheetProfilesArray"):
        if key in params:
            return parse_query(params[key]).topology_type
    return None


def _profile_executable(sketch: dict[str, Any]) -> bool:
    profile = sketch.get("profile") or {}
    if profile.get("type") == "circle": return True
    if profile.get("type") == "polygon": return len(profile.get("vertices") or []) >= 3
    if profile.get("type") == "multi_source_regions":
        return bool(profile.get("source_sketch_ids")) and all(
            _profile_executable({"profile": child})
            for child in profile.get("profiles") or []
        )
    if profile.get("type") == "planar_imprint":
        return bool(profile.get("source_entities") and profile.get("selections"))
    return bool(profile.get("contours"))


def _default_plane(value: Any) -> dict[str, Any] | None:
    for call in walk_calls(value):
        text = " ".join(symbolic_string(arg) for arg in call.args)
        for name, plane in PLANES.items():
            if f"{name}.planeOp" in text: return dict(plane)
    return None


def _entity_from_query(
    query: Any,
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> tuple[dict[str, Any], dict[str, Any], str]:
    info = parse_query(query); source = info.source_sketch or ""; token = info.source_entity or ""
    available = entity_by_sketch.get(source) or {}
    entity = available.get(token)
    if entity is None:
        entity_id = max((key for key in available if token.startswith(key + ".")), key=len, default="")
        entity = available.get(entity_id)
    sketch = sketch_by_source.get(source)
    if entity is None or sketch is None:
        raise ValueError("reference geometry source is unresolved")
    return entity, sketch["workplane"], token


def _entity_point(entity: dict[str, Any], plane: dict[str, Any], token: str) -> list[float]:
    if entity["type"] == "point": return _global(plane, entity["point"])
    if entity["type"] == "circle" and ".center" in token:
        return _global(plane, entity["center"])
    if entity["type"] == "line":
        local = entity["end"] if ".end" in token else entity["start"]
        return _global(plane, local)
    if entity["type"] == "arc":
        if token.endswith(".start"):
            return _global(plane, entity["start"])
        if token.endswith(".end"):
            return _global(plane, entity["end"])
        raise ValueError("arc reference point is unresolved")
    if entity["type"] == "bspline":
        points = entity.get("points") or []
        if not points: raise ValueError("B-spline reference point is unresolved")
        # ``.start`` and ``.end`` are distinct direct source endpoints.
        # FeatureScript's ``.N.internal`` suffixes are zero-based output
        # vertex indexes; neither form may silently fall back to the first
        # interpolation point.
        if token.endswith(".start"):
            index = 0
        elif token.endswith(".end"):
            index = len(points) - 1
        else:
            index = next((int(part) for part in token.split(".") if part.isdigit()), -1)
            if index < 0:
                raise ValueError("B-spline reference point is unresolved")
        return _global(plane, points[max(0, min(index, len(points) - 1))])
    raise ValueError("reference entity does not define a point")


def _entity_line(entity: dict[str, Any], plane: dict[str, Any]) -> tuple[list[float], list[float]]:
    if entity["type"] != "line": raise ValueError("reference entity is not a line")
    return _global(plane, entity["start"]), _global(plane, entity["end"])


def _curve_endpoint_tangent(entity: dict[str, Any], endpoint: str) -> list[float]:
    """Return the exact directed source tangent at one direct curve endpoint.

    ``CURVE_POINT`` is defined by the curve tangent at its selected point, not
    by a chord through adjacent fit points. The CADFS source carries exact
    derivatives for the bounded B-spline case below, while an analytic arc has
    an exact radial construction. Interior spline vertices and splines without
    an exported endpoint derivative deliberately stay unsupported.
    """
    if endpoint not in {"start", "end"}:
        raise UnsupportedCapability(
            "reference_plane:curve_point",
            "CURVE_POINT requires a direct source-curve endpoint",
        )
    curve_type = entity.get("type")
    if curve_type == "arc":
        point = entity.get(endpoint)
        center = entity.get("center")
        if not (
            isinstance(point, list) and len(point) == 2
            and isinstance(center, list) and len(center) == 2
        ):
            raise ValueError("arc endpoint tangent is unresolved")
        radial = [float(point[index]) - float(center[index]) for index in range(2)]
        return [radial[1], -radial[0]] if entity.get("clockwise") else [-radial[1], radial[0]]
    if curve_type == "bspline":
        tangent = entity.get(f"{endpoint}_tangent")
        if not (
            isinstance(tangent, list)
            and len(tangent) == 2
            and all(isinstance(value, (int, float)) and math.isfinite(value) for value in tangent)
        ):
            raise UnsupportedCapability(
                "reference_plane:curve_point",
                "CURVE_POINT B-spline endpoint has no exported tangent",
            )
        return [float(value) for value in tangent]
    raise UnsupportedCapability(
        "reference_plane:curve_point",
        "CURVE_POINT supports only direct lines, arcs, or B-spline endpoints with exported tangents",
    )


def _curve_interpolation_tangent(entity: dict[str, Any], index: int) -> list[float]:
    """Return the kernel-proven tangent at one direct B-spline fit point.

    An ``E<n>.<index>.internal`` source token denotes an interpolation vertex
    emitted by the source sketch solver. It is neither a derived topology
    suffix nor permission to estimate a tangent from adjacent fit points. We
    reproduce the CDSL runtime's explicit-parameter, non-scaling OCC
    interpolator and verify it still passes through that exact source point.
    """
    if entity.get("type") != "bspline":
        raise UnsupportedCapability(
            "reference_plane:curve_point",
            "CURVE_POINT internal point requires a direct B-spline source curve",
        )
    if entity.get("periodic"):
        raise UnsupportedCapability(
            "reference_plane:curve_point",
            "CURVE_POINT does not support periodic B-spline interpolation points",
        )
    points = entity.get("points")
    parameters = entity.get("parameters")
    start_tangent = entity.get("start_tangent")
    end_tangent = entity.get("end_tangent")
    valid_vector = lambda value: (
        isinstance(value, list)
        and len(value) == 2
        and all(isinstance(component, (int, float)) and math.isfinite(component) for component in value)
    )
    if (
        not isinstance(points, list)
        or not all(valid_vector(point) for point in points)
        or not isinstance(parameters, list)
        or not valid_vector(start_tangent)
        or not valid_vector(end_tangent)
    ):
        raise UnsupportedCapability(
            "reference_plane:curve_point",
            "CURVE_POINT B-spline interpolation point has no complete source interpolation data",
        )
    if index < 0 or index >= len(points):
        raise UnsupportedCapability(
            "reference_plane:curve_point",
            "CURVE_POINT B-spline interpolation point is out of range",
        )
    try:
        # Import the runtime helper lazily: conversion remains usable in a
        # parser-only environment until this kernel-backed capability is used.
        from engine.cdsl_engine.build123d_adapter import interpolated_bspline_point_and_tangent

        point, tangent = interpolated_bspline_point_and_tangent(
            [(*map(float, value), 0.0) for value in points],
            start_tangent=(*map(float, start_tangent), 0.0),
            end_tangent=(*map(float, end_tangent), 0.0),
            parameters=[float(value) for value in parameters],
            interpolation_index=index,
        )
    except (ImportError, TypeError, ValueError) as exc:
        raise UnsupportedCapability(
            "reference_plane:curve_point",
            f"CURVE_POINT B-spline interpolation tangent is unavailable: {exc}",
        ) from exc
    source_point = points[index]
    if math.dist(point[:2], source_point) > 1e-7:
        raise UnsupportedCapability(
            "reference_plane:curve_point",
            "CURVE_POINT B-spline interpolation does not reproduce its source vertex",
        )
    if math.hypot(tangent[0], tangent[1]) <= 1e-12:
        raise UnsupportedCapability(
            "reference_plane:curve_point",
            "CURVE_POINT B-spline interpolation tangent is degenerate",
        )
    return [tangent[0], tangent[1]]


def _curve_point_tangent(
    curve_query: Any,
    point_query: Any,
    point: list[float],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> tuple[dict[str, Any], list[float]]:
    """Resolve one direct source curve's tangent at its explicitly named end."""
    curve, plane, _ = _entity_from_query(curve_query, sketch_by_source, entity_by_sketch)
    curve_info = parse_query(curve_query)
    point_info = parse_query(point_query)
    _point_entity, _point_plane, point_token = _entity_from_query(
        point_query, sketch_by_source, entity_by_sketch,
    )
    source_entity_id = curve.get("source_entity_id")
    if (
        not isinstance(source_entity_id, str)
        or curve_info.source_sketch != point_info.source_sketch
        or not point_token.startswith(source_entity_id + ".")
    ):
        raise UnsupportedCapability(
            "reference_plane:curve_point",
            "CURVE_POINT point must be an endpoint of the same direct source curve",
        )
    suffix = point_token[len(source_entity_id) + 1:]
    interpolation_index: int | None = None
    if suffix in {"start", "end"}:
        local_point = curve.get(suffix)
    else:
        parts = suffix.split(".")
        if (
            curve.get("type") == "bspline"
            and len(parts) == 2
            and parts[0].isdigit()
            and parts[1] == "internal"
        ):
            interpolation_index = int(parts[0])
            points = curve.get("points")
            local_point = points[interpolation_index] if isinstance(points, list) and 0 <= interpolation_index < len(points) else None
        else:
            local_point = None
    if not isinstance(local_point, list) or len(local_point) != 2:
        raise UnsupportedCapability(
            "reference_plane:curve_point",
            "CURVE_POINT point must name a direct source-curve endpoint or B-spline interpolation vertex",
        )
    expected_point = _global(plane, local_point)
    if math.dist(point, expected_point) > 1e-7:
        raise UnsupportedCapability(
            "reference_plane:curve_point",
            "CURVE_POINT point does not match its source-curve endpoint",
        )
    local_tangent = (
        _curve_interpolation_tangent(curve, interpolation_index)
        if interpolation_index is not None
        else _curve_endpoint_tangent(curve, suffix)
    )
    y_dir = _y_dir(plane)
    tangent = [
        local_tangent[0] * plane["x_dir"][index] + local_tangent[1] * y_dir[index]
        for index in range(3)
    ]
    return plane, tangent


def _local(plane: dict[str, Any], point: list[float]) -> list[float]:
    relative = _sub(point, plane["origin_mm"])
    return [_dot(relative, plane["x_dir"]), _dot(relative, _y_dir(plane))]


def _revolve_swept_face_profile(
    query: Any,
    plane: dict[str, Any],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> dict[str, Any] | None:
    info = parse_query(query); frame = feature_frames.get(info.owner_feature or "")
    if info.topology_type != "SWEPT_FACE" or frame is None or not frame.get("revolve_full"):
        return None
    axis = frame.get("revolve_axis")
    if not isinstance(axis, dict): return None
    start, end = _query_line(query, feature_frames, sketch_by_source, entity_by_sketch)
    direction = _sub(end, start); axis_direction = axis["direction"]
    if abs(_dot(direction, axis_direction)) > 1e-6 * max(1.0, math.sqrt(_dot(direction, direction))):
        raise UnsupportedCapability("extrude_profile_topology:swept_face", "revolved swept face source line is not perpendicular to the revolve axis")
    start_offset = _dot(_sub(start, axis["origin_mm"]), axis_direction)
    end_offset = _dot(_sub(end, axis["origin_mm"]), axis_direction)
    if abs(start_offset - end_offset) > 1e-6:
        raise UnsupportedCapability("extrude_profile_topology:swept_face", "revolved swept face source line is not coplanar with the revolve axis")
    center = [axis["origin_mm"][index] + axis_direction[index] * start_offset for index in range(3)]
    radii = sorted([math.dist(start, center), math.dist(end, center)])
    if radii[1] <= 1e-9:
        raise ValueError("revolved swept face source line is degenerate")
    local_center = _local(plane, center)
    contours = [{"role": "outer", "closed": True, "segments": [{"type": "circle", "center": local_center, "radius_mm": radii[1]}]}]
    if radii[0] > 1e-9:
        contours.append({"role": "inner", "closed": True, "segments": [{"type": "circle", "center": local_center, "radius_mm": radii[0]}]})
    return {"type": "analytic_contours", "contours": contours}


def _contour_line_interior_normal(
    contour: dict[str, Any],
    entity: dict[str, Any],
    source_plane: dict[str, Any],
) -> list[float] | None:
    """Return the source-proven interior side of one closed contour line.

    A vertex average is not an interior witness: on a valid asymmetric
    polygon it can lie on the selected boundary line.  The ordered contour's
    signed area instead gives the exact left/right interior side for the
    matched source line, without inspecting any resulting B-rep geometry.
    """
    segments = contour.get("segments") or []
    if not contour.get("closed") or entity.get("type") != "line" or not segments:
        return None
    matches = [segment for segment in segments if _matching_profile_segment(segment, entity)]
    if len(matches) != 1:
        return None
    try:
        area = _contour_area(segments)
        if not math.isfinite(area) or abs(area) <= 1e-9:
            return None
        segment = matches[0]
        start = _global(source_plane, segment["start"])
        end = _global(source_plane, segment["end"])
        traversal = _unit(_sub(end, start), "swept face source line is degenerate")
        left = _cross(source_plane["normal"], traversal)
        orientation = 1.0 if area > 0 else -1.0
        return _unit([orientation * value for value in left], "swept face source contour is degenerate")
    except (KeyError, TypeError, ValueError):
        return None


def _query_plane(
    query: Any,
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> dict[str, Any]:
    try:
        return _plane_from_query(query, feature_frames, sketch_by_source, entity_by_sketch)
    except ValueError:
        info = parse_query(query)
        if info.topology_type != "SWEPT_FACE" or not info.owner_feature:
            raise
        entity, source_plane, _ = _entity_from_query(query, sketch_by_source, entity_by_sketch)
        start, end = _entity_line(entity, source_plane); frame = feature_frames.get(info.owner_feature)
        if frame is None: raise ValueError("swept face owner frame is unresolved")
        if frame.get("revolve_full"):
            axis = frame.get("revolve_axis")
            if not isinstance(axis, dict): raise ValueError("revolve swept face axis is unresolved")
            direction = _sub(end, start); axis_direction = axis["direction"]
            if abs(_dot(direction, axis_direction)) > 1e-6 * max(1.0, math.sqrt(_dot(direction, direction))):
                raise UnsupportedCapability("reference_plane:swept_face", "revolved swept face source line is not perpendicular to the revolve axis")
            return _frame(start, direction, axis_direction)
        direction = _unit(_sub(end, start), "swept face source line is degenerate")
        sketch = sketch_by_source.get(info.source_sketch or "") or {}
        contours = (sketch.get("profile") or {}).get("contours") or []
        contour = next((
            item for item in contours
            if any(_matching_profile_segment(segment, entity) for segment in item.get("segments") or [])
        ), None)
        interior_normal = _contour_line_interior_normal(contour, entity, source_plane) if isinstance(contour, dict) else None
        if interior_normal is not None:
            normal = [-value for value in interior_normal]
        else:
            # Keep the existing fallback for source contours without one
            # complete ordered line-loop witness.
            points = [
                segment["start"]
                for segment in (contour or {}).get("segments") or []
                if isinstance(segment.get("start"), list)
            ]
            if points:
                center = _global(source_plane, [
                    sum(point[index] for point in points) / len(points)
                    for index in range(2)
                ])
                midpoint = [(start[index] + end[index]) / 2.0 for index in range(3)]
                inward = _sub(center, midpoint)
                inward = _sub(inward, [direction[index] * _dot(inward, direction) for index in range(3)])
                normal = [-value for value in _unit(inward, "swept face interior is degenerate")]
            else:
                normal = _cross(direction, frame["end"]["normal"])
        x_dir = direction
        if _dot(_cross(normal, x_dir), source_plane["normal"]) < 0:
            x_dir = [-value for value in x_dir]
        # 附着草图的局部原点是全局原点在实体侧面上的投影，不是 source
        # 草图边的任一端点。后者会把以原全局平面坐标表达的 F7/F9 等草图
        # 平移一个完整边长，令后续 cut 落在主体之外。
        return _attachment_plane(_frame(start, x_dir, normal))


def _offset_face_plane(
    value: Any,
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> dict[str, Any]:
    """Recover one planar inner shell wall from its source profile edge."""
    query = parse_query(value)
    frame = feature_frames.get(query.owner_feature or "") or {}
    if query.topology_type != "OFFSET_FACE" or not frame.get("shell_source"):
        raise ValueError("offset face owner is unresolved")
    thickness = float(frame.get("shell_thickness_mm") or 0.0)
    if thickness <= 0:
        raise ValueError("offset face shell thickness is unresolved")
    entity, source_plane, _ = _entity_from_query(value, sketch_by_source, entity_by_sketch)
    start, end = _entity_line(entity, source_plane)
    direction = _unit(_sub(end, start), "offset face source line is degenerate")
    source_sketch = sketch_by_source.get(query.source_sketch or "") or {}
    contours = (source_sketch.get("profile") or {}).get("contours") or []
    contour = next((
        item for item in contours
        if any(_matching_profile_segment(segment, entity) for segment in item.get("segments") or [])
    ), None)
    points = [
        segment["start"]
        for segment in (contour or {}).get("segments") or []
        if isinstance(segment.get("start"), list)
    ]
    if not points:
        raise ValueError("offset face source contour is unresolved")
    center = _global(source_plane, [
        sum(point[index] for point in points) / len(points)
        for index in range(2)
    ])
    midpoint = [(start[index] + end[index]) / 2.0 for index in range(3)]
    inward = _sub(center, midpoint)
    inward = _sub(inward, [direction[index] * _dot(inward, direction) for index in range(3)])
    normal = _unit(inward, "offset face source interior is degenerate")
    x_dir = direction
    if _dot(_cross(normal, x_dir), source_plane["normal"]) < 0:
        x_dir = [-value for value in x_dir]
    offset = [start[index] + thickness * normal[index] for index in range(3)]
    return _attachment_plane(_frame(offset, x_dir, normal))


def _convex_linear_offset_wall_endpoints(
    profile: dict[str, Any],
    entity: dict[str, Any],
    source_plane: dict[str, Any],
    offset_plane: dict[str, Any],
    thickness: float,
) -> tuple[list[float], list[float]] | None:
    """Offset one convex, closed, linear profile edge with its true neighbors.

    A shell's offset wall ends at the intersections with the offset adjacent
    walls. This is not equivalent to translating the selected outer edge: a
    rectangular wall, for example, shortens at both corners. Restrict this
    construction to one ordered convex line loop so every miter and its
    interior side are uniquely defined.
    """
    contours = (profile.get("profile") or {}).get("contours") or []
    if len(contours) != 1:
        return None
    contour = contours[0]
    segments = contour.get("segments") or []
    if (
        not contour.get("closed")
        or len(segments) < 3
        or any(segment.get("type") != "line" for segment in segments)
        or any(not _same_point(segment["end"], segments[(index + 1) % len(segments)]["start"]) for index, segment in enumerate(segments))
    ):
        return None
    matches = [index for index, segment in enumerate(segments) if _matching_profile_segment(segment, entity)]
    if len(matches) != 1:
        return None
    area_twice = sum(
        segment["start"][0] * segment["end"][1] - segment["end"][0] * segment["start"][1]
        for segment in segments
    )
    if abs(area_twice) <= 1e-9:
        return None
    orientation = 1.0 if area_twice > 0 else -1.0

    def interior_normal(segment: dict[str, Any]) -> list[float] | None:
        dx = segment["end"][0] - segment["start"][0]
        dy = segment["end"][1] - segment["start"][1]
        length = math.hypot(dx, dy)
        if length <= 1e-9:
            return None
        return [-orientation * dy / length, orientation * dx / length]

    normals = [interior_normal(segment) for segment in segments]
    if any(normal is None for normal in normals):
        return None
    # A convex loop has one consistent signed turn direction. Concave offset
    # boundaries can self-intersect and require the shell kernel's exact trim
    # history, so they deliberately remain deferred.
    turn_signs = []
    for index, segment in enumerate(segments):
        next_segment = segments[(index + 1) % len(segments)]
        dx = segment["end"][0] - segment["start"][0]
        dy = segment["end"][1] - segment["start"][1]
        next_dx = next_segment["end"][0] - next_segment["start"][0]
        next_dy = next_segment["end"][1] - next_segment["start"][1]
        turn = dx * next_dy - dy * next_dx
        if abs(turn) <= 1e-9:
            return None
        turn_signs.append(1.0 if turn > 0 else -1.0)
    if any(sign != turn_signs[0] for sign in turn_signs):
        return None

    selected_index = matches[0]
    selected_normal = normals[selected_index]
    global_normal = [
        source_plane["x_dir"][index] * selected_normal[0] + _y_dir(source_plane)[index] * selected_normal[1]
        for index in range(3)
    ]
    if abs(_dot(_unit(global_normal, "offset wall normal is degenerate"), offset_plane["normal"]) - 1.0) > 1e-6:
        return None

    def shifted_line(index: int) -> tuple[list[float], list[float]]:
        segment = segments[index]
        normal = normals[index]
        return (
            [segment["start"][axis] + thickness * normal[axis] for axis in range(2)],
            [segment["end"][axis] + thickness * normal[axis] for axis in range(2)],
        )

    def intersection(
        first_start: list[float], first_end: list[float], second_start: list[float], second_end: list[float],
    ) -> list[float] | None:
        first_direction = [first_end[0] - first_start[0], first_end[1] - first_start[1]]
        second_direction = [second_end[0] - second_start[0], second_end[1] - second_start[1]]
        denominator = first_direction[0] * second_direction[1] - first_direction[1] * second_direction[0]
        if abs(denominator) <= 1e-9:
            return None
        difference = [second_start[0] - first_start[0], second_start[1] - first_start[1]]
        scale = (difference[0] * second_direction[1] - difference[1] * second_direction[0]) / denominator
        return [first_start[axis] + scale * first_direction[axis] for axis in range(2)]

    previous = (selected_index - 1) % len(segments)
    following = (selected_index + 1) % len(segments)
    selected_start, selected_end = shifted_line(selected_index)
    previous_start, previous_end = shifted_line(previous)
    following_start, following_end = shifted_line(following)
    first = intersection(previous_start, previous_end, selected_start, selected_end)
    second = intersection(selected_start, selected_end, following_start, following_end)
    if first is None or second is None or _same_point(first, second):
        return None
    return _global(source_plane, first), _global(source_plane, second)


def _offset_face_profile_sketch(
    value: Any,
    feature_frames: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    feature_by_id: dict[str, dict[str, Any]],
    feature_id: str,
) -> dict[str, Any] | None:
    """Materialize one planar, linear-extrude OFFSET_FACE wall when proven.

    An offset face is a generated side wall, not the source extrusion's cap
    region. Reusing the full source profile therefore changes both the face
    extent and its topology. The wall is reconstructible only when direct
    source provenance proves one non-construction edge of a convex linear
    profile, one finite direct extrusion span, and one removed extrusion cap.
    All other OFFSET_FACE queries remain an explicit deferred capability
    rather than receiving a guessed profile.
    """
    query = parse_query(value)
    frame = feature_frames.get(query.owner_feature or "") or {}
    profile_id = frame.get("shell_profile_sketch_id")
    profile = sketches_by_id.get(str(profile_id)) if profile_id else None
    shell_source = frame.get("shell_source")
    direct_frame = feature_frames.get(str(shell_source)) if shell_source else None
    direct_feature = feature_by_id.get(f"f_{shell_source}") if shell_source else None
    profile_source = (direct_frame or {}).get("profile_source")
    source_sketch = sketch_by_source.get(str(profile_source)) if profile_source else None
    refs = _source_refs(value)
    if (
        query.topology_type != "OFFSET_FACE"
        or profile is None
        or direct_frame is None
        or direct_feature is None
        or direct_feature.get("atomic_id") != "extrude_add_blind"
        or (direct_feature.get("params") or {}).get("result_mode") != "new_body"
        or (direct_feature.get("params") or {}).get("draft") is not None
        or frame.get("shell_inward") is not True
        or frame.get("shell_removed_cap") not in {"start", "end"}
        or not isinstance(profile_source, str)
        or source_sketch is None
        or not _profile_matches_direct_source(profile, source_sketch)
        or len(refs) != 1
        or refs[0][0] != profile_source
        or query.source_sketch != profile_source
        or query.source_entity != refs[0][1]
    ):
        return None

    entity = (entity_by_sketch.get(profile_source) or {}).get(refs[0][1])
    if entity is None or entity.get("type") != "line" or entity.get("construction"):
        return None
    profile_plane = direct_frame.get("profile")
    start_plane = direct_frame.get("start")
    end_plane = direct_frame.get("end")
    if not all(isinstance(plane, dict) for plane in (profile_plane, start_plane, end_plane)):
        return None

    try:
        source_start, source_end = _convex_linear_offset_wall_endpoints(
            profile, entity, source_sketch["workplane"],
            _offset_face_plane(value, feature_frames, sketch_by_source, entity_by_sketch),
            float(frame["shell_thickness_mm"]),
        ) or (None, None)
        if source_start is None or source_end is None:
            return None
        line_direction = _unit(_sub(source_end, source_start), "offset face source line is degenerate")
        span = _sub(end_plane["origin_mm"], start_plane["origin_mm"])
        span_direction = _unit(span, "offset face extrusion span is degenerate")
        profile_normal = _unit(profile_plane["normal"], "offset face extrusion profile normal is degenerate")
        if (
            abs(_dot(line_direction, span_direction)) > 1e-6
            or abs(abs(_dot(span_direction, profile_normal)) - 1.0) > 1e-6
        ):
            return None
        cap_shift = _sub(start_plane["origin_mm"], profile_plane["origin_mm"])
        if not all(math.isfinite(component) for point in (source_start, source_end, span, cap_shift) for component in point):
            return None
        offset_plane = _offset_face_plane(value, feature_frames, sketch_by_source, entity_by_sketch)
    except (KeyError, TypeError, ValueError):
        return None

    cap_shrink = [float(frame["shell_thickness_mm"]) * component for component in span_direction]
    start_shift = list(cap_shift)
    end_shift = [cap_shift[index] + span[index] for index in range(3)]
    if frame["shell_removed_cap"] == "end":
        start_shift = [start_shift[index] + cap_shrink[index] for index in range(3)]
    else:
        end_shift = [end_shift[index] - cap_shrink[index] for index in range(3)]
    corners = [
        [source_start[index] + start_shift[index] for index in range(3)],
        [source_end[index] + start_shift[index] for index in range(3)],
        [source_end[index] + end_shift[index] for index in range(3)],
        [source_start[index] + end_shift[index] for index in range(3)],
    ]
    local_corners = [_local(offset_plane, corner) for corner in corners]
    if not all(math.isfinite(component) for point in local_corners for component in point):
        return None
    segments = [
        {"type": "line", "start": local_corners[index], "end": local_corners[(index + 1) % len(local_corners)]}
        for index in range(len(local_corners))
    ]
    return {
        "id": f"sketch_{query.owner_feature}__{feature_id}",
        "name": f"{query.owner_feature}__{feature_id}",
        "workplane": offset_plane,
        "profile": {"type": "analytic_contours", "contours": [{"role": "unknown", "closed": True, "segments": segments}]},
    }


def _query_line(
    query: Any,
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> tuple[list[float], list[float]]:
    info = parse_query(query)
    entity, plane, _ = _entity_from_query(query, sketch_by_source, entity_by_sketch)
    if info.topology_type == "CAP_EDGE" and info.owner_feature in feature_frames:
        frame_data = feature_frames[info.owner_feature]
        frame = frame_data["start" if info.is_start else "end"]
        # CAP outer normals may flip the x direction to preserve the later
        # sketch attachment handedness. A source sketch edge, however, keeps
        # its original physical in-plane coordinates at either cap. Preserve
        # that profile frame and move only its origin to the selected cap.
        profile = frame_data.get("profile")
        plane = {**profile, "origin_mm": list(frame["origin_mm"])} if isinstance(profile, dict) else frame
        if entity["type"] == "circle":
            center = _global(plane, entity["center"])
            return center, [center[index] + frame["normal"][index] for index in range(3)]
    if info.topology_type == "SWEPT_FACE" and entity["type"] == "circle" and info.owner_feature in feature_frames:
        frame = feature_frames[info.owner_feature]
        start, end = frame.get("start"), frame.get("end")
        if start is None or end is None: raise ValueError("cylindrical swept face frame is unresolved")
        center = _global(plane, entity["center"])
        return [center[index] + start["origin_mm"][index] - plane["origin_mm"][index] for index in range(3)], [center[index] + end["origin_mm"][index] - plane["origin_mm"][index] for index in range(3)]
    return _entity_line(entity, plane)


def _transform_axis(
    query: Any,
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> dict[str, list[float]]:
    start, end = _query_line(query, feature_frames, sketch_by_source, entity_by_sketch)
    return {"origin_mm": start, "direction": _unit(_sub(end, start), "transform axis is degenerate")}


def _scale_center(
    value: Any,
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> list[float]:
    """Resolve the explicit center of a CADFS uniform scale.

    Origin point is a system datum with a known coordinate. Other centers must
    name exactly one direct sketch or CAP_VERTEX source whose physical point is
    available in the lowering state. COPY/SWEPT/OFFSET vertices need runtime
    topology provenance, so treating their nearest visible point as the scale
    center would change the operation's semantics.
    """
    centers = _queries(value)
    if len(centers) != 1:
        raise UnsupportedCapability(
            "transform_uniform_scale_center",
            "SCALE_UNIFORMLY requires exactly one explicit scale point",
        )
    center = centers[0]
    for call in walk_calls(center):
        if call.name == "qCreatedBy" and call.args and "Origin.pointOp" in symbolic_string(call.args[0]):
            return [0.0, 0.0, 0.0]
    info = parse_query(center)
    if info.kind not in {"vertex", "entitytype.vertex"} or info.topology_type not in {None, "CAP_VERTEX"}:
        raise UnsupportedCapability(
            "transform_uniform_scale_center",
            "SCALE_UNIFORMLY scale point must be Origin point or a direct sketch/CAP_VERTEX",
        )
    try:
        return _query_point(center, feature_frames, sketch_by_source, entity_by_sketch)
    except ValueError as error:
        raise UnsupportedCapability(
            "transform_uniform_scale_center",
            "SCALE_UNIFORMLY scale point must resolve to one physical vertex",
        ) from error


def _translation_distance_vector(
    params: dict[str, Any],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    feature_by_id: dict[str, dict[str, Any]] | None = None,
    previous: list[str] | None = None,
) -> list[float]:
    """Resolve the restricted CADFS TRANSLATION_DISTANCE direction contract.

    An edge direction is only unambiguous when it comes from one source
    sketch line or its CAP_EDGE descendant. A direct CAP_FACE is also exact
    when its producer has recorded a physical start/end frame: its selected
    cap normal is the FeatureScript direction. A generic face normal, swept
    edge, offset edge, and curve tangent each need different source semantics,
    so they remain explicit capability gaps instead of borrowing a nearby
    direction from the active body.
    """
    directions = _queries(params.get("transformDirection"))
    if len(directions) != 1:
        raise UnsupportedCapability(
            "transform_translation_direction",
            "TRANSLATION_DISTANCE requires exactly one direct linear sketch or CAP_EDGE direction",
        )
    direction_query = directions[0]
    info = parse_query(direction_query)
    # System datum planes and previously lowered reference planes have an
    # explicit physical normal. ``_query_plane`` accepts only those two
    # qCreatedBy forms here, so this never treats an arbitrary produced face
    # as a translation direction.
    if "qCreatedBy" in info.calls and info.topology_type is None:
        try:
            direction = _unit(
                list(_query_plane(direction_query, feature_frames, sketch_by_source, entity_by_sketch)["normal"]),
                "transform reference-plane normal is degenerate",
            )
        except ValueError as error:
            raise UnsupportedCapability(
                "transform_translation_direction",
                "TRANSLATION_DISTANCE reference-plane direction must have an explicit plane frame",
            ) from error
    elif info.kind in {"face", "entitytype.face"} and info.topology_type == "SWEPT_FACE":
        try:
            direction = _unit(
                list(_query_plane(direction_query, feature_frames, sketch_by_source, entity_by_sketch)["normal"]),
                "transform swept-face normal is degenerate",
            )
        except (UnsupportedCapability, ValueError) as error:
            raise UnsupportedCapability(
                "transform_translation_direction",
                "TRANSLATION_DISTANCE SWEPT_FACE direction requires one direct planar source face",
            ) from error
    elif info.kind in {"face", "entitytype.face"} and info.topology_type == "CAP_FACE" and info.is_start is not None:
        frame = feature_frames.get(info.owner_feature or "") or {}
        cap = frame.get("start" if info.is_start else "end")
        try:
            direction = _unit(list((cap or {}).get("normal") or []), "transform cap-face normal is degenerate")
        except ValueError as error:
            raise UnsupportedCapability(
                "transform_translation_direction",
                "TRANSLATION_DISTANCE CAP_FACE direction requires a producer with a physical cap frame",
            ) from error
    else:
        if info.kind not in {"edge", "entitytype.edge"} or info.topology_type not in {None, "CAP_EDGE"}:
            raise UnsupportedCapability(
                "transform_translation_direction",
                "TRANSLATION_DISTANCE only supports a linear sketch/CAP_EDGE, exact transform copy, explicit reference plane, direct planar SWEPT_FACE, or framed CAP_FACE direction",
            )
        try:
            entity, _plane, _token = _entity_from_query(direction_query, sketch_by_source, entity_by_sketch)
            if entity.get("type") != "line":
                raise ValueError("transform direction source is not linear")
            if feature_by_id is not None and previous is not None:
                start, end = _transform_copy_line(
                    direction_query, feature_frames, sketch_by_source, entity_by_sketch, feature_by_id, previous,
                )
            else:
                start, end = _query_line(direction_query, feature_frames, sketch_by_source, entity_by_sketch)
            direction = _unit(_sub(end, start), "transform translation direction is degenerate")
        except ValueError as error:
            raise UnsupportedCapability(
                "transform_translation_direction",
                "TRANSLATION_DISTANCE direction must resolve to a non-degenerate line",
            ) from error
    distance = _number(params.get("distance"), True)
    if distance < 0:
        raise UnsupportedCapability(
            "transform_translation_distance",
            "TRANSLATION_DISTANCE requires a non-negative distance",
        )
    if _bool(params.get("oppositeDirection")):
        distance = -distance
    return [component * distance for component in direction]


def _translation_entity_vector(
    params: dict[str, Any],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    feature_by_id: dict[str, dict[str, Any]] | None = None,
    previous: list[str] | None = None,
) -> list[float]:
    """Resolve a direct CADFS TRANSLATION_ENTITY vector without topology guesses.

    FeatureScript accepts either a line entity, whose endpoint delta is the
    translation vector, or two vertices interpreted in selection order. This
    restricted lowering accepts raw sketch/CAP descendants and exact copies
    made by explicit single-source transforms. Other COPY/SWEPT/OFFSET
    geometry requires a kernel-proven successor relation.
    """
    entities = _queries(params.get("transformLine"))
    if len(entities) == 1:
        line = entities[0]
        info = parse_query(line)
        if info.kind not in {"edge", "entitytype.edge"} or info.topology_type not in {None, "CAP_EDGE"}:
            raise UnsupportedCapability(
                "transform_translation_entity",
                "TRANSLATION_ENTITY requires a linear sketch/CAP_EDGE or its exact transform copy",
            )
        try:
            entity, _plane, _token = _entity_from_query(line, sketch_by_source, entity_by_sketch)
            if entity.get("type") != "line":
                raise ValueError("transform line source is not linear")
            if feature_by_id is not None and previous is not None:
                start, end = _transform_copy_line(
                    line, feature_frames, sketch_by_source, entity_by_sketch, feature_by_id, previous,
                )
            else:
                start, end = _query_line(line, feature_frames, sketch_by_source, entity_by_sketch)
        except ValueError as error:
            raise UnsupportedCapability(
                "transform_translation_entity",
                "TRANSLATION_ENTITY line must resolve to a non-degenerate line",
            ) from error
    elif len(entities) == 2:
        first, second = entities
        first_info, second_info = parse_query(first), parse_query(second)
        if (
            first_info.kind not in {"vertex", "entitytype.vertex"}
            or second_info.kind not in {"vertex", "entitytype.vertex"}
            or first_info.topology_type not in {None, "CAP_VERTEX"}
            or second_info.topology_type not in {None, "CAP_VERTEX"}
        ):
            raise UnsupportedCapability(
                "transform_translation_entity",
                "TRANSLATION_ENTITY requires exactly two sketch/CAP_VERTEX points or their exact transform copies",
            )
        try:
            if feature_by_id is not None and previous is not None:
                start = _transform_copy_point(
                    first, feature_frames, sketch_by_source, entity_by_sketch, feature_by_id, previous,
                )
                end = _transform_copy_point(
                    second, feature_frames, sketch_by_source, entity_by_sketch, feature_by_id, previous,
                )
            else:
                start = _query_point(first, feature_frames, sketch_by_source, entity_by_sketch)
                end = _query_point(second, feature_frames, sketch_by_source, entity_by_sketch)
        except ValueError as error:
            raise UnsupportedCapability(
                "transform_translation_entity",
                "TRANSLATION_ENTITY vertices must resolve to unique points",
            ) from error
    else:
        raise UnsupportedCapability(
            "transform_translation_entity",
            "TRANSLATION_ENTITY requires one direct line or exactly two direct vertices",
        )
    vector = _sub(end, start)
    if math.sqrt(sum(component * component for component in vector)) <= 1e-9:
        raise UnsupportedCapability("transform_translation_entity", "TRANSLATION_ENTITY vector is degenerate")
    if _bool(params.get("oppositeDirectionEntity")):
        vector = [-component for component in vector]
    return vector


def _bake_transform(
    params: dict[str, Any],
    previous: list[str],
    feature_by_id: dict[str, dict[str, Any]],
    feature_source_by_id: dict[str, str],
    sketches_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> None:
    if _bool(params.get("makeCopy")):
        raise UnsupportedCapability("transform", "current CDSL engine cannot exactly copy transformed CADFS source bodies")
    sources = _transform_source_features(params.get("entities"), previous)
    if len(sources) != 1:
        raise UnsupportedCapability("transform", "current CDSL engine cannot exactly transform multiple selected CADFS source bodies")
    source_id = sources[0]; source = feature_by_id.get(source_id)
    if source is None or source.get("atomic_id") not in {"extrude_add_blind", "extrude_add_two_sided", "revolve_add"}:
        raise UnsupportedCapability("transform", "current CDSL engine can only bake a direct additive extrusion or revolve transform")
    sketch = sketches_by_id.get(str(source.get("sketch_id") or ""))
    source_feature_id = feature_source_by_id.get(source_id)
    if sketch is None or source_feature_id is None:
        raise UnsupportedCapability("transform", "current CDSL engine cannot resolve the transformed source feature geometry")
    transform_type = str(params.get("transformType") or "").split(".")[-1].upper()
    if transform_type == "TRANSLATION_3D":
        offset = [_number(params.get(key, 0.0), True) for key in ("dx", "dy", "dz")]
        transform_frame = lambda frame: _translate_frame(frame, offset)
        transform_axis = lambda axis: {**axis, "origin_mm": [axis["origin_mm"][index] + offset[index] for index in range(3)]}
    elif transform_type == "TRANSLATION_DISTANCE":
        offset = _translation_distance_vector(params, feature_frames, sketch_by_source, entity_by_sketch)
        transform_frame = lambda frame: _translate_frame(frame, offset)
        transform_axis = lambda axis: {**axis, "origin_mm": [axis["origin_mm"][index] + offset[index] for index in range(3)]}
    elif transform_type == "TRANSLATION_ENTITY":
        # Baking is only semantics-preserving while the selected NEW result
        # has not been absorbed or changed by another body-mutating feature.
        if source.get("params", {}).get("result_mode") != "new_body" or previous[-1:] != [source_id]:
            raise UnsupportedCapability(
                "transform_body_lifecycle",
                "TRANSLATION_ENTITY bake requires an immediately preceding independent NEW body",
            )
        offset = _translation_entity_vector(params, feature_frames, sketch_by_source, entity_by_sketch)
        transform_frame = lambda frame: _translate_frame(frame, offset)
        transform_axis = lambda axis: {**axis, "origin_mm": [axis["origin_mm"][index] + offset[index] for index in range(3)]}
    elif transform_type == "ROTATION":
        axis = _transform_axis(params.get("transformAxis"), feature_frames, sketch_by_source, entity_by_sketch)
        angle_rad = math.radians(_number(params.get("angle"), True))
        transform_frame = lambda frame: _rotate_frame(frame, axis, angle_rad)
        transform_axis = lambda value: {
            **value,
            "origin_mm": _rotate_point(value["origin_mm"], axis, angle_rad),
            "direction": _rotate(value["direction"], axis["direction"], angle_rad),
        }
    else:
        raise UnsupportedCapability("transform", f"current CDSL engine cannot exactly bake {transform_type or 'unknown'} transform")
    sketch["workplane"] = transform_frame(sketch["workplane"])
    frame = feature_frames.get(source_feature_id)
    if frame is not None:
        transformed = {key: transform_frame(value) for key, value in frame.items() if key in {"start", "end", "profile"}}
        for cap in ("start", "end"):
            if cap in transformed:
                transformed[f"{cap}_attachment"] = _attachment_plane(transformed[cap])
        if isinstance(frame.get("revolve_axis"), dict): transformed["revolve_axis"] = transform_axis(frame["revolve_axis"])
        if "revolve_full" in frame: transformed["revolve_full"] = frame["revolve_full"]
        feature_frames[source_feature_id] = transformed
    source_axis = source.get("params", {}).get("axis")
    if isinstance(source_axis, dict) and source_axis.get("origin_mm") and source_axis.get("direction"):
        source["params"]["axis"] = transform_axis(source_axis)


def _record_non_copy_body_successors(
    aliases: dict[str, str],
    source_ids: list[str],
    successor_id: str,
) -> None:
    """Bind direct transform sources to their latest physical body member.

    A non-copy transform replaces exactly the selected independent members in
    the runtime. Preserve that one-to-one lifecycle fact for later CADFS
    queries that retain the original producer ID. This deliberately has no
    fallback for fused/dress-up/pattern members because those are not entered
    into ``aliases`` by lowering.
    """
    for source in source_ids:
        for owner, current in list(aliases.items()):
            if current == source:
                aliases[owner] = successor_id
        aliases[source] = successor_id


_SINGLE_BODY_FUSING_ATOMICS = frozenset({
    "extrude_add_blind", "extrude_add_blind_with_hole", "extrude_add_two_sided",
    "extrude_from_face", "loft_add", "loft_add_with_cap_face", "sweep_add", "revolve_add",
})
_SINGLE_BODY_DRESSUP_ATOMICS = frozenset({"fillet", "chamfer", "shell"})
_SINGLE_BODY_CUT_ATOMICS = frozenset({
    "extrude_cut_blind", "extrude_cut_two_sided", "revolve_cut",
    "hole_blind", "hole_countersink", "hole_counterbore", "hole_wizard", "thread_cut",
})
_SINGLE_BODY_NON_MUTATING_ATOMICS = frozenset({"reference_plane", "reference_axis", "extrude_surface", "revolve_surface"})
_LOWERING_BODY_MUTATING_ATOMICS = frozenset({
    "extrude_add_blind", "extrude_add_blind_with_hole", "extrude_add_two_sided",
    "extrude_cut_blind", "extrude_cut_two_sided", "extrude_cut_through", "extrude_from_face",
    "loft_add", "loft_add_with_cap_face", "sweep_add", "revolve_add", "revolve_cut",
    "sphere_add", "box_add", "cylinder_add", "thread_add", "thread_cut", "bend_add",
    "hole_blind", "hole_countersink", "hole_counterbore", "hole_wizard", "fillet", "chamfer",
    "shell", "boolean_bodies",
})
_LOWERING_CUT_ATOMICS = frozenset({
    "extrude_cut_blind", "extrude_cut_two_sided", "extrude_cut_through", "revolve_cut",
    "thread_cut", "hole_blind", "hole_countersink", "hole_counterbore", "hole_wizard",
})
_LOWERING_PRIMARY_ATOMICS = frozenset({
    "extrude_add_blind", "extrude_add_blind_with_hole", "extrude_add_two_sided", "extrude_from_face",
    "loft_add", "loft_add_with_cap_face", "sweep_add", "revolve_add", "sphere_add", "box_add",
    "cylinder_add", "thread_add", "bend_add",
})


def _record_lowered_body_members(members: set[str], feature: dict[str, Any]) -> None:
    """Mirror the runtime's independently selectable body-member contract.

    This projection is intentionally narrower than geometric body ownership.
    It only decides whether a later direct CADFS SWEPT_BODY can be emitted as a
    CDSL shell target. No aggregate/current-body fallback is permitted here.
    """
    feature_id = str(feature["id"])
    atomic_id = str(feature.get("atomic_id") or "")
    params = feature.get("params") or {}
    if atomic_id == "boolean_bodies":
        targets = {str(value) for value in params.get("target_feature_ids") or ()}
        tools = {str(value) for value in params.get("tool_feature_ids") or ()}
        members.difference_update(targets | tools)
        members.add(feature_id)
        if bool(params.get("keep_tools")):
            members.update(tools)
        return
    if atomic_id == "transform_bodies":
        sources = {str(value) for value in params.get("source_feature_ids") or ()}
        if bool(params.get("make_copy")):
            if len(sources) == 1:
                members.add(feature_id)
            return
        members.difference_update(sources)
        members.add(feature_id)
        return
    if atomic_id == "delete_bodies":
        members.difference_update(str(value) for value in params.get("target_feature_ids") or ())
        return
    if atomic_id in {"pattern_linear", "pattern_mirror", "pattern_circular"}:
        sources = {str(value) for value in params.get("source_feature_ids") or ()}
        if not (
            atomic_id == "pattern_circular"
            and str(params.get("operation_mode") or "add") == "add"
            and sources
            and sources <= members
        ):
            members.clear()
        return
    if atomic_id not in _LOWERING_BODY_MUTATING_ATOMICS:
        return
    if atomic_id in _LOWERING_CUT_ATOMICS or (
        atomic_id == "extrude_from_face" and params.get("operation") == "cut"
    ):
        return
    if atomic_id in _LOWERING_PRIMARY_ATOMICS and params.get("result_mode") == "new_body":
        members.add(feature_id)
        return
    members.clear()
    members.add(feature_id)


def _clear_single_body_successor_state(
    aliases: dict[str, str],
    state: dict[str, Any],
) -> None:
    """Discard only aliases derived from the restricted aggregate lineage."""
    for source in state["sources"]:
        aliases.pop(source, None)
    state["owner"] = None
    state["sources"] = set()


def _record_single_body_successor(
    aliases: dict[str, str],
    state: dict[str, Any],
    feature: dict[str, Any],
) -> None:
    """Track one CADFS body through exact single-aggregate successors.

    A ``SWEPT_BODY`` query names a CADFS body object, not a frozen feature
    result. When an ordinary additive feature or dress-up mutates the only
    active body, the original body query still denotes that same physical
    body. Runtime collapses those operations to one explicit body member, so
    lowering may follow the successor only while this state machine mirrors
    that one-member lifecycle exactly. Multi-body, boolean, pattern, delete,
    and other body-changing paths intentionally clear the proof rather than
    substituting ``session.body``.
    """
    feature_id = str(feature["id"])
    atomic_id = str(feature.get("atomic_id") or "")
    params = feature.get("params") or {}
    owner = state["owner"]
    sources: set[str] = state["sources"]

    def advance() -> None:
        for source in sources:
            if source != feature_id:
                aliases[source] = feature_id
        aliases.pop(feature_id, None)
        sources.add(feature_id)
        state["owner"] = feature_id

    if atomic_id in _SINGLE_BODY_NON_MUTATING_ATOMICS:
        return
    if atomic_id in _SINGLE_BODY_CUT_ATOMICS:
        # Runtime preserves the selected member keys for a cut. The cut
        # feature itself is not a new independently selectable body member.
        return
    if atomic_id in _SINGLE_BODY_FUSING_ATOMICS:
        if atomic_id == "extrude_from_face" and params.get("operation") == "cut":
            return
        if params.get("result_mode") == "new_body":
            if owner is None:
                state["owner"] = feature_id
                sources.add(feature_id)
            else:
                # A new body does not mutate the preceding member.  Existing
                # aliases still identify that member exactly (for example a
                # later SWEPT_BODY query of a shell's original direct-prism
                # owner), even though there is no longer one aggregate body
                # through which a future ordinary ADD may advance them.
                # Detach the single-body state without erasing those proven
                # member aliases.
                state["owner"] = None
                state["sources"] = set()
            return
        if owner is None:
            state["owner"] = feature_id
            sources.add(feature_id)
        else:
            advance()
        return
    if atomic_id in _SINGLE_BODY_DRESSUP_ATOMICS:
        if owner is not None:
            advance()
        return
    if atomic_id == "transform_bodies":
        source_ids = [str(value) for value in params.get("source_feature_ids") or ()]
        if bool(params.get("make_copy")):
            # The original member remains addressable, but the aggregate is no
            # longer a one-body lifecycle. Do not let a later ordinary ADD or
            # dress-up advance an alias across that unproven split.
            _clear_single_body_successor_state(aliases, state)
            return
        if owner is not None and source_ids == [owner] and not params.get("pattern_instance_refs"):
            advance()
            return
        _clear_single_body_successor_state(aliases, state)
        return
    if atomic_id == "pattern_circular":
        # A direct circular ADD over the sole current member takes the runtime
        # body-member path: it preserves that member and exposes each rotated
        # copy under an exact instance key. Keep the already-proven aliases so
        # a following CADFS COPY(SWEPT_BODY) resolves to the same member.
        source_ids = [str(value) for value in params.get("source_feature_ids") or ()]
        if (
            owner is not None
            and str(params.get("operation_mode") or "add") == "add"
            and source_ids == [owner]
        ):
            return
    # The remaining body atomics either split ownership, select explicit
    # members, or replay feature geometry. Their CADFS body continuation is
    # not represented by this restricted one-member contract.
    _clear_single_body_successor_state(aliases, state)


def _query_point(
    query: Any,
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> list[float]:
    info = parse_query(query)
    cpoint_frame = feature_frames.get(info.owner_feature or "")
    if (
        info.topology_type is None
        and info.kind in {"vertex", "entitytype.vertex"}
        and "qCreatedBy" in info.calls
        and isinstance(cpoint_frame, dict)
        and isinstance(cpoint_frame.get("point_mm"), list)
    ):
        return list(cpoint_frame["point_mm"])
    if info.topology_type == "CAP_VERTEX" and info.owner_feature in feature_frames:
        frame_data = feature_frames[info.owner_feature]
        cap = frame_data["start" if info.is_start else "end"]
        profile = frame_data.get("profile")
        plane = {**profile, "origin_mm": list(cap["origin_mm"])} if isinstance(profile, dict) else cap
        references = _source_refs(query)
        if len(references) >= 2:
            lines = []
            for source, token in references:
                available = entity_by_sketch.get(source) or {}
                entity = available.get(token)
                if entity is None:
                    entity_id = max((key for key in available if token.startswith(key + ".")), key=len, default="")
                    entity = available.get(entity_id)
                if entity and entity.get("type") == "line": lines.append(_entity_line(entity, plane))
            if len(lines) >= 2:
                pairs = [(math.dist(left, right), left) for left in lines[0] for right in lines[1]]
                distance, point = min(pairs, key=lambda item: item[0])
                if distance <= 1e-5: return point
    entity, plane, token = _entity_from_query(query, sketch_by_source, entity_by_sketch)
    if info.topology_type == "CAP_VERTEX" and info.owner_feature in feature_frames:
        frame_data = feature_frames[info.owner_feature]
        cap = frame_data["start" if info.is_start else "end"]
        profile = frame_data.get("profile")
        plane = {**profile, "origin_mm": list(cap["origin_mm"])} if isinstance(profile, dict) else cap
    return _entity_point(entity, plane, token)


def _featurescript_perpendicular_vector(value: list[float]) -> list[float]:
    """Match FeatureScript 1511's deterministic ``perpendicularVector``.

    ``LINE_ANGLE`` with one selected axis has no second reference that can
    determine its zero-angle direction.  The standard library deliberately
    supplies one with ``perpendicularVector``; using an arbitrary local frame
    here changes subsequent sketch coordinates.  Keep the same branch
    thresholds as the 1511 implementation instead of deriving a direction
    from a current body or a topology hint.
    """
    direction = _unit(value, "line-angle reference axis is degenerate")
    if abs(direction[0]) > 1.036663652861932668633 * abs(direction[1]):
        different = [0.0, 0.0, 1.0] if abs(direction[0]) > .951702989392233451722 * abs(direction[2]) else [0.0, 1.0, 0.0]
    else:
        different = [1.0, 0.0, 0.0] if abs(direction[1]) > .920419947455385938102 * abs(direction[2]) else [0.0, 1.0, 0.0]
    return _unit(_cross(different, direction), "line-angle reference axis is degenerate")


def _direct_line_angle_source_entity(
    query: Any,
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> tuple[dict[str, Any], dict[str, Any], str] | None:
    """Resolve one exact sketch entity without widening it to topology.

    ``LINE_ANGLE`` accepts direct sketch construction geometry as well as
    profile geometry.  The source entity key must therefore match exactly;
    suffix matching would incorrectly turn a trim, CAP, SWEPT, COPY, or other
    derived query into an original sketch reference.
    """
    info = parse_query(query)
    direct_calls = {"sQuery", "sketchEntityQuery", "__binary__"}
    if (
        info.topology_type is not None
        or not info.calls
        or any(call not in direct_calls for call in info.calls)
        or not isinstance(info.source_sketch, str)
        or not isinstance(info.source_entity, str)
    ):
        return None
    sketch = sketch_by_source.get(info.source_sketch)
    entity = (entity_by_sketch.get(info.source_sketch) or {}).get(info.source_entity)
    if sketch is None or entity is None:
        return None
    return entity, sketch["workplane"], info.source_entity


def _derived_line_angle_cylinder_axis(
    query: Any,
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> tuple[dict[str, Any], dict[str, Any], str] | None:
    """Accept the legacy derived-cylinder contract without widening it.

    The older LINE_ANGLE compatibility path is not a general fallback for a
    query which happens to mention a source line. It is limited to a direct
    source circle selected as a CAP_EDGE or SWEPT_FACE of an operation whose
    recorded frame can prove its cylinder axis.
    """
    try:
        _call, owner, topology, kind, _definition = _direct_make_query(query)
    except ValueError:
        return None
    if (
        (topology == "CAP_EDGE" and kind != "edge")
        or (topology == "SWEPT_FACE" and kind != "face")
        or topology not in {"CAP_EDGE", "SWEPT_FACE"}
    ):
        return None
    info = parse_query(query)
    if info.owner_feature != owner or not isinstance(info.source_sketch, str) or not isinstance(info.source_entity, str):
        return None
    references = _source_refs(query)
    if references != [(info.source_sketch, info.source_entity)]:
        return None
    resolved = _source_ref_entity(info.source_sketch, info.source_entity, entity_by_sketch)
    sketch = sketch_by_source.get(info.source_sketch)
    frame = feature_frames.get(owner)
    if (
        resolved is None
        or sketch is None
        or frame is None
        or resolved[0] != info.source_entity
        or resolved[1].get("type") != "circle"
        or not isinstance(frame.get("start"), dict)
        or not isinstance(frame.get("end"), dict)
    ):
        return None
    return resolved[1], sketch["workplane"], info.source_entity


def _direct_line_angle_axis(
    query: Any,
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> tuple[list[float], list[float]] | None:
    """Return the exact ``evAxis`` result for a direct sketch line/circle.

    FeatureScript's ``lineAnglePlane`` passes selected axes to ``evAxis``.
    A direct ``skLineSegment`` and a direct ``skCircle`` have unique source
    axes.  This does not infer an axis from a resulting edge: CAP/SWEPT/COPY
    and suffix-derived references stay out of this source-only path.
    """
    info = parse_query(query)
    if info.kind not in {"edge", "entitytype.edge"}:
        return None
    direct = _direct_line_angle_source_entity(query, sketch_by_source, entity_by_sketch)
    if direct is None:
        return None
    entity, plane, _token = direct
    if entity.get("type") == "line":
        start, end = _entity_line(entity, plane)
        return start, _unit(_sub(end, start), "line-angle reference axis is degenerate")
    if entity.get("type") == "circle":
        center = entity.get("center")
        if not isinstance(center, list) or len(center) != 2:
            return None
        return _global(plane, center), _unit(list(plane["normal"]), "line-angle reference axis is degenerate")
    return None


def _direct_prism_line_angle_swept_edge_axis(
    query: Any,
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    *,
    previous: list[str],
    featurescript_version: str | None,
) -> tuple[list[float], list[float]] | None:
    """Return a source-determined datum axis for one direct prism SWEPT_EDGE.

    This is deliberately a datum calculation, not a topology resolver.  A
    direct blind prism turns one explicitly identified source-profile vertex
    into the line connecting its two cap copies.  The producer frame records
    that its profile was unchanged, so the two source curves and the prism
    span determine that line without asking the current body for an edge.
    """
    if featurescript_version != "1511":
        return None
    try:
        _call, owner, topology, kind, _definition = _direct_make_query(query)
    except ValueError:
        return None
    producer_id = f"f_{owner}"
    frame = feature_frames.get(owner) or {}
    profile_source = frame.get("profile_source")
    if (
        topology != "SWEPT_EDGE"
        or kind not in {"edge", "entitytype.edge"}
        or previous[-1:] != [producer_id]
        or frame.get("direct_prism_line_angle_axis") is not True
        or not isinstance(profile_source, str)
        or profile_source not in sketch_by_source
        or not isinstance(frame.get("profile"), dict)
        or not isinstance(frame.get("start"), dict)
        or not isinstance(frame.get("end"), dict)
    ):
        return None
    refs = _source_refs(query)
    if len(refs) != 2 or {source for source, _token in refs} != {profile_source}:
        return None
    source_ids = set(frame.get("direct_prism_source_entity_ids") or ())
    resolved_ids: set[str] = set()
    for source, token in refs:
        resolved = _source_ref_entity(source, token, entity_by_sketch)
        if resolved is None:
            return None
        entity_id, entity = resolved
        if entity.get("construction") or entity_id not in source_ids:
            return None
        resolved_ids.add(entity_id)
    if len(resolved_ids) != 2:
        return None
    local = _shared_source_endpoint(refs, profile_source, entity_by_sketch)
    if local is None:
        return None
    try:
        source_point = _global(sketch_by_source[profile_source]["workplane"], local)
        profile_origin = frame["profile"]["origin_mm"]
        start_origin = frame["start"]["origin_mm"]
        end_origin = frame["end"]["origin_mm"]
        start = [source_point[index] + start_origin[index] - profile_origin[index] for index in range(3)]
        direction = _unit(_sub(end_origin, start_origin), "line-angle swept-edge axis is degenerate")
    except (KeyError, TypeError, ValueError):
        return None
    if not all(math.isfinite(component) for component in start + direction):
        return None
    return start, direction


def _direct_line_angle_wire_axis(
    query: Any,
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    *,
    featurescript_version: str | None,
    standard_library: str | None,
    standard_library_version: str | None,
) -> tuple[list[float], list[float]] | None:
    """Return one exact source-wire line axis for ``LINE_ANGLE``.

    This interprets only one direct ``qBodyType(qCreatedBy(sketch, EDGE),
    WIRE)`` source query. It does not expose a runtime ``qBodyType`` selector:
    one line must be named from one source sketch, with no derived topology or
    current-body information. Construction lines are valid datum axes, unlike
    sweep paths.
    """
    selection = _direct_sketch_wire_selection(
        Call("qUnion", [[query]]), sketch_by_source, entity_by_sketch,
        featurescript_version=featurescript_version,
        standard_library=standard_library,
        standard_library_version=standard_library_version,
        permit_construction=True,
    )
    if selection is None:
        return None
    _source, candidates, sketch = selection
    if len(candidates) != 1 or candidates[0][1].get("type") != "line":
        return None
    _entity_id, entity = candidates[0]
    start, end = _entity_line(entity, sketch["workplane"])
    return start, _unit(_sub(end, start), "line-angle reference axis is degenerate")


def _direct_line_angle_reference_plane(
    query: Any,
    feature_frames: dict[str, dict[str, Any]],
) -> dict[str, Any] | None:
    """Resolve only a default plane or an already-lowered reference plane."""
    default = _default_plane(query)
    if default is not None:
        return default
    info = parse_query(query)
    if (
        info.topology_type is not None
        or "qCreatedBy" not in info.calls
        or not info.owner_feature
    ):
        return None
    frame = feature_frames.get(info.owner_feature)
    if not isinstance(frame, dict) or frame.get("start") != frame.get("end"):
        return None
    start = frame.get("start")
    return dict(start) if isinstance(start, dict) else None


def _direct_line_angle_reference_point(
    query: Any,
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> list[float] | None:
    """Resolve one explicit datum point or direct sketch point/endpoint."""
    info = parse_query(query)
    cpoint_frame = feature_frames.get(info.owner_feature or "")
    if (
        info.topology_type is None
        and info.kind in {"vertex", "entitytype.vertex"}
        and "qCreatedBy" in info.calls
        and isinstance(cpoint_frame, dict)
        and isinstance(cpoint_frame.get("point_mm"), list)
    ):
        return list(cpoint_frame["point_mm"])
    if (
        info.topology_type is not None
        or info.kind not in {"vertex", "entitytype.vertex"}
        or not isinstance(info.source_sketch, str)
        or not isinstance(info.source_entity, str)
    ):
        return None
    sketch = sketch_by_source.get(info.source_sketch)
    resolved = _source_ref_entity(info.source_sketch, info.source_entity, entity_by_sketch)
    if sketch is None or resolved is None:
        return None
    entity_id, entity = resolved
    token = info.source_entity
    if entity.get("type") == "point" and token == entity_id:
        return _entity_point(entity, sketch["workplane"], token)
    if entity.get("type") == "line" and token in {f"{entity_id}.start", f"{entity_id}.end"}:
        return _entity_point(entity, sketch["workplane"], token)
    return None


def _direct_line_angle_two_entity_plane(
    entities: list[Any],
    params: dict[str, Any],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    *,
    previous: list[str],
    featurescript_version: str | None,
    standard_library: str | None,
    standard_library_version: str | None,
) -> dict[str, Any] | None:
    """Implement FeatureScript's exact two-entity ``lineAnglePlane`` rule.

    The first entity normally supplies the axis.  If it has no direct axis and
    the second entity does, FeatureScript swaps the axis and treats the
    original first entity as the plane/point reference.  Parallel axes use
    their origin-to-origin vector; nonparallel axes use the second direction.
    """
    if len(entities) != 2:
        return None
    first_axis = (
        _direct_line_angle_axis(entities[0], sketch_by_source, entity_by_sketch)
        or _direct_prism_line_angle_swept_edge_axis(
            entities[0], feature_frames, sketch_by_source, entity_by_sketch,
            previous=previous, featurescript_version=featurescript_version,
        )
        or _direct_line_angle_wire_axis(
            entities[0], sketch_by_source, entity_by_sketch,
            featurescript_version=featurescript_version,
            standard_library=standard_library,
            standard_library_version=standard_library_version,
        )
    )
    second_axis = (
        _direct_line_angle_axis(entities[1], sketch_by_source, entity_by_sketch)
        or _direct_prism_line_angle_swept_edge_axis(
            entities[1], feature_frames, sketch_by_source, entity_by_sketch,
            previous=previous, featurescript_version=featurescript_version,
        )
        or _direct_line_angle_wire_axis(
            entities[1], sketch_by_source, entity_by_sketch,
            featurescript_version=featurescript_version,
            standard_library=standard_library,
            standard_library_version=standard_library_version,
        )
    )
    if first_axis is None:
        if second_axis is None:
            return None
        axis_origin, axis_direction = second_axis
        reference = entities[0]
        reference_axis = None
    else:
        axis_origin, axis_direction = first_axis
        reference = entities[1]
        reference_axis = second_axis

    if reference_axis is not None:
        reference_origin, reference_direction = reference_axis
        if math.sqrt(_dot(_cross(axis_direction, reference_direction), _cross(axis_direction, reference_direction))) <= 1e-9:
            second_in_plane_direction = _sub(reference_origin, axis_origin)
        else:
            second_in_plane_direction = reference_direction
    else:
        reference_plane = _direct_line_angle_reference_plane(reference, feature_frames)
        if reference_plane is not None:
            second_in_plane_direction = _cross(axis_direction, reference_plane["normal"])
        else:
            reference_point = _direct_line_angle_reference_point(
                reference, feature_frames, sketch_by_source, entity_by_sketch,
            )
            if reference_point is None:
                return None
            second_in_plane_direction = _sub(reference_point, axis_origin)

    normal = _cross(axis_direction, second_in_plane_direction)
    _unit(normal, "line-angle reference selection is degenerate")
    signed_angle = _number(params.get("angle", 0.0))
    if _bool(params.get("oppositeDirection")):
        signed_angle = -signed_angle
    return _frame(
        axis_origin,
        axis_direction,
        _rotate(normal, axis_direction, math.radians(signed_angle)),
    )


def _cpoint_parameter(params: dict[str, Any]) -> float:
    """Read the finite source-line parameter shared by every datum form."""
    parameter = _number(params.get("parameter"))
    if not math.isfinite(parameter) or not 0.0 <= parameter <= 1.0:
        raise UnsupportedCapability("reference_point", "cPoint parameter must be a finite value in [0, 1]")
    return parameter


def _direct_source_line_cpoint(
    params: dict[str, Any],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
) -> list[float]:
    """Evaluate one `cPoint` on a direct source-sketch line.

    This is source datum geometry, not a runtime edge selector.  FeatureScript
    parameterizes a line segment affinely, so the source endpoint coordinates
    and a finite unit-interval parameter completely determine the point.
    Derived CAP/SWEPT edges and curved source entities need their own contracts.
    """
    entities = _queries(params.get("entities"))
    if len(entities) != 1:
        raise UnsupportedCapability("reference_point", "cPoint requires exactly one direct source line")
    query = parse_query(entities[0])
    if (
        query.topology_type is not None
        or query.kind not in {"edge", "entitytype.edge"}
        or not isinstance(query.source_sketch, str)
        or not isinstance(query.source_entity, str)
    ):
        raise UnsupportedCapability("reference_point", "cPoint source must be one direct sketch line")
    resolved = _source_ref_entity(query.source_sketch, query.source_entity, entity_by_sketch)
    sketch = sketch_by_source.get(query.source_sketch)
    if resolved is None or sketch is None:
        raise ValueError("cPoint source line is unresolved")
    entity_id, entity = resolved
    if entity_id != query.source_entity or entity.get("type") != "line":
        raise UnsupportedCapability("reference_point", "cPoint only supports an original unsuffixed source line")
    parameter = _cpoint_parameter(params)
    start, end = _entity_line(entity, sketch["workplane"])
    return [start[index] + parameter * (end[index] - start[index]) for index in range(3)]


def _direct_prism_swept_edge_cpoint(
    value: Any,
    params: dict[str, Any],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    *,
    previous: list[str],
    featurescript_version: str | None,
) -> list[float] | None:
    """Evaluate a source-defined direct-prism SWEPT_EDGE datum point.

    The LINE_ANGLE datum bridge proves the source vertex and prism span.
    cPoint interpolates that source-defined span; it never resolves a runtime
    edge or inspects the resulting body.
    """
    try:
        _call, owner, topology, _kind, _definition = _direct_make_query(value)
    except ValueError:
        return None
    if topology != "SWEPT_EDGE":
        return None
    axis = _direct_prism_line_angle_swept_edge_axis(
        value, feature_frames, sketch_by_source, entity_by_sketch,
        previous=previous, featurescript_version=featurescript_version,
    )
    frame = feature_frames.get(owner) or {}
    start_frame, end_frame = frame.get("start"), frame.get("end")
    if (
        axis is None
        or not isinstance(start_frame, dict)
        or not isinstance(end_frame, dict)
        or not isinstance(start_frame.get("origin_mm"), list)
        or not isinstance(end_frame.get("origin_mm"), list)
    ):
        return None
    parameter = _cpoint_parameter(params)
    start, _direction = axis
    span = _sub(end_frame["origin_mm"], start_frame["origin_mm"])
    return [start[index] + parameter * span[index] for index in range(3)]


def _direct_prism_cap_edge_cpoint(
    value: Any,
    params: dict[str, Any],
    *,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    previous: list[str],
    featurescript_version: str | None,
) -> list[float] | None:
    """Evaluate one direct-prism CAP_EDGE datum from its source line and role.

    Source datum points remain valid through earlier cPoint/reference-plane
    features, but no body-mutating feature may intervene. The cap is not
    looked up from the current B-rep.
    """
    if featurescript_version != "1511":
        return None
    try:
        _call, owner, topology, kind, _definition = _direct_make_query(value)
    except ValueError:
        return None
    query = parse_query(value)
    producer_id = f"f_{owner}"
    producer = feature_by_id.get(producer_id) or {}
    producer_params = producer.get("params") or {}
    frame = feature_frames.get(owner) or {}
    profile_source = frame.get("profile_source")
    profile_sketch = sketches_by_id.get(str(producer.get("sketch_id") or ""))
    source_sketch = sketch_by_source.get(profile_source) if isinstance(profile_source, str) else None
    if producer_id not in previous:
        return None
    producer_index = previous.index(producer_id)
    intervening = previous[producer_index + 1:]
    if (
        topology != "CAP_EDGE"
        or kind not in {"edge", "entitytype.edge"}
        or query.is_start is None
        or any((feature_by_id.get(feature_id) or {}).get("atomic_id") not in {"reference_plane", "reference_point"} for feature_id in intervening)
        or producer.get("atomic_id") != "extrude_add_blind"
        or producer_params.get("result_mode") != "new_body"
        or (producer_params.get("end_condition") or {}).get("type") != "blind"
        or producer_params.get("draft") is not None
        or not isinstance(profile_source, str)
        or source_sketch is None
        or profile_sketch is None
        or profile_sketch.get("source_sketch_id") != profile_source
        or not _profile_matches_direct_source(profile_sketch, source_sketch)
    ):
        return None
    refs = _source_refs(value)
    if len(refs) != 1 or refs[0][0] != profile_source or query.source_entity != refs[0][1]:
        return None
    resolved = _source_ref_entity(profile_source, refs[0][1], entity_by_sketch)
    source_ids = _direct_profile_source_entity_ids(profile_sketch)
    if resolved is None:
        return None
    entity_id, entity = resolved
    if (
        entity_id != refs[0][1]
        or entity_id not in source_ids
        or entity.get("construction")
        or entity.get("type") != "line"
    ):
        return None
    cap = frame.get("start" if query.is_start else "end")
    profile = frame.get("profile")
    if (
        not isinstance(cap, dict)
        or not isinstance(profile, dict)
        or not isinstance(cap.get("origin_mm"), list)
        or not isinstance(profile.get("origin_mm"), list)
    ):
        return None
    parameter = _cpoint_parameter(params)
    start, end = _entity_line(entity, source_sketch["workplane"])
    source_point = [start[index] + parameter * (end[index] - start[index]) for index in range(3)]
    return [source_point[index] + cap["origin_mm"][index] - profile["origin_mm"][index] for index in range(3)]


def _cpoint_datum(
    params: dict[str, Any],
    *,
    feature_by_id: dict[str, dict[str, Any]],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    previous: list[str],
    featurescript_version: str | None,
) -> list[float]:
    """Select the only source-datum cPoint forms presently proven by source."""
    entities = _queries(params.get("entities"))
    if len(entities) != 1:
        raise UnsupportedCapability("reference_point", "cPoint requires exactly one direct source line")
    query = entities[0]
    topology = parse_query(query).topology_type
    if topology is None:
        return _direct_source_line_cpoint(params, sketch_by_source, entity_by_sketch)
    point = (
        _direct_prism_swept_edge_cpoint(
            query, params, feature_frames, sketch_by_source, entity_by_sketch,
            previous=previous, featurescript_version=featurescript_version,
        )
        if topology == "SWEPT_EDGE" else _direct_prism_cap_edge_cpoint(
            query, params,
            feature_by_id=feature_by_id,
            feature_frames=feature_frames,
            sketch_by_source=sketch_by_source,
            sketches_by_id=sketches_by_id,
            entity_by_sketch=entity_by_sketch,
            previous=previous,
            featurescript_version=featurescript_version,
        ) if topology == "CAP_EDGE" else None
    )
    if point is None:
        raise UnsupportedCapability("reference_point", "cPoint datum source is unsupported")
    return point


def _cplane(
    params: dict[str, Any],
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    *,
    feature_by_id: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    previous: list[str],
    featurescript_version: str | None = None,
    standard_library: str | None = None,
    standard_library_version: str | None = None,
) -> dict[str, Any]:
    plane_type = str(params.get("cplaneType") or "OFFSET").split(".")[-1].upper()
    entities = _queries(params.get("entities"))

    def datum_point(query: Any) -> list[float]:
        # The origin point is an explicit system datum. A CAP_VERTEX is not:
        # it must satisfy the direct source-prism contract above rather than
        # falling through to the legacy frame-based point reconstruction.
        if any(
            call.name == "qCreatedBy" and call.args
            and "Origin.pointOp" in symbolic_string(call.args[0])
            for call in walk_calls(query)
        ):
            return [0.0, 0.0, 0.0]
        if parse_query(query).topology_type == "CAP_VERTEX":
            point = _direct_prism_cap_vertex_datum_point(
                query,
                feature_by_id=feature_by_id,
                feature_frames=feature_frames,
                sketch_by_source=sketch_by_source,
                sketches_by_id=sketches_by_id,
                entity_by_sketch=entity_by_sketch,
                previous=previous,
                featurescript_version=featurescript_version,
            )
            if point is None:
                raise ValueError("CAP_VERTEX datum source is unsupported")
            return point
        return _query_point(query, feature_frames, sketch_by_source, entity_by_sketch)
    if plane_type == "OFFSET":
        offset = _number(params.get("offset", 0), True)
        # CPlane OFFSET preserves the source plane's local frame. CADFS uses
        # oppositeDirection only to select the other signed offset side.
        if _bool(params.get("oppositeDirection")):
            offset = -offset
        return _shift_plane(_query_plane(entities[0], feature_frames, sketch_by_source, entity_by_sketch), offset)
    if plane_type == "LINE_ANGLE":
        # ``lineAnglePlane`` resolves the direct source contract before any
        # topology-derived workplane compatibility path.  In particular, a
        # two-entity plane is defined by the axis plus the second entity's
        # direction, not by rotating an arbitrary source workplane frame.
        if len(entities) == 1:
            direct_axis = _direct_line_angle_axis(
                entities[0], sketch_by_source, entity_by_sketch,
            ) or _direct_prism_line_angle_swept_edge_axis(
                entities[0], feature_frames, sketch_by_source, entity_by_sketch,
                previous=previous, featurescript_version=featurescript_version,
            ) or _direct_line_angle_wire_axis(
                entities[0], sketch_by_source, entity_by_sketch,
                featurescript_version=featurescript_version,
                standard_library=standard_library,
                standard_library_version=standard_library_version,
            )
            if direct_axis is not None:
                origin, axis = direct_axis
                signed_angle = _number(params.get("angle", 0.0))
                if _bool(params.get("oppositeDirection")):
                    signed_angle = -signed_angle
                base_normal = _featurescript_perpendicular_vector(axis)
                normal = _rotate(base_normal, axis, math.radians(signed_angle))
                return _frame(origin, axis, normal)
        if len(entities) == 2:
            direct_plane = _direct_line_angle_two_entity_plane(
                entities, params, feature_frames, sketch_by_source, entity_by_sketch,
                previous=previous,
                featurescript_version=featurescript_version,
                standard_library=standard_library,
                standard_library_version=standard_library_version,
            )
            if direct_plane is not None:
                return direct_plane
        # The retained compatibility path is specifically a cylinder
        # generatrix contract. Do not use it as a generic derived-topology
        # fallback: a CAP/SWEPT line or a query combinator has different
        # FeatureScript provenance and needs its own source proof.
        candidates = [
            item for item in entities
            if _derived_line_angle_cylinder_axis(
                item, feature_frames, sketch_by_source, entity_by_sketch,
            ) is not None
        ]
        if len(entities) != 2 or len(candidates) != 1:
            raise ValueError("line-angle reference selection is unsupported")
        line_query = candidates[0]
        base_query = next(item for item in entities if item is not line_query)
        base = _direct_line_angle_reference_plane(base_query, feature_frames)
        if base is None:
            raise ValueError("line-angle cylinder reference plane is unsupported")
        start, end = _query_line(line_query, feature_frames, sketch_by_source, entity_by_sketch)
        axis = _sub(end, start); angle = -_number(params.get("angle", 0.0))
        opposite = _bool(params.get("oppositeDirection"))
        normal = _rotate(base["normal"], axis, math.radians(angle))
        x_dir = _rotate(base["x_dir"], axis, math.radians(angle))
        entity, _plane, _token = _derived_line_angle_cylinder_axis(
            line_query, feature_frames, sketch_by_source, entity_by_sketch,
        ) or (None, None, None)
        if entity is None:  # Kept for type narrowing; the candidate was checked above.
            raise ValueError("line-angle reference selection is unsupported")
        # 圆柱面/端盖圆边用于 LINE_ANGLE 时，FeatureScript 取圆柱面上的
        # 母线作为旋转轴，而不是圆心处的中心轴。将该轴移到旋转后的面
        # 法向所指的圆柱半径位置，才能保持后续草图和端面引用的位置。
        axis_direction = _unit(axis, "line-angle reference line is degenerate")
        radial = _sub(normal, [axis_direction[index] * _dot(normal, axis_direction) for index in range(3)])
        start = [start[index] + _unit(radial, "line-angle cylinder radial direction is degenerate")[index] * entity["radius_mm"] for index in range(3)]
        return _frame(start, x_dir, normal)
    if plane_type == "PLANE_POINT":
        # A PLANE_POINT definition is typed source data: one FACE plane and
        # one VERTEX point.  Do not infer their roles from qCreatedBy text;
        # a direct CAP_FACE is equally a valid plane query and must retain
        # that source topology rather than falling back to a runtime face.
        face_queries = [
            item for item in entities
            if (parse_query(item).kind or "").lower() in {"face", "entitytype.face"}
        ]
        point_queries = [
            item for item in entities
            if (parse_query(item).kind or "").lower() in {"vertex", "entitytype.vertex"}
        ]
        if len(entities) != 2 or len(face_queries) != 1 or len(point_queries) != 1:
            raise ValueError("plane-point requires exactly one face and one vertex")
        base_query, point_query = face_queries[0], point_queries[0]
        base = _query_plane(base_query, feature_frames, sketch_by_source, entity_by_sketch)
        return _frame(datum_point(point_query), base["x_dir"], base["normal"])
    if plane_type == "CURVE_POINT":
        point_query = next((item for item in entities if parse_query(item).kind and "vertex" in parse_query(item).kind), None)
        curve_query = next((item for item in entities if item is not point_query), None)
        if point_query is None or curve_query is None: raise ValueError("curve-point references are unresolved")
        point = _query_point(point_query, feature_frames, sketch_by_source, entity_by_sketch)
        curve, source_plane, _ = _entity_from_query(curve_query, sketch_by_source, entity_by_sketch)
        if curve.get("type") == "line":
            start, end = _query_line(curve_query, feature_frames, sketch_by_source, entity_by_sketch)
            tangent = _sub(end, start)
        else:
            source_plane, tangent = _curve_point_tangent(
                curve_query, point_query, point, sketch_by_source, entity_by_sketch,
            )
        return _frame(point, source_plane["normal"], tangent)
    if plane_type == "THREE_POINT":
        if len(entities) != 3: raise ValueError("three-point plane requires exactly three points")
        first, second, third = [datum_point(item) for item in entities]
        normal = _cross(_sub(second, first), _sub(third, first))
        if _bool(params.get("oppositeDirection")): normal = [-value for value in normal]
        return _frame(first, _sub(second, first), normal)
    if plane_type == "LINE_POINT":
        line_query = next((item for item in entities if "edge" in (parse_query(item).kind or "")), None)
        point_query = next((item for item in entities if item is not line_query), None)
        if line_query is None or point_query is None: raise ValueError("line-point references are unresolved")
        # FeatureScript 的 LINE_POINT 平面经过指定点，法向与参考线平行。
        # 点可以是线端点；它不是用来和直线共同定义平面的第三个方向。
        _, source_plane, _ = _entity_from_query(line_query, sketch_by_source, entity_by_sketch)
        start, end = _query_line(line_query, feature_frames, sketch_by_source, entity_by_sketch)
        point = _query_point(point_query, feature_frames, sketch_by_source, entity_by_sketch)
        normal = _sub(end, start)
        if _bool(params.get("oppositeDirection")): normal = [-value for value in normal]
        return _frame(point, _cross(source_plane["normal"], normal), normal)
    if plane_type == "MID_PLANE":
        if len(entities) != 2: raise ValueError("mid-plane requires exactly two reference planes")
        first, second = [_query_plane(item, feature_frames, sketch_by_source, entity_by_sketch) for item in entities]
        first_normal = _unit(first["normal"], "first mid-plane normal is degenerate")
        second_normal = _unit(second["normal"], "second mid-plane normal is degenerate")
        intersection = _cross(first_normal, second_normal)
        intersection_length_squared = _dot(intersection, intersection)
        if intersection_length_squared <= 1e-12:
            alignment = 1.0 if _dot(first_normal, second_normal) >= 0 else -1.0
            offset = _dot(_sub(second["origin_mm"], first["origin_mm"]), first_normal) * alignment
            return _shift_plane(first, offset / 2.0)
        # 两个相交面没有“中点偏移面”。CADFS 的 MID_PLANE 是两面形成的
        # 二面角平分面：先令两个法向同向，再取其和作为平分面的法向；平面
        # 经过两原平面的交线。此处的 local x 轴由交线推导，后续草图的
        # (u, v) 坐标不依赖任意选择的输入 face frame。
        if _dot(first_normal, second_normal) < 0:
            second_normal = [-value for value in second_normal]
        # 法向翻转也会反转两平面的交线方向。交点公式中的交线必须与已
        # 对齐的法向保持同一方向，否则会将原点映射到交线的对称位置。
        intersection = _cross(first_normal, second_normal)
        normal = _unit([first_normal[index] + second_normal[index] for index in range(3)], "mid-plane angle bisector is degenerate")
        first_offset = _dot(first_normal, first["origin_mm"])
        second_offset = _dot(second_normal, second["origin_mm"])
        first_term = _cross(second_normal, intersection)
        second_term = _cross(intersection, first_normal)
        origin = [
            (first_offset * first_term[index] + second_offset * second_term[index]) / intersection_length_squared
            for index in range(3)
        ]
        return _frame(origin, _cross(normal, intersection), normal)
    raise UnsupportedCapability(f"reference_plane:{plane_type.lower()}", f"current converter has no exact {plane_type} reference plane")


def _mirror_plane_from_query(
    value: Any,
    feature_frames: dict[str, dict[str, Any]],
    sketch_by_source: dict[str, dict[str, Any]],
    entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
    feature_by_id: dict[str, dict[str, Any]],
    sketches_by_id: dict[str, dict[str, Any]],
    previous: list[str],
    mirror_source_ids: list[str],
    featurescript_version: str | None,
) -> dict[str, Any] | None:
    """Materialize the bounded planar mirror-face source into a CDSL frame.

    A full solid revolve turns a source line perpendicular to its axis into a
    planar annular face. A direct independent blind prism similarly has a
    physical cap or one source-line side plane while it is still the immediate
    mirror source. Those faces can materialize a CDSL datum plane without
    resolving a runtime topology selector. Curved, partial, derived, mutated,
    or unrelated faces remain unresolved instead of becoming guessed planes.
    """
    plane = _default_plane(value)
    if plane is not None:
        return plane
    try:
        _call, owner, topology, kind, _definition = _direct_make_query(value)
    except ValueError:
        return None
    if kind not in {"face", "entitytype.face"}:
        return None
    producer_id = f"f_{owner}"
    producer = feature_by_id.get(producer_id) or {}
    frame = feature_frames.get(owner) or {}

    if topology == "SWEPT_FACE" and (
        producer.get("atomic_id") == "revolve_add"
        and frame.get("revolve_full")
        and isinstance(frame.get("revolve_axis"), dict)
    ):
        try:
            return _query_plane(value, feature_frames, sketch_by_source, entity_by_sketch)
        except (UnsupportedCapability, ValueError):
            return None

    # A CAP/SWEPT source can only be a static mirror datum while its physical
    # direct-prism boundary is current and the mirror is operating on that
    # same independently selectable body. Do not reuse a frame after a
    # dress-up, Boolean, copy, or any other lifecycle transition.
    params = producer.get("params") or {}
    if (
        featurescript_version != "1511"
        or topology not in {"CAP_FACE", "SWEPT_FACE"}
        or producer_id not in mirror_source_ids
        or previous[-1:] != [producer_id]
        or producer.get("atomic_id") != "extrude_add_blind"
        or params.get("result_mode") != "new_body"
        or (params.get("end_condition") or {}).get("type") != "blind"
        or params.get("draft") is not None
    ):
        return None
    try:
        if topology == "CAP_FACE":
            if _cap_face_output_role_selector(value, feature_by_id, sketches_by_id) is None:
                return None
        elif _direct_prism_swept_selector(
            value,
            owner=owner,
            selector_kind="face",
            feature_by_id=feature_by_id,
            feature_frames=feature_frames,
            sketch_by_source=sketch_by_source,
            sketches_by_id=sketches_by_id,
            entity_by_sketch=entity_by_sketch,
            previous=previous,
            featurescript_version=featurescript_version,
        ) is None:
            return None
        return _query_plane(value, feature_frames, sketch_by_source, entity_by_sketch)
    except (UnsupportedCapability, ValueError):
        return None


def lower_model(model: ModelIR, provenance: dict[str, Any]) -> LoweringResult:
    diagnostics: list[dict[str, Any]] = []; history = []
    sketches: list[dict[str, Any]] = []; sketches_by_id: dict[str, dict[str, Any]] = {}; sketch_by_source: dict[str, dict[str, Any]] = {}; entity_by_sketch: dict[str, dict[str, dict[str, Any]]] = {}
    feature_frames: dict[str, dict[str, Any]] = {}; source_variables: dict[str, Any] = {}; surface_profiles: list[dict[str, Any]] = []; swept_face_sketches: set[str] = set()
    features: list[dict[str, Any]] = []; complete = True; previous: list[str] = []
    feature_by_id: dict[str, dict[str, Any]] = {}; feature_source_by_id: dict[str, str] = {}
    sketch_workplanes = {step.feature_id: step.workplane for step in model.sketches}
    # Original CADFS operation owners can remain the query anchor after an
    # explicit non-copy body transform. Map only those proven transform
    # successors; all other body lifecycle transitions remain unaliased.
    body_transform_aliases: dict[str, str] = {}
    # This is the lowering-side mirror of runtime ``body_members``. It makes
    # a source-qualified shell.parts target possible only while that source is
    # still one explicit selectable body member.
    lowered_body_members: set[str] = set()
    # A direct SWEPT_BODY query can continue to name the sole CADFS body after
    # ordinary additive and dress-up successors. This state is deliberately
    # cleared before any aggregate, multi-member, or otherwise ambiguous body
    # transition can make that continuation non-unique.
    single_body_successor_state: dict[str, Any] = {"owner": None, "sources": set()}
    for step in model.steps:
        if isinstance(step, SketchIR):
            history.append({"feature_id": step.feature_id, "operation": "newSketch", "parameters": {"sketchPlane": plain(step.workplane)}, "entities": [{"entity_id": e.feature_id, "operation": e.operation, "parameters": plain(e.params)} for e in step.entities]})
            try:
                attachment = _direct_prism_cap_face_attachment(
                    step.workplane,
                    feature_by_id=feature_by_id,
                    sketches_by_id=sketches_by_id,
                    previous=previous,
                    featurescript_version=model.featurescript_version,
                )
                if attachment is not None:
                    # CAP faces are native builder results. The exact plane is
                    # resolved only when the consuming feature executes.
                    lowered, entities = _lower_sketch(step, PLANES["Top"])
                    lowered["attachment"] = attachment
                    sketches.append(lowered); sketches_by_id[lowered["id"]] = lowered; sketch_by_source[step.feature_id] = lowered; entity_by_sketch[step.feature_id] = entities
                    continue
                attachment = _direct_primary_cut_copy_cap_face_attachment(
                    step.workplane,
                    feature_by_id=feature_by_id,
                    feature_frames=feature_frames,
                    sketch_by_source=sketch_by_source,
                    sketches_by_id=sketches_by_id,
                    entity_by_sketch=entity_by_sketch,
                    previous=previous,
                    featurescript_version=model.featurescript_version,
                )
                if attachment is not None:
                    # This placeholder must never be consumed: attached
                    # sketches remain local through preflight and are
                    # materialized from the exact active face at execution.
                    lowered, entities = _lower_sketch(step, PLANES["Top"])
                    lowered["attachment"] = attachment
                    sketches.append(lowered); sketches_by_id[lowered["id"]] = lowered; sketch_by_source[step.feature_id] = lowered; entity_by_sketch[step.feature_id] = entities
                    continue
                attachment = _direct_primary_cut_copy_swept_face_attachment(
                    step.workplane,
                    feature_by_id=feature_by_id,
                    feature_frames=feature_frames,
                    sketch_by_source=sketch_by_source,
                    sketches_by_id=sketches_by_id,
                    entity_by_sketch=entity_by_sketch,
                    previous=previous,
                    featurescript_version=model.featurescript_version,
                )
                if attachment is not None:
                    # The swept tool face has no static source frame.  It is
                    # resolved through the native prism and subtract history
                    # only when the immediate consumer executes.
                    lowered, entities = _lower_sketch(step, PLANES["Top"])
                    lowered["attachment"] = attachment
                    sketches.append(lowered); sketches_by_id[lowered["id"]] = lowered; sketch_by_source[step.feature_id] = lowered; entity_by_sketch[step.feature_id] = entities
                    continue
                attachment = _direct_prism_blend_face_attachment(
                    step.workplane,
                    feature_by_id=feature_by_id,
                    feature_frames=feature_frames,
                    sketch_by_source=sketch_by_source,
                    sketches_by_id=sketches_by_id,
                    entity_by_sketch=entity_by_sketch,
                    previous=previous,
                    featurescript_version=model.featurescript_version,
                )
                if attachment is not None:
                    # BLEND_FACE is a dress-up patch. Its physical plane and
                    # native orientation are available only from the exact
                    # runtime ``Generated(edge -> face)`` relation.
                    lowered, entities = _lower_sketch(step, PLANES["Top"])
                    lowered["attachment"] = attachment
                    sketches.append(lowered); sketches_by_id[lowered["id"]] = lowered; sketch_by_source[step.feature_id] = lowered; entity_by_sketch[step.feature_id] = entities
                    continue
                # The outer query, rather than recursively parsed diagnostics,
                # determines whether a static SWEPT_FACE frame is admissible.
                # In particular MERGE(FACE) often contains SWEPT_FACE inputs
                # but is a distinct result that must be resolved at runtime.
                try:
                    _outer, _owner, outer_topology, _outer_kind, _definition = _direct_make_query(step.workplane)
                except ValueError:
                    outer_topology = None
                swept_face = outer_topology == "SWEPT_FACE"
                plane = _query_plane(step.workplane, feature_frames, sketch_by_source, entity_by_sketch) if swept_face else _plane_from_query(step.workplane, feature_frames, sketch_by_source, entity_by_sketch)
                profile = _revolve_swept_face_profile(step.workplane, plane, feature_frames, sketch_by_source, entity_by_sketch) if swept_face and not step.entities else None
                if profile is None: lowered, entities = _lower_sketch(step, plane)
                else:
                    lowered, entities = {"id": f"sketch_{step.feature_id}", "name": step.feature_id, "workplane": plane, "profile": profile}, {}
                    swept_face_sketches.add(step.feature_id)
                sketches.append(lowered); sketches_by_id[lowered["id"]] = lowered; sketch_by_source[step.feature_id] = lowered; entity_by_sketch[step.feature_id] = entities
            except Exception as exc:
                # 开放草图不能作为实体 profile，但其几何仍可能是后续基准面、
                # 阵列轴或旋转轴的精确引用。保留为 reference 草图，后续实体
                # 特征仍由 _profile_executable 明确拒绝，不能静默把开放轮廓实体化。
                try:
                    plane = _query_plane(step.workplane, feature_frames, sketch_by_source, entity_by_sketch) if swept_face else _plane_from_query(step.workplane, feature_frames, sketch_by_source, entity_by_sketch)
                    lowered, entities = _lower_sketch(step, plane, allow_open=True)
                    sketches.append(lowered); sketches_by_id[lowered["id"]] = lowered; sketch_by_source[step.feature_id] = lowered; entity_by_sketch[step.feature_id] = entities
                    if isinstance(exc, OpenSketchProfileError): continue
                except Exception:
                    pass
                diagnostics.append({"code": "sketch_deferred", "feature_id": step.feature_id, "message": str(exc)}); complete = False
            continue
        item = step
        history.append({"feature_id": item.feature_id, "operation": item.operation, "source_span": {"line_start": item.line_start, "line_end": item.line_end or item.line_start}, "parameters": plain(item.params), "raw_source": item.raw_source})
        if item.operation in UNSUPPORTED or item.operation not in LOWERABLE_OPERATIONS:
            diagnostics.append({"code": "unsupported_operation", "feature_id": item.feature_id, "operation": item.operation}); complete = False; continue
        try:
            fid = f"f_{item.feature_id}"; depends = list(previous[-1:]); p = _resolve_source_variables(item.params, source_variables); feature: dict[str, Any]
            if item.operation == "assignVariable":
                variable_name, source_value, variable_params = _assign_variable_params(p)
                if variable_name in source_variables:
                    raise UnsupportedCapability(
                        "assign_variable_redeclaration",
                        f"assignVariable redeclares source variable {variable_name}",
                    )
                source_variables[variable_name] = deepcopy(source_value)
                feature = {
                    "id": fid,
                    "name": item.feature_id,
                    "atomic_id": "assign_variable",
                    "depends_on": depends,
                    "params": variable_params,
                    "execution_status": "supported",
                }
            elif item.operation == "transform":
                # 单一直接 source 可以烘焙回原始几何。多 body 与 COPY instance
                # 必须保留为显式 body graph transform，不能移动聚合主体。
                sources, pattern_instance_refs, transform_copy_refs = _transform_body_references(
                    p.get("entities"), previous, feature_by_id, body_transform_aliases,
                )
                transform_type = str(p.get("transformType") or "").split(".")[-1].upper()
                identity_copy = transform_type == "COPY"
                # Uniform scaling changes the B-rep's dimensions. It cannot be
                # baked into a source sketch without also transforming every
                # dependent parameter and topology frame, so retain it as an
                # explicit body-graph operation even for one direct source.
                source_for_bake = sources[0] if len(sources) == 1 else None
                source_feature_for_bake = feature_by_id.get(source_for_bake or "")
                if (
                    transform_type not in {"SCALE_UNIFORMLY", "COPY"}
                    and not _bool(p.get("makeCopy"))
                    and len(sources) == 1
                    and not pattern_instance_refs
                    # Baking mutates an already emitted source sketch and its
                    # lowering-only frames. It is therefore equivalent to a
                    # transform only for the immediately preceding,
                    # independent NEW member. A boolean, dress-up, later add,
                    # or even a reference feature can retain geometry from the
                    # pre-transform source; changing that source retroactively
                    # would invert CADFS history order.
                    and (
                        # _bake_transform has a stronger lifecycle diagnostic
                        # for TRANSLATION_ENTITY. Let it run even when the
                        # source was absorbed so that this unrepresentable
                        # body move is rejected rather than silently lowered
                        # as an explicit transform of a successor member.
                        transform_type == "TRANSLATION_ENTITY"
                        or (
                            # A later transform may retain the original CADFS
                            # owner while the physical member is an earlier
                            # transform's successor. Baking it into the
                            # original sketch would discard the first move.
                            sources == _transform_source_features(p.get("entities"), previous)
                            and
                            previous[-1:] == sources
                            and (source_feature_for_bake or {}).get("params", {}).get("result_mode") == "new_body"
                        )
                    )
                ):
                    _bake_transform(p, previous, feature_by_id, feature_source_by_id, sketches_by_id, feature_frames, sketch_by_source, entity_by_sketch)
                    continue
                missing = [source for source in sources if source not in feature_by_id]
                if missing:
                    raise ValueError("transform source bodies are unresolved: " + ", ".join(missing))
                pattern_dependencies = [reference["pattern_feature_id"] for reference in pattern_instance_refs]
                transform_copy_dependencies = [reference["transform_feature_id"] for reference in transform_copy_refs]
                transform_params: dict[str, Any] = {
                    "transform": _body_transform(
                        p, feature_frames, sketch_by_source, entity_by_sketch, feature_by_id, previous,
                    ),
                    "make_copy": identity_copy or _bool(p.get("makeCopy")),
                }
                if sources:
                    transform_params["source_feature_ids"] = sources
                if pattern_instance_refs:
                    transform_params["pattern_instance_refs"] = pattern_instance_refs
                if transform_copy_refs:
                    transform_params["transform_copy_refs"] = transform_copy_refs
                source_member_aliases = _transform_source_member_aliases(p.get("entities"), sources)
                if source_member_aliases:
                    transform_params["source_member_aliases"] = source_member_aliases
                feature = {
                    "id": fid,
                    "name": item.feature_id,
                    "atomic_id": "transform_bodies",
                    "depends_on": list(dict.fromkeys(sources + pattern_dependencies + transform_copy_dependencies + depends)),
                    "params": transform_params,
                    "execution_status": "supported",
                }
            elif item.operation == "deleteBodies":
                queries = _queries(p.get("entities"))
                if not queries:
                    raise ValueError("deleteBodies selection is empty")
                targets = []
                for query in queries:
                    _call, owner, topology, kind, _definition = _direct_make_query(query)
                    pattern_id = f"f_{owner}"
                    pattern = feature_by_id.get(pattern_id)
                    if topology != "COPY" or kind not in {"body", "entitytype.body"} or pattern is None or pattern.get("atomic_id") != "pattern_circular":
                        target = _delete_body_source(query)
                        if target not in targets:
                            targets.append(target)
                        continue
                    pattern_id, source_id, instance = _pattern_copy_body(query)
                    params = pattern["params"]
                    if source_id not in params.get("source_feature_ids", []):
                        raise ValueError("pattern copy deletion source is not replayed by its owner")
                    count = int(params.get("pattern_count") or 0)
                    if instance < 1 or instance >= count:
                        raise ValueError("pattern copy deletion instance is outside the generated range")
                    excluded = params.setdefault("excluded_instance_indices", [])
                    if instance not in excluded:
                        excluded.append(instance)
                if not targets:
                    continue
                missing = [target for target in targets if target not in feature_by_id]
                if missing:
                    raise ValueError("deleteBodies source bodies are unresolved: " + ", ".join(missing))
                feature = {
                    "id": fid,
                    "name": item.feature_id,
                    "atomic_id": "delete_bodies",
                    "depends_on": list(dict.fromkeys(targets + depends)),
                    "params": {"target_feature_ids": targets},
                    "execution_status": "supported",
                }
            elif item.operation == "cPoint":
                point = _cpoint_datum(
                    p,
                    feature_by_id=feature_by_id,
                    feature_frames=feature_frames,
                    sketch_by_source=sketch_by_source,
                    sketches_by_id=sketches_by_id,
                    entity_by_sketch=entity_by_sketch,
                    previous=previous,
                    featurescript_version=model.featurescript_version,
                )
                feature_frames[item.feature_id] = {"point_mm": point}
                feature = {
                    "id": fid,
                    "name": item.feature_id,
                    "atomic_id": "reference_point",
                    "depends_on": depends,
                    "params": {"point_mm": point},
                    "execution_status": "supported",
                }
            elif item.operation == "cPlane":
                plane = _cplane(
                    p, feature_frames, sketch_by_source, entity_by_sketch,
                    feature_by_id=feature_by_id,
                    sketches_by_id=sketches_by_id,
                    previous=previous,
                    featurescript_version=model.featurescript_version,
                    standard_library=model.standard_library,
                    standard_library_version=model.standard_library_version,
                )
                feature = {"id": fid, "name": item.feature_id, "atomic_id": "reference_plane", "depends_on": depends, "params": {"plane": plane}, "execution_status": "supported"}
                attachment = _attachment_plane(plane)
                feature_frames[item.feature_id] = {
                    "start": plane,
                    "end": plane,
                    "start_attachment": attachment,
                    "end_attachment": attachment,
                }
            elif item.operation == "extrude":
                surface_profile_sketch = None
                pure_surface_operation = (
                    str(p.get("bodyType") or "").rsplit(".", 1)[-1].upper() == "SURFACE"
                )
                if pure_surface_operation:
                    if p.get("surfaceOperationType") is not None:
                        raise UnsupportedCapability(
                            "extrude_surface_operation",
                            "pure ToolBodyType.SURFACE extrusion cannot also declare a surface operation",
                        )
                    surface_body_operation = str(p.get("operationType") or "").rsplit(".", 1)[-1].upper()
                    if surface_body_operation not in {"", "ADD", "NEW"}:
                        raise UnsupportedCapability(
                            "extrude_surface_operation",
                            "pure ToolBodyType.SURFACE extrusion supports only an independent ADD surface operation",
                        )
                    surface_source = _source_sketch({"surfaceEntities": p.get("surfaceEntities")})
                    if not surface_source or surface_source not in sketch_by_source:
                        raise ValueError("surface extrude sketch query is unresolved")
                    surface_profile_sketch = _surface_profile_selection_sketch(
                        sketch_by_source[surface_source], p.get("surfaceEntities"),
                        entity_by_sketch[surface_source], fid, allow_open_wire=True,
                    )
                    sketches.append(surface_profile_sketch); sketches_by_id[surface_profile_sketch["id"]] = surface_profile_sketch
                if p.get("surfaceOperationType") is not None:
                    surface_operation = str(p.get("surfaceOperationType") or "").rsplit(".", 1)[-1].upper()
                    if surface_operation != "ADD":
                        raise UnsupportedCapability("extrude_surface_operation", "current CDSL surface extrude supports only NewSurfaceOperationType.ADD")
                    surface_source = _source_sketch({"surfaceEntities": p.get("surfaceEntities")})
                    if not surface_source or surface_source not in sketch_by_source:
                        raise ValueError("surface extrude sketch query is unresolved")
                    surface_profile_sketch = _surface_profile_selection_sketch(
                        sketch_by_source[surface_source], p.get("surfaceEntities"), entity_by_sketch[surface_source], fid,
                    )
                    sketches.append(surface_profile_sketch); sketches_by_id[surface_profile_sketch["id"]] = surface_profile_sketch
                profile_value = (
                    p.get("surfaceEntities") if pure_surface_operation
                    else _sketch_region_query(p.get("entities")) or p.get("entities")
                )
                profile_operation = str(p.get("operationType") or "NEW").upper()
                profile_kind = parse_query(profile_value).topology_type
                multi_source_region_profile = (
                    _multi_source_sketch_region_profile(p.get("entities"), sketch_by_source, fid)
                    if not pure_surface_operation else None
                )
                if (
                    not pure_surface_operation
                    and multi_source_region_profile is None
                    and _has_composed_sketch_region_union(p.get("entities"))
                ):
                    raise UnsupportedCapability(
                        "extrude_multi_source_sketch_region",
                        "extrude qSketchRegion union requires direct executable source profiles on one identical unattached frame",
                    )
                source = (
                    None if multi_source_region_profile is not None
                    else parse_query(profile_value).source_sketch or _source_sketch(p)
                )
                imprint = _imprint_sketch(profile_value)
                cap_face_output_selector = _cap_face_output_role_selector(
                    profile_value, feature_by_id, sketches_by_id,
                )
                retained_offset_cap_selector = _shell_retained_direct_prism_cap_offset_face_profile_selector(
                    profile_value, feature_by_id, sketches_by_id, previous,
                    featurescript_version=model.featurescript_version,
                ) if profile_kind == "OFFSET_FACE" else None
                cap_edge_hole = _cap_edge_hole_profile_sketch(
                    profile_value, sketch_by_source, entity_by_sketch, feature_frames, fid,
                )
                cap_edge_union_profile = _cap_edge_union_profile_sketch(
                    profile_value, sketch_by_source, entity_by_sketch, fid,
                )
                # First let the established profile materializer handle
                # single-region, circle and open-IMPRINT contracts. A
                # multi-face IMPRINT query reaches the arrangement path only
                # when that materializer cannot reduce the source sketch.
                materialized_imprint = (
                    _profile_selection_sketch(
                        sketch_by_source[source], profile_value, entity_by_sketch[source], fid,
                    )
                    if profile_kind == "IMPRINT" and source in sketch_by_source
                    else None
                )
                # ``parse_query`` retains nested-query information and its
                # last nested makeQuery can be a CAP_EDGE/INTERSECT leaf.
                # Only the external-boundary form needs direct qUnion-root
                # inspection here; ordinary single IMPRINT profiles keep
                # their established materialization path.
                planar_imprint_selections = [
                    selection
                    for root in _queries(profile_value)
                    if (selection := _planar_imprint_selection(root)) is not None
                ]
                has_external_planar_imprint_root = any(
                    isinstance((selection[1].get("fragment") or {}).get("_external_anchor_query"), Call)
                    for selection in planar_imprint_selections
                )
                planar_imprint_profile = _planar_imprint_profile_sketch(
                    profile_value,
                    sketch_by_source,
                    entity_by_sketch,
                    fid,
                    feature_by_id=feature_by_id,
                    feature_frames=feature_frames,
                    sketches_by_id=sketches_by_id,
                    previous=previous,
                    featurescript_version=model.featurescript_version,
                ) if (
                    profile_kind == "INTERSECT"
                    or (
                        has_external_planar_imprint_root
                        and _is_new_body_operation(profile_operation)
                    )
                    or (
                        profile_kind == "IMPRINT"
                        and len(_queries(profile_value)) > 1
                        and isinstance(source, str)
                        and materialized_imprint is sketch_by_source.get(source)
                    )
                ) else None
                intersect_profile_sketch = _intersect_partition_profile_sketch(
                    profile_value, sketch_by_source, entity_by_sketch, fid,
                ) if profile_kind == "INTERSECT" and planar_imprint_profile is None else None
                offset_face_profile = _offset_face_profile_sketch(
                    profile_value, feature_frames, sketches_by_id, sketch_by_source, entity_by_sketch, feature_by_id, fid,
                ) if profile_kind == "OFFSET_FACE" else None
                profile_sketch: dict[str, Any] | None = None
                if cap_face_output_selector is not None or retained_offset_cap_selector is not None:
                    # Keep the B-rep face as a runtime-derived profile.  It
                    # must not be reconstructed from the original sketch.
                    pass
                elif multi_source_region_profile is not None:
                    profile_sketch = multi_source_region_profile
                    sketches.append(profile_sketch); sketches_by_id[profile_sketch["id"]] = profile_sketch
                elif cap_edge_hole is not None:
                    profile_sketch, hole_selector = cap_edge_hole
                    if profile_sketch["id"] not in sketches_by_id:
                        sketches.append(profile_sketch); sketches_by_id[profile_sketch["id"]] = profile_sketch
                elif cap_edge_union_profile is not None:
                    profile_sketch = cap_edge_union_profile
                    if profile_sketch["id"] not in sketches_by_id:
                        sketches.append(profile_sketch); sketches_by_id[profile_sketch["id"]] = profile_sketch
                elif profile_kind == "SWEPT_EDGE" and imprint in swept_face_sketches: source = imprint
                elif planar_imprint_profile is not None:
                    profile_sketch = planar_imprint_profile
                    sketches.append(profile_sketch); sketches_by_id[profile_sketch["id"]] = profile_sketch
                elif intersect_profile_sketch is not None:
                    profile_sketch = intersect_profile_sketch
                    sketches.append(profile_sketch); sketches_by_id[profile_sketch["id"]] = profile_sketch
                elif offset_face_profile is not None:
                    profile_sketch = offset_face_profile
                    sketches.append(profile_sketch); sketches_by_id[profile_sketch["id"]] = profile_sketch
                elif pure_surface_operation:
                    profile_sketch = surface_profile_sketch
                elif profile_kind not in {None, "IMPRINT"}:
                    partitioned = _partitioned_imprint_sketch(p.get("entities"), entity_by_sketch)
                    if partitioned is not None:
                        source = partitioned; profile_kind = "IMPRINT"
                    else:
                        raise UnsupportedCapability(f"extrude_profile_topology:{profile_kind.lower()}", f"current CDSL engine cannot exactly replay an extrude profile selected from {profile_kind}")
                if (
                    not pure_surface_operation
                    and cap_face_output_selector is None
                    and retained_offset_cap_selector is None
                    and multi_source_region_profile is None
                    and cap_edge_hole is None
                    and cap_edge_union_profile is None
                    and planar_imprint_profile is None
                    and intersect_profile_sketch is None
                    and offset_face_profile is None
                ):
                    if not source or source not in sketch_by_source: raise ValueError("extrude sketch query is unresolved")
                    open_profile_sketch = _open_imprint_profile_sketch(sketch_by_source[source], profile_value, fid)
                    profile_sketch = open_profile_sketch or _profile_selection_sketch(sketch_by_source[source], profile_value, entity_by_sketch[source], fid)
                    if profile_sketch is not sketch_by_source[source]: sketches.append(profile_sketch); sketches_by_id[profile_sketch["id"]] = profile_sketch
                operation = profile_operation
                cutting = any(x in operation for x in ("REMOVE", "CUT"))
                if cutting and profile_kind == "IMPRINT" and profile_sketch is not None:
                    trimmed_profile_sketch = _surface_trimmed_imprint_profile(profile_sketch, surface_profile_sketch, surface_profiles)
                    if trimmed_profile_sketch is not profile_sketch:
                        for index, sketch in enumerate(sketches):
                            if sketch is profile_sketch:
                                sketches[index] = trimmed_profile_sketch; break
                        sketches_by_id[trimmed_profile_sketch["id"]] = trimmed_profile_sketch
                        profile_sketch = trimmed_profile_sketch
                if (
                    profile_sketch is not None
                    and not pure_surface_operation
                    and not _profile_executable(profile_sketch)
                ):
                    raise ValueError("extrude sketch has no closed profile")
                second = _bool(p.get("hasSecondDirection"))
                end = _end_condition("SYMMETRIC" if _bool(p.get("symmetric")) else p.get("endBound"))
                if end["type"] == "up_to_body":
                    end["reference"] = _extent_reference(
                        p.get("endBoundEntityBody"), "body", feature_frames, sketch_by_source, entity_by_sketch,
                        feature_by_id=feature_by_id, sketches_by_id=sketches_by_id, previous=previous,
                        featurescript_version=model.featurescript_version,
                    )
                elif end["type"] == "up_to_surface":
                    # A two-sided face extent is one paired provenance
                    # request. Defer resolving either side until the reverse
                    # query is available below, where the exact CAP/SWEPT
                    # pair contracts can prove both members together.
                    if not second:
                        end["reference"] = _extent_reference(
                            p.get("endBoundEntityFace"), "face", feature_frames, sketch_by_source, entity_by_sketch,
                            feature_by_id=feature_by_id, sketches_by_id=sketches_by_id, previous=previous,
                            allow_cap_output_role=True,
                            allow_primary_add_up_to_surface=True,
                            allow_direct_prism_swept_lineage=True,
                            featurescript_version=model.featurescript_version,
                        )
                elif end["type"] == "up_to_vertex":
                    end["reference"] = (
                        _direct_source_vertex_extent_reference(
                            p.get("endBoundEntityVertex"), sketch_by_source, entity_by_sketch,
                            featurescript_version=model.featurescript_version,
                        )
                        or _direct_prism_cap_vertex_extent_selector(
                            p.get("endBoundEntityVertex"), feature_by_id=feature_by_id,
                            feature_frames=feature_frames, sketch_by_source=sketch_by_source,
                            sketches_by_id=sketches_by_id, entity_by_sketch=entity_by_sketch,
                            previous=previous, featurescript_version=model.featurescript_version,
                        )
                        or _intersection_vertex_reference(
                            p.get("endBoundEntityVertex"), feature_frames, sketch_by_source, entity_by_sketch, feature_by_id, item.feature_id,
                        )
                    )
                if _bool(p.get("hasOffset")):
                    offset = _number(p.get("offsetDistance"), True)
                    if offset < 0: raise ValueError("extrude extent offset must be non-negative")
                    end["offset_mm"] = offset
                depth_value = p.get("depth"); depth = _number(depth_value, True) if depth_value is not None else 1.0
                # FeatureScript 的 operationType 缺省为 NEW。source 若要把结果
                # 并入既有主体会显式给出 ADD；不能根据当前 CDSL history 猜成 ADD，
                # 否则会把应保留的独立 body 在转换时丢失。
                reverse = _bool(p.get("oppositeDirection")); cutting = any(x in operation for x in ("REMOVE", "CUT"))
                if cutting and not second and end["type"] not in {"blind", "mid_plane", "through_all", "through_next", "up_to_surface", "up_to_vertex", "up_to_body"}:
                    capability = f"extrude_cut_{end['type']}"
                    raise UnsupportedCapability(capability, f"current CDSL atomic set has no exact {capability} operation")
                if not cutting and not second and end["type"] not in {"blind", "mid_plane", "through_all", "through_next", "up_to_surface", "up_to_vertex", "up_to_body"}:
                    capability = f"extrude_add_{end['type']}"
                    raise UnsupportedCapability(capability, f"current CDSL atomic set has no exact {capability} operation")
                if second:
                    atomic = "extrude_cut_two_sided" if cutting else "extrude_add_two_sided"
                    params = {"distance_mm": depth, "reverse": reverse, "end_condition": end}
                    reverse_depth = _number(p.get("secondDirectionDepth", depth), True)
                    reverse_end = _end_condition(p.get("secondDirectionBound"))
                    if reverse_end["type"] == "up_to_body":
                        reverse_end["reference"] = _extent_reference(p.get("secondDirectionBoundEntityBody"), "body", feature_frames, sketch_by_source, entity_by_sketch)
                    elif reverse_end["type"] == "up_to_vertex":
                        reverse_end["reference"] = (
                            _direct_source_vertex_extent_reference(
                                p.get("secondDirectionBoundEntityVertex"), sketch_by_source, entity_by_sketch,
                                featurescript_version=model.featurescript_version,
                            )
                            or _direct_prism_cap_vertex_extent_selector(
                                p.get("secondDirectionBoundEntityVertex"), feature_by_id=feature_by_id,
                                feature_frames=feature_frames, sketch_by_source=sketch_by_source,
                                sketches_by_id=sketches_by_id, entity_by_sketch=entity_by_sketch,
                                previous=previous, featurescript_version=model.featurescript_version,
                            )
                            or _intersection_vertex_reference(
                                p.get("secondDirectionBoundEntityVertex"), feature_frames, sketch_by_source, entity_by_sketch, feature_by_id, item.feature_id,
                            )
                        )
                    params.update({"reverse_distance_mm": reverse_depth, "reverse_end_condition": reverse_end})
                    if end["type"] == "up_to_surface" and reverse_end["type"] == "up_to_surface":
                        cap_pair = _two_sided_up_to_surface_cap_pair(
                            p.get("endBoundEntityFace"), p.get("secondDirectionBoundEntityFace"),
                            feature_by_id=feature_by_id, sketches_by_id=sketches_by_id,
                            source_sketches=sketch_by_source, previous=previous,
                            featurescript_version=model.featurescript_version,
                        )
                        if cap_pair is not None:
                            end["reference"], reverse_end["reference"] = cap_pair
                        else:
                            swept_pair = _two_sided_up_to_surface_shell_swept_face_pair(
                                p.get("endBoundEntityFace"), p.get("secondDirectionBoundEntityFace"),
                                feature_by_id=feature_by_id, feature_frames=feature_frames,
                                sketch_by_source=sketch_by_source, sketches_by_id=sketches_by_id,
                                entity_by_sketch=entity_by_sketch, previous=previous,
                                featurescript_version=model.featurescript_version,
                            )
                            if swept_pair is not None:
                                end["reference"], reverse_end["reference"] = swept_pair
                            else:
                                end["reference"] = _extent_reference(
                                    p.get("endBoundEntityFace"), "face", feature_frames, sketch_by_source, entity_by_sketch,
                                    feature_by_id=feature_by_id, sketches_by_id=sketches_by_id, previous=previous,
                                    featurescript_version=model.featurescript_version,
                                )
                                reverse_end["reference"] = _extent_reference(
                                    p.get("secondDirectionBoundEntityFace"), "face", feature_frames, sketch_by_source, entity_by_sketch,
                                    feature_by_id=feature_by_id, sketches_by_id=sketches_by_id, previous=previous,
                                    featurescript_version=model.featurescript_version,
                                )
                    elif reverse_end["type"] == "up_to_surface":
                        end["reference"] = _extent_reference(
                            p.get("endBoundEntityFace"), "face", feature_frames, sketch_by_source, entity_by_sketch,
                            feature_by_id=feature_by_id, sketches_by_id=sketches_by_id, previous=previous,
                            featurescript_version=model.featurescript_version,
                        )
                        reverse_end["reference"] = _extent_reference(
                            p.get("secondDirectionBoundEntityFace"), "face", feature_frames, sketch_by_source, entity_by_sketch,
                            feature_by_id=feature_by_id, sketches_by_id=sketches_by_id, previous=previous,
                            featurescript_version=model.featurescript_version,
                        )
                elif end["type"] == "mid_plane":
                    blind = _end_condition("BLIND")
                    atomic = "extrude_cut_two_sided" if cutting else "extrude_add_two_sided"
                    params = {"distance_mm": depth / 2, "reverse_distance_mm": depth / 2, "reverse": reverse, "end_condition": blind, "reverse_end_condition": dict(blind)}
                else:
                    atomic = "extrude_cut_blind" if cutting else "extrude_add_blind"
                    params = {"distance_mm": depth, "reverse": reverse, "end_condition": end}
                if pure_surface_operation:
                    if second or end["type"] not in {"blind", "mid_plane"}:
                        raise UnsupportedCapability(
                            "extrude_surface_extent",
                            "pure ToolBodyType.SURFACE extrusion supports blind and symmetric extents only",
                        )
                if _bool(p.get("hasDraft")):
                    if second or end["type"] != "blind":
                        raise UnsupportedCapability("extrude_draft_extent", "current CDSL draft supports only one-sided blind extrusions")
                    params["draft"] = {
                        "angle_deg": _number(p.get("draftAngle")),
                        "pull_direction": _bool(p.get("draftPullDirection")),
                    }
                if cap_edge_hole is not None:
                    if cutting or second or end["type"] != "blind" or "draft" in params:
                        raise UnsupportedCapability("extrude_cap_edge_profile", "current CAP_EDGE profile extrusion supports one-sided blind additive results")
                    atomic = "extrude_add_blind_with_hole"
                if not cutting and _is_new_body_operation(operation): params["result_mode"] = "new_body"
                derived_face_selector = cap_face_output_selector or retained_offset_cap_selector
                if derived_face_selector is not None:
                    params["operation"] = "cut" if cutting else "add"
                    if second or end["type"] == "mid_plane":
                        params["two_sided"] = True
                    feature = {
                        "id": fid,
                        "name": item.feature_id,
                        "atomic_id": "extrude_from_face",
                        "depends_on": depends,
                        "params": params,
                        "selectors": [derived_face_selector],
                        "execution_status": "supported",
                    }
                else:
                    if profile_sketch is None:
                        raise ValueError("extrude profile is unresolved")
                    if pure_surface_operation:
                        surface_params = {"distance_mm": params["distance_mm"], "reverse": bool(params.get("reverse"))}
                        if "reverse_distance_mm" in params:
                            surface_params["reverse_distance_mm"] = params["reverse_distance_mm"]
                        feature = {"id": fid, "name": item.feature_id, "atomic_id": "extrude_surface", "depends_on": depends, "sketch_id": profile_sketch["id"], "params": surface_params, "execution_status": "supported"}
                    else:
                        feature = {"id": fid, "name": item.feature_id, "atomic_id": atomic, "depends_on": depends, "sketch_id": profile_sketch["id"], "params": params, "execution_status": "supported"}
                    if cap_edge_hole is not None: feature["selectors"] = [hole_selector]
                if surface_profile_sketch is not None and not pure_surface_operation:
                    if end["type"] not in {"blind", "mid_plane"}:
                        raise UnsupportedCapability("extrude_surface_extent", "current CDSL surface extrude supports blind and symmetric extents only")
                    surface_params = {"distance_mm": params["distance_mm"], "reverse": bool(params.get("reverse"))}
                    if "reverse_distance_mm" in params:
                        surface_params["reverse_distance_mm"] = params["reverse_distance_mm"]
                    surface_feature = {
                        "id": f"{fid}_surface",
                        "name": f"{item.feature_id} surface",
                        "atomic_id": "extrude_surface",
                        "depends_on": [fid],
                        "sketch_id": surface_profile_sketch["id"],
                        "params": surface_params,
                        "execution_status": "supported",
                    }
                plane = _query_plane(profile_value, feature_frames, sketch_by_source, entity_by_sketch) if derived_face_selector is not None else profile_sketch["workplane"]
                if end["type"] == "blind" and not second:
                    direction = -1 if reverse else 1
                    # FeatureScript 的 CAP_FACE 是实体端盖，而不是原草图平面。
                    # 记录实际外法向后，后续附着在 start/end cap 的草图才能沿
                    # 正确一侧拉伸；不能复用 profile 的初始法向。
                    feature_frames[item.feature_id] = {
                        "start": _oriented_plane(plane, -direction),
                        "end": _oriented_plane(plane, direction, direction * depth),
                        "profile": dict(plane),
                        "profile_source": source,
                    }
                elif (
                    second
                    and end["type"] == "blind"
                    and (params.get("reverse_end_condition") or {}).get("type") == "blind"
                ):
                    # A two-sided blind extrusion has no cap at the source
                    # plane. Keep the one-sided CAP convention: ``isStart``
                    # is the cap on the side opposite the primary extent and
                    # ``isStart:false`` is the primary-extent cap. This makes
                    # the zero-second-distance limit agree with the
                    # one-sided frame above, regardless of oppositeDirection.
                    direction = -1 if reverse else 1
                    reverse_depth = float(params["reverse_distance_mm"])
                    feature_frames[item.feature_id] = {
                        "start": _oriented_plane(plane, -direction, -direction * reverse_depth),
                        "end": _oriented_plane(plane, direction, direction * depth),
                        "profile": dict(plane),
                        "profile_source": source,
                    }
                elif end["type"] == "mid_plane":
                    direction = -1 if reverse else 1
                    feature_frames[item.feature_id] = {
                        "start": _oriented_plane(plane, -direction, -direction * depth / 2),
                        "end": _oriented_plane(plane, direction, direction * depth / 2),
                        "profile": dict(plane),
                        "profile_source": source,
                    }
                # This source-only datum contract is intentionally narrower
                # than the runtime SWEPT_EDGE selector: a LINE_ANGLE axis can
                # be computed from the original profile vertex and the prism
                # span only while the whole profile was retained unchanged.
                frame = feature_frames.get(item.feature_id)
                if (
                    atomic == "extrude_add_blind"
                    and params.get("result_mode") == "new_body"
                    and end["type"] == "blind"
                    and not second
                    and params.get("draft") is None
                    and isinstance(source, str)
                    and profile_sketch is not None
                    and source in sketch_by_source
                    and profile_sketch.get("source_sketch_id") == source
                    and _profile_matches_direct_source(profile_sketch, sketch_by_source[source])
                    and isinstance(frame, dict)
                ):
                    source_entity_ids = _direct_profile_source_entity_ids(profile_sketch)
                    if source_entity_ids:
                        frame["direct_prism_line_angle_axis"] = True
                        frame["direct_prism_source_entity_ids"] = sorted(source_entity_ids)
            elif item.operation == "loft":
                cap_face_loft = _loft_cap_face_profile(p, sketch_by_source, entity_by_sketch, feature_frames, fid)
                if cap_face_loft is not None:
                    profile_sketch, cap_selector, cap_plane = cap_face_loft
                    if profile_sketch["id"] not in sketches_by_id:
                        sketches.append(profile_sketch); sketches_by_id[profile_sketch["id"]] = profile_sketch
                    if not _profile_executable(profile_sketch): raise ValueError("loft profile sketch has no closed profile")
                    feature = {
                        "id": fid,
                        "name": item.feature_id,
                        "atomic_id": "loft_add_with_cap_face",
                        "depends_on": depends,
                        "params": {"profile_sketch_ids": [profile_sketch["id"]]},
                        "selectors": [cap_selector],
                        "execution_status": "supported",
                    }
                    frames = _loft_cap_frames(cap_plane, profile_sketch["workplane"])
                else:
                    wire_profiles = p.get("wireProfilesArray")
                    body_type = str(p.get("bodyType") or "").rsplit(".", 1)[-1].upper()
                    is_surface_wire_loft = body_type == "SURFACE" and isinstance(wire_profiles, list)
                    surface_loft = (
                        is_surface_wire_loft
                        and len(wire_profiles) == 2
                        and not p.get("sheetProfilesArray")
                        and not p.get("guidesArray")
                        and p.get("spine") is None
                        and str(p.get("operationType") or "NEW").rsplit(".", 1)[-1].upper() == "NEW"
                        and all(p.get(key) in (None, False, [], {}) for key in (
                            "connections", "matchConnections", "startCondition", "endCondition",
                            "startMagnitude", "endMagnitude",
                        ))
                    )
                    if surface_loft:
                        profiles = [
                            _direct_closed_sketch_wire_profile(
                                profile.get("wireProfileEntities") if isinstance(profile, dict) else None,
                                sketch_by_source, entity_by_sketch,
                                featurescript_version=model.featurescript_version,
                                standard_library=model.standard_library,
                                standard_library_version=model.standard_library_version,
                                feature_id=f"{fid}_{index}",
                            )
                            for index, profile in enumerate(wire_profiles)
                        ]
                        if any(profile is None for profile in profiles):
                            raise UnsupportedCapability(
                                "loft_surface_wire_profiles",
                                "current CDSL surface loft requires two direct closed source-wire profiles",
                            )
                        profile_sketches = [profile for profile in profiles if profile is not None]
                        if len({profile["source_sketch_id"] for profile in profile_sketches}) != len(profile_sketches):
                            raise UnsupportedCapability(
                                "loft_surface_wire_profiles",
                                "current CDSL surface loft requires profiles from distinct source sketches",
                            )
                        for profile in profile_sketches:
                            sketches.append(profile); sketches_by_id[profile["id"]] = profile
                        feature = {
                            "id": fid,
                            "name": item.feature_id,
                            "atomic_id": "loft_surface",
                            "depends_on": depends,
                            "params": {"profile_sketch_ids": [profile["id"] for profile in profile_sketches]},
                            "execution_status": "supported",
                        }
                        frames = None
                    elif is_surface_wire_loft:
                        raise UnsupportedCapability(
                            "loft_surface_wire_profiles",
                            "current CDSL surface loft requires two direct closed source-wire profiles",
                        )
                    else:
                        sources = _loft_profile_sketches(p)
                        missing = [source for source in sources if source not in sketch_by_source]
                        if missing:
                            raise ValueError("loft profile sketches are unresolved: " + ", ".join(missing))
                        non_closed = [source for source in sources if not _profile_executable(sketch_by_source[source])]
                        if non_closed:
                            raise ValueError("loft profile sketches have no closed profile: " + ", ".join(non_closed))
                        feature = {
                            "id": fid,
                            "name": item.feature_id,
                            "atomic_id": "loft_add",
                            "depends_on": depends,
                            "params": {"profile_sketch_ids": [sketch_by_source[source]["id"] for source in sources]},
                            "execution_status": "supported",
                        }
                        if _initial_direct_loft_cap_output_roles(p, sources, features, model.featurescript_version):
                            feature["params"].update({
                                "initial_output_roles": True,
                                "cap_output_profile_sources": list(sources),
                            })
                        frames = _loft_cap_frames(
                            sketch_by_source[sources[0]]["workplane"], sketch_by_source[sources[-1]]["workplane"],
                        )
                if frames is not None:
                    # This lowering-only provenance permits an exact source
                    # endpoint pair for a two-section direct loft. It is not
                    # a replacement for runtime topology history.
                    if cap_face_loft is None:
                        frames["loft_profile_sources"] = sources
                    feature_frames[item.feature_id] = frames
            elif item.operation == "sweep":
                profile_source = _source_sketch({"entities": p.get("profiles")})
                if not profile_source or profile_source not in sketch_by_source:
                    raise ValueError("sweep profile sketch is unresolved")
                profile_sketch = _profile_selection_sketch(
                    sketch_by_source[profile_source], p.get("profiles"), entity_by_sketch[profile_source], fid,
                )
                if profile_sketch is not sketch_by_source[profile_source]:
                    sketches.append(profile_sketch); sketches_by_id[profile_sketch["id"]] = profile_sketch
                if not _profile_executable(profile_sketch):
                    raise ValueError("sweep profile sketch has no closed profile")
                path_query = parse_query(p.get("path"))
                path_source = path_query.source_sketch
                path_entity = (entity_by_sketch.get(path_source or "") or {}).get(path_query.source_entity or "")
                path_sketch = sketch_by_source.get(path_source or "")
                # A raw arc/circle leaf must be named by exactly one source
                # query: the query parser retains a representative qUnion
                # leaf, and accepting it would discard the other curves. A
                # single original curve selected by the versioned source-wire
                # contract is different: its complete source set is already
                # proven to contain precisely that one line/arc/B-spline.
                direct_single_path_source = path_query.calls.count("sQuery") == 1
                path: dict[str, Any] | None = None
                # A multi-leaf query is a source wire request, never an
                # authorization to use the parser's representative leaf.
                # Resolve the complete same-sketch or spatial wire before
                # considering the singleton segment path. In particular,
                # parse_query retains the last leaf of qUnion for context;
                # treating that arc or line as the path would discard every
                # preceding curve in the FeatureScript query.
                if not direct_single_path_source:
                    segmented_wire_path = _direct_segmented_sketch_wire_path(
                        p.get("path"), sketch_by_source, entity_by_sketch,
                        featurescript_version=model.featurescript_version,
                        standard_library=model.standard_library,
                        standard_library_version=model.standard_library_version,
                    )
                    if segmented_wire_path is not None:
                        path_source, path_segments, path_sketch = segmented_wire_path
                        path = {"workplane": path_sketch["workplane"], "segments": path_segments}
                    else:
                        spatial_segments = _direct_spatial_segmented_sketch_wire_path(
                            p.get("path"), sketch_by_source, entity_by_sketch,
                            featurescript_version=model.featurescript_version,
                            standard_library=model.standard_library,
                            standard_library_version=model.standard_library_version,
                        )
                        if spatial_segments is not None:
                            path = {"segments": spatial_segments}
                    # Do not fall back to the representative direct leaf.
                    path_entity = path_sketch = None
                if path is None and (path_entity is None or path_sketch is None):
                    direct_wire_path = _direct_sketch_wire_path(
                        p.get("path"), sketch_by_source, entity_by_sketch,
                        featurescript_version=model.featurescript_version,
                        standard_library=model.standard_library,
                        standard_library_version=model.standard_library_version,
                    )
                    if direct_wire_path is not None:
                        path_source, _path_entity_id, path_entity, path_sketch = direct_wire_path
                    elif not direct_single_path_source:
                        # Unlike a raw direct circle leaf, a qBodyType source
                        # wire has no parser entity that may stand in for the
                        # query result. Admit it only after this helper proves
                        # its complete selected source set is exactly one
                        # original circle.
                        circle_wire_path = _direct_sketch_circle_wire_path(
                            p.get("path"), sketch_by_source, entity_by_sketch,
                            featurescript_version=model.featurescript_version,
                            standard_library=model.standard_library,
                            standard_library_version=model.standard_library_version,
                        )
                        if circle_wire_path is not None:
                            path_source, _path_entity_id, path_entity, path_sketch = circle_wire_path
                    elif direct_single_path_source:
                        segmented_wire_path = _direct_segmented_sketch_wire_path(
                            p.get("path"), sketch_by_source, entity_by_sketch,
                            featurescript_version=model.featurescript_version,
                            standard_library=model.standard_library,
                            standard_library_version=model.standard_library_version,
                        )
                        if segmented_wire_path is not None:
                            path_source, path_segments, path_sketch = segmented_wire_path
                            path = {"workplane": path_sketch["workplane"], "segments": path_segments}
                        else:
                            spatial_segments = _direct_spatial_segmented_sketch_wire_path(
                                p.get("path"), sketch_by_source, entity_by_sketch,
                                featurescript_version=model.featurescript_version,
                                standard_library=model.standard_library,
                                standard_library_version=model.standard_library_version,
                            )
                            if spatial_segments is not None:
                                path = {"segments": spatial_segments}
                if path_entity is None or path_sketch is None:
                    if path is None:
                        raise UnsupportedCapability(
                            "sweep_path_query",
                            "current CDSL sweep requires one direct source sketch line/arc/B-spline, a connected source-sketch wire, or a connected union of source wires",
                        )
                if path is None and path_entity.get("type") not in {"line", "arc", "circle", "bspline"}:
                    raise UnsupportedCapability("sweep_path", "current CDSL sweep requires one line, arc, circle, or B-spline path")
                operation = str(p.get("operationType") or "NEW").upper()
                is_cut_operation = any(value in operation for value in ("REMOVE", "CUT"))
                if "INTERSECT" in operation:
                    raise UnsupportedCapability("sweep_intersect", "current CDSL sweep does not yet support intersection body semantics")
                if path is None:
                    path = {"workplane": path_sketch["workplane"], "segment": deepcopy(path_entity)}
                path_reversed = _sweep_profile_attaches_at_path_end(profile_sketch, path)
                if path_reversed:
                    path = _reversed_sweep_path(path)
                feature = {
                    "id": fid,
                    "name": item.feature_id,
                    "atomic_id": "sweep_cut" if is_cut_operation else "sweep_add",
                    "depends_on": depends,
                    "sketch_id": profile_sketch["id"],
                    "params": {"path": path},
                    "execution_status": "supported",
                }
                if _is_new_body_operation(operation): feature["params"]["result_mode"] = "new_body"
                frames = _sweep_cap_frames(profile_sketch, feature["params"]["path"])
                if frames is not None:
                    feature_frames[item.feature_id] = frames
                # PipeShell FirstShape/LastShape can prove two physical cap
                # faces only for one direct profile and one direct source
                # path. Preserve that singleton pair for CAP_FACE.  Its
                # Generated(profile_edge) history is distinct and can retain
                # a complete direct analytic contour for SWEPT_FACE.
                path_segment = feature["params"]["path"].get("segment") or {}
                closed_circle_path = path_segment.get("type") == "circle"
                profile_shape = profile_sketch.get("profile") or {}
                if (
                    feature["params"].get("result_mode") == "new_body"
                    and profile_sketch.get("source_sketch_id") == profile_source
                    and profile_shape.get("source_entity_id")
                    and isinstance(path_segment.get("source_entity_id"), str)
                    and path_segment["source_entity_id"]
                    and direct_single_path_source
                    and isinstance(feature["params"]["path"].get("workplane"), dict)
                    and not feature["params"]["path"].get("segments")
                    and not closed_circle_path
                    and frames is not None
                ):
                    feature["params"]["initial_output_roles"] = True
                    feature["params"]["cap_output_contract"] = {
                        "profile_source": profile_source,
                        "profile_entity": str(profile_shape["source_entity_id"]),
                        "path_source": path_source,
                        "path_entity": path_segment["source_entity_id"],
                        "path_reversed": path_reversed,
                    }
                direct_profile_entities = _direct_sweep_profile_entities(profile_sketch)
                if (
                    feature["params"].get("result_mode") == "new_body"
                    and profile_sketch.get("source_sketch_id") == profile_source
                    and direct_profile_entities is not None
                    and isinstance(path_segment.get("source_entity_id"), str)
                    and path_segment["source_entity_id"]
                    and direct_single_path_source
                    and isinstance(feature["params"]["path"].get("workplane"), dict)
                    and not feature["params"]["path"].get("segments")
                    and not closed_circle_path
                ):
                    feature["params"]["initial_output_roles"] = True
                    feature["params"]["swept_face_contract"] = {
                        "profile_source": profile_source,
                        "profile_entities": direct_profile_entities,
                        "path_source": path_source,
                        "path_entity": path_segment["source_entity_id"],
                        "path_reversed": path_reversed,
                    }
                if (
                    feature["params"].get("result_mode") == "new_body"
                    and profile_source != path_source
                    and profile_sketch.get("source_sketch_id") == profile_source
                    and direct_profile_entities is not None
                    and len(direct_profile_entities) >= 2
                    and isinstance(path_segment.get("source_entity_id"), str)
                    and path_segment["source_entity_id"]
                    and direct_single_path_source
                    and isinstance(feature["params"]["path"].get("workplane"), dict)
                    and not feature["params"]["path"].get("segments")
                    and not closed_circle_path
                ):
                    feature["params"]["initial_output_roles"] = True
                    feature["params"]["swept_edge_contract"] = {
                        "profile_source": profile_source,
                        "profile_entities": direct_profile_entities,
                        "path_source": path_source,
                        "path_entity": path_segment["source_entity_id"],
                        "path_reversed": path_reversed,
                    }
            elif item.operation == "booleanBodies":
                operation = str(p.get("operationType") or "").split(".")[-1].upper()
                operation_map = {
                    "UNION": "union",
                    "SUBTRACTION": "subtract",
                    "INTERSECTION": "intersect",
                }
                if operation not in operation_map:
                    raise UnsupportedCapability("boolean_bodies_operation", "current CDSL booleanBodies supports union, subtraction and intersection")
                # An omitted FeatureScript ``targets`` field is the exact
                # targetless-UNION form.  ``_queries(None)`` intentionally
                # returns one placeholder for callers that need a diagnostic,
                # so it cannot be used to decide whether this field exists.
                has_targets = p.get("targets") is not None
                targets, target_instance_refs, target_transform_copy_refs = (
                    _boolean_body_references(
                        p.get("targets"), previous, feature_by_id, body_transform_aliases,
                    )
                    if has_targets else ([], [], [])
                )
                tools, tool_instance_refs, tool_transform_copy_refs = _boolean_body_references(
                    p.get("tools"), previous, feature_by_id, body_transform_aliases,
                )
                if not has_targets:
                    # A targetless FeatureScript boolean denotes an ordered
                    # set of body operands. For UNION and INTERSECTION, the
                    # first explicit source member can be made CDSL's left
                    # operand and every following member its right set. This
                    # preserves the operation while keeping the source body
                    # set explicit; SUBTRACTION has no such source-proven
                    # targetless ordering contract.
                    if operation not in {"UNION", "INTERSECTION"}:
                        raise UnsupportedCapability(
                            "boolean_bodies_targets",
                            "targetless booleanBodies currently supports only UNION or INTERSECTION",
                        )
                    selections = _ordered_boolean_body_references(
                        p.get("tools"), previous, feature_by_id, body_transform_aliases,
                    )
                    if len(selections) < 2:
                        raise ValueError("targetless booleanBodies requires at least two explicit bodies")
                    # FeatureScript supplies a set here, not a directional
                    # target/tool pair. Preserve the existing deterministic
                    # lifecycle policy: select an explicit direct member when
                    # the set has one; otherwise choose its first qualified
                    # COPY member. UNION/INTERSECTION are commutative, so the
                    # choice does not alter their shape, while it avoids
                    # rewriting a direct source as a pattern aggregate.
                    target_index = next(
                        (index for index, (kind, _value) in enumerate(selections) if kind == "feature"),
                        0,
                    )
                    target_kind, target = selections.pop(target_index)
                    right_operands = selections
                    targets = [target] if target_kind == "feature" else []
                    target_instance_refs = [target] if target_kind == "pattern" else []
                    target_transform_copy_refs = [target] if target_kind == "transform_copy" else []
                    tools = [value for kind, value in right_operands if kind == "feature"]
                    tool_instance_refs = [value for kind, value in right_operands if kind == "pattern"]
                    tool_transform_copy_refs = [value for kind, value in right_operands if kind == "transform_copy"]
                    targetless_body_set = True
                else:
                    targetless_body_set = False
                target_keys = {("feature", source) for source in targets} | {
                    ("pattern", reference["pattern_feature_id"], reference["source_feature_id"], reference["instance_index"])
                    for reference in target_instance_refs
                } | {
                    ("transform_copy", reference["transform_feature_id"], reference["source_feature_id"])
                    for reference in target_transform_copy_refs
                }
                tool_keys = {("feature", source) for source in tools} | {
                    ("pattern", reference["pattern_feature_id"], reference["source_feature_id"], reference["instance_index"])
                    for reference in tool_instance_refs
                } | {
                    ("transform_copy", reference["transform_feature_id"], reference["source_feature_id"])
                    for reference in tool_transform_copy_refs
                }
                if target_keys & tool_keys:
                    raise ValueError("booleanBodies targets and tools must be disjoint")
                missing = [source for source in targets + tools if source not in feature_by_id]
                if missing:
                    raise ValueError("booleanBodies source features are unresolved: " + ", ".join(missing))
                pattern_dependencies = list(dict.fromkeys([
                    *(reference["pattern_feature_id"] for reference in target_instance_refs),
                    *(reference["pattern_feature_id"] for reference in tool_instance_refs),
                ]))
                transform_copy_dependencies = list(dict.fromkeys([
                    *(reference["transform_feature_id"] for reference in target_transform_copy_refs),
                    *(reference["transform_feature_id"] for reference in tool_transform_copy_refs),
                ]))
                feature = {
                    "id": fid,
                    "name": item.feature_id,
                    "atomic_id": "boolean_bodies",
                    "depends_on": list(dict.fromkeys(targets + tools + pattern_dependencies + transform_copy_dependencies + depends)),
                    "params": {
                        "operation": operation_map[operation],
                        "keep_tools": _bool(p.get("keepTools")),
                    },
                    "execution_status": "supported",
                }
                if targetless_body_set:
                    feature["params"]["targetless_body_set"] = True
                if targets:
                    feature["params"]["target_feature_ids"] = targets
                if tools:
                    feature["params"]["tool_feature_ids"] = tools
                if target_instance_refs:
                    feature["params"]["target_pattern_instance_refs"] = target_instance_refs
                if tool_instance_refs:
                    feature["params"]["tool_pattern_instance_refs"] = tool_instance_refs
                if target_transform_copy_refs:
                    feature["params"]["target_transform_copy_refs"] = target_transform_copy_refs
                if tool_transform_copy_refs:
                    feature["params"]["tool_transform_copy_refs"] = tool_transform_copy_refs
            elif item.operation == "revolve":
                # surfaceOperationType alone does not make a body operation a
                # surface operation. CADFS emits it for closed sketch regions
                # that produce ordinary solids too. Only ToolBodyType.SURFACE
                # selects a sheet result; its profile is in surfaceEntities.
                surface_operation = str(p.get("bodyType") or "").rsplit(".", 1)[-1].upper() == "SURFACE"
                profile_entities = p.get("surfaceEntities") if surface_operation else p.get("entities")
                profile_kind = parse_query(profile_entities).topology_type
                source = _source_sketch(p)
                if not source or source not in sketch_by_source: raise ValueError("revolve sketch query is unresolved")
                profile_sketch = _profile_selection_sketch(sketch_by_source[source], profile_entities, entity_by_sketch[source], fid)
                if profile_sketch is not sketch_by_source[source]: sketches.append(profile_sketch); sketches_by_id[profile_sketch["id"]] = profile_sketch
                if not _profile_executable(profile_sketch): raise ValueError("revolve sketch has no closed profile")
                axis_q = parse_query(p.get("axis")); axis_entity = (entity_by_sketch.get(axis_q.source_sketch or "") or {}).get(axis_q.source_entity or "")
                if not axis_entity or axis_entity.get("type") != "line": raise ValueError("revolve axis is unresolved")
                plane = sketch_by_source[axis_q.source_sketch]["workplane"]; start, end = _global(plane, axis_entity["start"]), _global(plane, axis_entity["end"])
                direction = [end[i]-start[i] for i in range(3)]; norm = math.sqrt(sum(x*x for x in direction)); direction = [x/norm for x in direction]
                # 闭合实体回转携带 surfaceOperationType、但没有 bodyType 时，
                # 该字段只是曲面处理参数，不能被误读为 NewBodyOperationType.NEW。
                # 它保持默认 ADD，F8 这类重叠回转因而会参与当前实体的融合。
                # 完全没有该字段的普通实体回转仍保持 FeatureScript 的默认 NEW
                # body 语义；显式 ToolBodyType.SURFACE 则以独立 shell 执行。
                default_operation = "NEW" if surface_operation or p.get("surfaceOperationType") is None else "ADD"
                operation = str(p.get("operationType") or default_operation).upper()
                surface_kind = str(p.get("surfaceOperationType") or "NEW").upper()
                if surface_operation and "NEW" not in surface_kind:
                    raise UnsupportedCapability("revolve_surface_operation", "current CDSL surface revolve supports only NewSurfaceOperationType.NEW")
                atomic = "revolve_surface" if surface_operation else "revolve_cut" if "REMOVE" in operation else "revolve_add"
                full = "FULL" in str(p.get("revolveType") or "FULL").upper(); angle = 360.0 if full else _number(p.get("angle", 360.0))
                params = {"angle_deg": angle, "reverse": _bool(p.get("oppositeDirection")), "axis": {"origin_mm": start, "direction": direction}}
                if atomic == "revolve_add" and _is_new_body_operation(operation): params["result_mode"] = "new_body"
                feature = {"id": fid, "name": item.feature_id, "atomic_id": atomic, "depends_on": depends, "sketch_id": profile_sketch["id"], "params": params, "execution_status": "supported"}
                if full:
                    frame = {"revolve_axis": {"origin_mm": start, "direction": direction}, "revolve_full": True}
                    # A SWEPT_EDGE circle is only lowerable when both profile
                    # and axis are still direct source-sketch entities. Keep
                    # this lowering-only provenance out of the public CDSL.
                    axis_direct = (
                        axis_q.source_sketch == source
                        and axis_q.source_entity is not None
                        and _source_ref_entity(source, axis_q.source_entity, entity_by_sketch) is not None
                    )
                    if (
                        atomic == "revolve_add"
                        and params.get("result_mode") == "new_body"
                        and _profile_matches_direct_source(profile_sketch, sketch_by_source[source])
                        and axis_direct
                    ):
                        frame["profile_source"] = source
                        # Keep the FeatureScript profile provenance separate
                        # from geometry equality.  Some 1511 IMPRINT queries
                        # lower to identical contours but are not the original
                        # sketch topology; 2491 has explicit evidence for one
                        # complete unchanged materialization.
                        frame["revolve_profile_contract"] = (
                            "verified_complete_materialization"
                            if profile_kind == "IMPRINT"
                            else "original_source"
                        )
                    feature_frames[item.feature_id] = frame
            elif item.operation in {"fillet", "chamfer"}:
                key = "radius" if item.operation == "fillet" else "width"
                chamfer_type = str(p.get("chamferType") or "EQUAL_OFFSETS").split(".")[-1].upper()
                amount_value = p.get(key)
                if item.operation == "chamfer" and chamfer_type == "TWO_OFFSETS": amount_value = p.get("width1")
                amount = _number(amount_value, True); selectors = []
                source_set = _direct_query_set_operands(p.get("entities"))
                query_values = _query_set_leaf_values(p.get("entities")) if source_set is not None else _queries(p.get("entities"))
                offset_edge_forms: set[str] = set()
                for query_value in query_values:
                    try:
                        _call, _owner, topology, _kind, definition = _direct_make_query(query_value)
                    except ValueError:
                        continue
                    if topology != "OFFSET_EDGE":
                        continue
                    disambiguation = definition.get("disambiguationData")
                    if isinstance(disambiguation, list):
                        offset_edge_forms.add(
                            "tdd" if any(isinstance(item, Call) and item.name == "TDD" for item in disambiguation)
                            else "osd"
                        )
                mixed_offset_edge_forms = len(offset_edge_forms) > 1
                for index, query_value in enumerate(query_values):
                    query = parse_query(query_value)
                    # ``parse_query`` retains nested source metadata for
                    # diagnostics, but its recursive walk ends on an inner
                    # CAP/SWEPT query.  A fillet/chamfer consumes the outer
                    # makeQuery result, so use the direct outer expression
                    # for its topology kind and owner.
                    try:
                        _outer_call, outer_owner, outer_topology, outer_kind, _outer_definition = _direct_make_query(query_value)
                    except ValueError:
                        outer_owner = query.owner_feature
                        outer_topology = query.topology_type
                        outer_kind = query.kind
                    owner = outer_owner
                    if not owner: raise ValueError("selector owner is unresolved")
                    # A deferred source query still describes a CADFS result,
                    # but it cannot bind to a producer omitted from the CDSL
                    # prefix.  Keeping that missing owner in a supported
                    # dress-up would create semantically invalid CDSL and
                    # falsely move this lowering failure into validation.
                    if f"f_{owner}" not in feature_by_id:
                        raise UnsupportedCapability(
                            "selector_owner_unavailable",
                            f"selector owner {owner} has no executable CDSL producer",
                        )
                    selector_kind = "face" if outer_kind in {"face", "entitytype.face"} else "edge"
                    if outer_topology == "BLEND_EDGE":
                        blend_selector = _direct_blend_edge_selector(
                            query_value,
                            owner=owner,
                            feature_by_id=feature_by_id,
                            feature_frames=feature_frames,
                            sketch_by_source=sketch_by_source,
                            sketches_by_id=sketches_by_id,
                            entity_by_sketch=entity_by_sketch,
                            previous=previous,
                            featurescript_version=model.featurescript_version,
                        )
                        if blend_selector is not None:
                            selectors.append(blend_selector)
                            continue
                        selectors.append({
                            "kind": selector_kind,
                            "owner_feature_id": f"f_{owner}",
                            "stable_id": f"cadfs_{fid}_{index}",
                            "source": "runtime_snapshot",
                            "confidence": 1.0,
                            "selector_intent": _deferred_featurescript_selector_intent(
                                query_value, kind=selector_kind,
                            ),
                        })
                        continue
                    if outer_topology == "OFFSET_EDGE":
                        offset_edge_selector = _direct_prism_shell_offset_edge_tdd_selector(
                            query_value,
                            owner=owner,
                            feature_by_id=feature_by_id,
                            feature_frames=feature_frames,
                            sketch_by_source=sketch_by_source,
                            sketches_by_id=sketches_by_id,
                            entity_by_sketch=entity_by_sketch,
                            previous=previous,
                            featurescript_version=model.featurescript_version,
                        )
                        if offset_edge_selector is None and not mixed_offset_edge_forms:
                            offset_edge_selector = _direct_prism_shell_offset_edge_vertex_selector(
                                query_value,
                                owner=owner,
                                feature_by_id=feature_by_id,
                                feature_frames=feature_frames,
                                sketch_by_source=sketch_by_source,
                                sketches_by_id=sketches_by_id,
                                entity_by_sketch=entity_by_sketch,
                                previous=previous,
                                featurescript_version=model.featurescript_version,
                            )
                        if offset_edge_selector is not None:
                            selectors.append(offset_edge_selector)
                            continue
                    if outer_topology == "INTERSECT":
                        intersection_selector = _direct_boolean_intersection_selector(
                            query_value,
                            feature_by_id=feature_by_id,
                            feature_frames=feature_frames,
                            sketch_by_source=sketch_by_source,
                            sketches_by_id=sketches_by_id,
                            entity_by_sketch=entity_by_sketch,
                            featurescript_version=model.featurescript_version,
                        )
                        if intersection_selector is None:
                            intersection_selector = _direct_primary_cut_intersection_selector(
                                query_value,
                                feature_by_id=feature_by_id,
                                feature_frames=feature_frames,
                                sketch_by_source=sketch_by_source,
                                sketches_by_id=sketches_by_id,
                                entity_by_sketch=entity_by_sketch,
                                previous=previous,
                                featurescript_version=model.featurescript_version,
                            )
                        if intersection_selector is not None:
                            selectors.append(intersection_selector)
                            continue
                        selectors.append({
                            "kind": selector_kind,
                            "owner_feature_id": f"f_{owner}",
                            "stable_id": f"cadfs_{fid}_{index}",
                            "source": "runtime_snapshot",
                            "confidence": 1.0,
                            "selector_intent": _deferred_featurescript_selector_intent(
                                query_value, kind=selector_kind,
                            ),
                        })
                        continue
                    if outer_topology == "COPY":
                        copy_selector = _direct_primary_cut_copy_cap_edge_selector(
                            query_value,
                            feature_by_id=feature_by_id,
                            feature_frames=feature_frames,
                            sketch_by_source=sketch_by_source,
                            sketches_by_id=sketches_by_id,
                            entity_by_sketch=entity_by_sketch,
                            previous=previous,
                            featurescript_version=model.featurescript_version,
                        )
                        if copy_selector is not None:
                            selectors.append(copy_selector)
                            continue
                    if outer_topology == "CAP_FACE":
                        # A primary ADD has only a transient prism tool. Its
                        # cap may drive the immediately following dress-up
                        # only when runtime proves the exact one-to-one
                        # extrude-to-union successor in the active member.
                        cap_selector = _cap_face_output_role_selector(
                            query_value,
                            feature_by_id,
                            sketches_by_id,
                            allow_primary_add_dressup=True,
                        )
                        if (
                            cap_selector is not None
                            and previous[-1:] == [cap_selector["owner_feature_id"]]
                        ):
                            selectors.append(cap_selector)
                            continue
                    if outer_topology in {"CAP_FACE", "CAP_EDGE", "SWEPT_FACE", "SWEPT_EDGE"}:
                        imprint_selector = _planar_imprint_prism_selector(
                            query_value,
                            owner=owner,
                            selector_kind=selector_kind,
                            feature_by_id=feature_by_id,
                            feature_frames=feature_frames,
                            sketches_by_id=sketches_by_id,
                            previous=previous,
                            featurescript_version=model.featurescript_version,
                        )
                        if imprint_selector is not None:
                            selectors.append(imprint_selector)
                            continue
                    if outer_topology in {"CAP_EDGE", "SWEPT_FACE", "SWEPT_EDGE"}:
                        sweep_cap_edge_selector = _initial_direct_sweep_cap_edge_selector(
                            query_value, feature_by_id, sketches_by_id, previous,
                        ) if outer_topology == "CAP_EDGE" else None
                        if sweep_cap_edge_selector is not None:
                            selectors.append(sweep_cap_edge_selector)
                            continue
                        sweep_swept_face_selector = _initial_direct_sweep_swept_face_selector(
                            query_value, feature_by_id, sketches_by_id, previous,
                        ) if outer_topology == "SWEPT_FACE" else None
                        if sweep_swept_face_selector is not None:
                            selectors.append(sweep_swept_face_selector)
                            continue
                        sweep_swept_edge_selector = _initial_direct_sweep_swept_edge_selector(
                            query_value, feature_by_id, sketches_by_id, previous,
                        ) if outer_topology == "SWEPT_EDGE" else None
                        if sweep_swept_edge_selector is not None:
                            selectors.append(sweep_swept_edge_selector)
                            continue
                        # A direct PipeShell producer with an explicit source
                        # contract must not fall through to the legacy
                        # cylinder geometry hint when its profile/path pair is
                        # incomplete or contradictory. Preserve the source
                        # query for diagnostics and let runtime reject it.
                        sweep_producer = feature_by_id.get(f"f_{owner}") or {}
                        sweep_params = sweep_producer.get("params") or {}
                        if (
                            outer_topology in {"SWEPT_FACE", "SWEPT_EDGE"}
                            and sweep_producer.get("atomic_id") == "sweep_add"
                            and sweep_params.get("initial_output_roles") is True
                            and isinstance(
                                sweep_params.get(
                                    "swept_face_contract" if outer_topology == "SWEPT_FACE" else "swept_edge_contract"
                                ),
                                dict,
                            )
                        ):
                            selectors.append({
                                "kind": selector_kind,
                                "owner_feature_id": f"f_{owner}",
                                "source": "runtime_snapshot",
                                "confidence": 1.0,
                                "selector_intent": _deferred_featurescript_selector_intent(
                                    query_value, kind=selector_kind,
                                ),
                            })
                            continue
                        lineage_selector = _direct_prism_swept_selector(
                            query_value,
                            owner=owner,
                            selector_kind=selector_kind,
                            feature_by_id=feature_by_id,
                            feature_frames=feature_frames,
                            sketch_by_source=sketch_by_source,
                            sketches_by_id=sketches_by_id,
                            entity_by_sketch=entity_by_sketch,
                            previous=previous,
                            featurescript_version=model.featurescript_version,
                            allow_continuation=outer_topology in {"CAP_EDGE", "SWEPT_EDGE"},
                        )
                        if lineage_selector is not None:
                            selectors.append(lineage_selector)
                            continue
                        if outer_topology == "SWEPT_EDGE":
                            revolve_selector = _direct_full_revolve_swept_edge_selector(
                                query_value,
                                owner=owner,
                                selector_kind=selector_kind,
                                feature_by_id=feature_by_id,
                                feature_frames=feature_frames,
                                sketch_by_source=sketch_by_source,
                                sketches_by_id=sketches_by_id,
                                entity_by_sketch=entity_by_sketch,
                                previous=previous,
                                featurescript_version=model.featurescript_version,
                            )
                            if revolve_selector is not None:
                                selectors.append(revolve_selector)
                                continue
                        if _uses_planar_imprint_profile(owner, feature_by_id, sketches_by_id):
                            selectors.append({
                                "kind": selector_kind,
                                "owner_feature_id": f"f_{owner}",
                                "stable_id": f"cadfs_{fid}_{index}",
                                "source": "runtime_snapshot",
                                "confidence": 1.0,
                                "selector_intent": _deferred_featurescript_selector_intent(
                                    query_value, kind=selector_kind,
                                ),
                            })
                            continue
                    refs = _source_refs(query_value)
                    source_entity = (entity_by_sketch.get(query.source_sketch or "") or {}).get(query.source_entity or "")
                    geometry: dict[str, Any] = {}
                    frame = feature_frames.get(owner)
                    cap = frame.get("start" if query.is_start else "end") if frame and {"start", "end"}.issubset(frame) else None
                    if selector_kind == "face" and query.topology_type == "CAP_FACE" and cap:
                        geometry = {"normal": cap["normal"], "plane_offset_mm": sum(cap["normal"][i] * cap["origin_mm"][i] for i in range(3))}
                    elif selector_kind == "face" and query.topology_type == "SWEPT_FACE" and source_entity and source_entity["type"] == "circle":
                        # 圆形 profile 拉伸得到的侧面以轴线、半径为标识。同一 feature 可以
                        # 生成多个半径相同的圆柱面，因此保留草图圆心作为轴原点来解消歧义。
                        source_plane = sketch_by_source.get(query.source_sketch or "", {}).get("workplane")
                        if source_plane is not None:
                            geometry = {
                                "axis_origin_mm": _global(source_plane, source_entity["center"]),
                                "axis_direction": source_plane["normal"],
                                "radius_mm": source_entity["radius_mm"],
                            }
                    elif selector_kind == "edge" and query.topology_type == "OFFSET_EDGE" and source_entity and source_entity["type"] == "circle":
                        offset_planes = (frame or {}).get("shell_offset_edge_planes") or {}
                        source_key = f"{query.source_sketch}:{query.source_entity}"
                        offset_plane = offset_planes.get(source_key)
                        if offset_plane is not None:
                            geometry = {
                                "source_circle_center_mm": _global(offset_plane, source_entity["center"]),
                                "source_circle_radius_mm": source_entity["radius_mm"],
                                "source_plane_normal": offset_plane["normal"],
                            }
                    if selector_kind == "edge" and query.topology_type == "SWEPT_EDGE":
                        geometry = _swept_edge_line_selector_geometry(
                            owner, refs, frame or {}, feature_by_id, sketch_by_source, entity_by_sketch,
                        )
                        if geometry is None:
                            geometry = _swept_edge_revolve_circle_selector_geometry(
                                owner, refs, frame or {}, feature_by_id, sketch_by_source, entity_by_sketch,
                            )
                        if geometry is None:
                            raise ValueError("swept edge source endpoint provenance is unsupported")
                    elif selector_kind == "edge" and source_entity and cap:
                        if source_entity["type"] == "circle":
                            # Keep the source circle signature until the prefix has been
                            # rebuilt. OCC may expose it as one edge or several arcs.
                            selectors.append({"kind": selector_kind, "owner_feature_id": f"f_{owner}", "stable_id": f"cadfs_{fid}_{index}", "source": "runtime_snapshot", "confidence": 1.0, "geometry": geometry or {"curve_type": "circle", "source_circle_center_mm": _global(cap, source_entity["center"]), "source_circle_radius_mm": source_entity["radius_mm"], "source_plane_normal": cap["normal"]}, "selector_intent": _deferred_featurescript_selector_intent(query_value, kind=selector_kind)})
                            continue
                        elif source_entity["type"] == "line":
                            start, end = _global(cap, source_entity["start"]), _global(cap, source_entity["end"])
                            geometry = {"curve_type": "line", "bbox_mm": [min(start[i], end[i]) for i in range(3)] + [max(start[i], end[i]) for i in range(3)]}
                    if not geometry: raise ValueError("selector geometry is unresolved")
                    if selector_kind == "face" and not geometry:
                        raise ValueError(f"{query.topology_type or 'face'} selector geometry is unresolved")
                    selectors.append({"kind": selector_kind, "owner_feature_id": f"f_{owner}", "stable_id": f"cadfs_{fid}_{index}", "source": "runtime_snapshot", "confidence": 1.0, "geometry": geometry, "selector_intent": _deferred_featurescript_selector_intent(query_value, kind=selector_kind)})
                # Dress-up consumers must retain the source set expression,
                # including a direct qUnion, because its ordered child
                # provenance is what lets the runtime apply exact set
                # algebra.  (The shell consumer below intentionally keeps
                # its legacy flat direct-union contract.)
                query_set = _proven_query_set_selector(p.get("entities"), selectors) if source_set is not None else None
                if query_set is not None:
                    selectors = [query_set]
                params = {"radius_mm" if item.operation == "fillet" else "distance_mm": amount}
                if item.operation == "fillet": params["tangent_propagation"] = _bool(p.get("tangentPropagation"))
                elif _bool(p.get("tangentPropagation")):
                    params["tangent_propagation"] = True
                elif chamfer_type == "TWO_OFFSETS":
                    second = _number(p.get("width2"), True)
                    if _bool(p.get("oppositeDirection")): params["distance_mm"], second = second, params["distance_mm"]
                    params["distance_2_mm"] = second
                elif chamfer_type == "OFFSET_ANGLE":
                    angle = math.radians(_number(p.get("angle")))
                    if _bool(p.get("oppositeDirection")):
                        second = amount * math.tan(angle); params["distance_mm"] = second; params["distance_2_mm"] = amount
                    else: params["angle_rad"] = angle
                feature = {"id": fid, "name": item.feature_id, "atomic_id": item.operation, "depends_on": depends, "params": params, "selectors": selectors, "execution_status": "supported"}
            elif item.operation == "shell":
                thickness = _number(p.get("thickness"), True)
                selectors = []; offset_edge_planes: dict[str, dict[str, Any]] = {}
                cap_removals: list[tuple[str, str]] = []
                source_set = _direct_query_set_operands(p.get("entities"))
                query_values = (
                    _query_set_leaf_values(p.get("entities"))
                    if source_set is not None
                    else _queries(p.get("entities"))
                )
                for index, query_value in enumerate(query_values):
                    query = parse_query(query_value)
                    _call, _owner, topology, kind, _definition = _direct_make_query(query_value)
                    if kind not in {"face", "entitytype.face"}:
                        raise UnsupportedCapability("shell_face_selector", "current CDSL shell requires face removal selectors")
                    if topology == "CAP_FACE":
                        # A direct CAP_FACE names the extrusion's physical
                        # builder output.  It may serve a shell only while
                        # that independent prism is still the active,
                        # immediately preceding body.  Other CAP histories
                        # retain their deferred source query and cannot pick a
                        # geometrically similar face here.
                        selector = _cap_face_output_role_selector(
                            query_value,
                            feature_by_id,
                            sketches_by_id,
                            allow_initial_loft=True,
                            allow_two_sided_circle_shell=True,
                            allow_primary_add_shell=True,
                        )
                        if selector is None:
                            selector = _initial_direct_sweep_cap_output_role_selector(
                                query_value, feature_by_id, sketches_by_id,
                            )
                        if selector is None or previous[-1:] != [selector["owner_feature_id"]]:
                            selector = _face_reference(query_value, feature_frames, sketch_by_source, entity_by_sketch)
                        if query.owner_feature and query.is_start is not None:
                            cap_removals.append((query.owner_feature, "start" if query.is_start else "end"))
                        source_frame = feature_frames.get(query.owner_feature or "") or {}
                        cap = source_frame.get("start" if query.is_start else "end")
                        if cap is not None:
                            for source, entity_id in _source_refs(query_value):
                                offset_edge_planes[f"{source}:{entity_id}"] = dict(cap)
                    elif topology == "SWEPT_FACE":
                        selector = _direct_linear_extrude_swept_face_shell_reference(
                            query_value, feature_frames, sketch_by_source, sketches_by_id,
                            entity_by_sketch, feature_by_id, previous, model.featurescript_version,
                        )
                    elif topology == "OFFSET_FACE":
                        selector = _shell_offset_face_output_role_selector(
                            query_value, feature_by_id, sketches_by_id, previous,
                        )
                    elif topology == "COPY":
                        selector = _pattern_copy_face_reference(
                            query_value, feature_frames, sketch_by_source, entity_by_sketch, feature_by_id,
                        )
                    else:
                        raise UnsupportedCapability("shell_face_selector", "current CDSL shell requires CAP_FACE, direct linear-extrude SWEPT_FACE, or COPY(CAP_FACE) removal selectors")
                    # Feature-output roles resolve only through the active
                    # kernel snapshot. A stable id would turn that semantic
                    # evidence into a stale geometric selector.
                    if selector.get("output_role") is None and not isinstance(selector.get("selector_intent"), dict):
                        selector["stable_id"] = f"cadfs_{fid}_{index}"
                    selectors.append(selector)
                # A direct qUnion is already represented by the ordered flat
                # removal-face list expected by the established shell
                # contract.  Preserve a QUERY_SET parent only for set
                # operators whose intersection/subtraction or nested union
                # semantics cannot be represented by that list.
                needs_query_set_parent = bool(
                    source_set is not None
                    and (
                        source_set[1] != "union"
                        or any(_direct_query_set_operands(item) is not None for item in source_set[2])
                    )
                )
                query_set = _proven_query_set_selector(p.get("entities"), selectors) if needs_query_set_parent else None
                if query_set is not None:
                    selectors = [query_set]
                if not selectors:
                    raise ValueError("shell has no face removal selector")
                # CADFS's oppositeDirection selects the exterior material
                # side. The runtime contract carries this directly to OCC's
                # signed offset; it is not a request to reverse removal-face
                # ownership or a candidate for a current-body fallback.
                shell_params = {"thickness_mm": thickness, "inward": not _bool(p.get("oppositeDirection"))}
                if p.get("parts") is not None:
                    try:
                        shell_params["target_feature_id"] = _shell_target_body_source(
                            p["parts"], previous, body_transform_aliases, lowered_body_members,
                        )
                    except (UnsupportedCapability, ValueError) as error:
                        # Keep the established face-scoped execution path for
                        # legacy histories, but make the omitted parts-owner
                        # proof visible instead of silently treating the active
                        # aggregate as an explicitly selected body.
                        diagnostics.append({
                            "code": "unresolved_body_source",
                            "capability": "shell_parts_body_source",
                            "feature_id": item.feature_id,
                            "operation": item.operation,
                            "message": str(error),
                        })
                feature = {"id": fid, "name": item.feature_id, "atomic_id": "shell", "depends_on": depends, "params": shell_params, "selectors": selectors, "execution_status": "supported"}
                def selector_owners(selector: dict[str, Any]) -> set[str]:
                    owners: set[str] = set()
                    owner = selector.get("owner_feature_id")
                    if isinstance(owner, str) and owner:
                        owners.add(owner.removeprefix("f_"))
                    for child in selector.get("query_operands") or ():
                        if isinstance(child, dict):
                            owners.update(selector_owners(child))
                    return owners

                owners = set().union(*(selector_owners(selector) for selector in selectors))
                if len(owners) == 1:
                    source = next(iter(owners))
                    source_feature = feature_by_id.get(f"f_{source}") or {}
                    source_frame = feature_frames.get(source)
                    if source_frame is not None and source_feature.get("sketch_id"):
                        shell_frame = {
                            **source_frame,
                            "shell_source": source,
                            "shell_thickness_mm": thickness,
                            "shell_profile_sketch_id": source_feature["sketch_id"],
                        }
                        # A derived inner wall has a bounded span only when
                        # this direct shell removes exactly one known cap of
                        # the same extrusion. Additional removal faces can
                        # change its trim topology, so do not infer a wall.
                        if (
                            shell_params["inward"]
                            and len(cap_removals) == 1
                            and cap_removals[0][0] == source
                        ):
                            shell_frame["shell_inward"] = True
                            shell_frame["shell_removed_cap"] = cap_removals[0][1]
                        feature_frames[item.feature_id] = shell_frame
                if offset_edge_planes:
                    frame = feature_frames.setdefault(item.feature_id, {})
                    frame["shell_offset_edge_planes"] = offset_edge_planes
            elif item.operation == "hole":
                locations = _queries(p.get("locations")); positions = []; host_plane = None; host_attachment = None
                for location in locations:
                    location_query = parse_query(location)
                    # A direct source vertex only has a usable local position
                    # once its source sketch has an executable, explicit frame.
                    # Do not label an unresolved host workplane as a malformed
                    # vertex selector: it is an upstream sketch dependency.
                    if (
                        _is_direct_hole_location_query(location)
                        and
                        isinstance(location_query.source_sketch, str)
                        and location_query.source_sketch not in sketch_by_source
                    ):
                        raise UnsupportedCapability(
                            "hole_location_sketch_unavailable",
                            "hole location source sketch is not executable",
                        )
                    resolved_location = _direct_hole_location(location, sketch_by_source, entity_by_sketch)
                    if resolved_location is None:
                        raise UnsupportedCapability(
                            "hole_location_vertex",
                            "hole location requires one direct original sketch vertex",
                        )
                    position, location_plane = resolved_location
                    if host_plane is not None and location_plane != host_plane:
                        raise UnsupportedCapability(
                            "hole_location_plane",
                            "hole locations must share one explicit sketch plane",
                        )
                    positions.append({"mm": position})
                    host_plane = location_plane
                    attachment = (
                        sketch_by_source.get(location_query.source_sketch or "", {}).get("attachment")
                        if isinstance(location_query.source_sketch, str) else None
                    )
                    if attachment is not None and not isinstance(attachment, dict):
                        raise UnsupportedCapability("hole_location_attachment", "hole location sketch attachment is invalid")
                    if host_attachment is not None and attachment != host_attachment:
                        raise UnsupportedCapability("hole_location_attachment", "hole locations must share one runtime attachment")
                    host_attachment = attachment
                if not positions or host_plane is None: raise ValueError("hole has no resolved locations")
                frame = {**host_plane, "y_dir": _y_dir(host_plane)}
                if _bool(p.get("oppositeDirection")):
                    if host_attachment is not None:
                        raise UnsupportedCapability("hole_location_attachment", "attached hole workplane does not yet support oppositeDirection")
                    frame = {**frame, "normal": [-v for v in frame["normal"]]}
                style = str(p.get("style") or "SIMPLE").split(".")[-1].lower(); end = str(p.get("endStyle") or "BLIND").upper()
                standard_through_diameter = _standard_tapped_through_bore_diameter(p, style, end)
                condition = "through_all_both" if "BOTH" in end else "through_all" if "THROUGH" in end or standard_through_diameter is not None else "blind"
                depth_value = p.get("holeDepth") or p.get("tappedDepth")
                if condition == "blind" and depth_value is None: raise ValueError("blind hole depth is unresolved")
                depth = _number(depth_value, True) if depth_value is not None else 1.0
                condition_code = {"blind": 0, "through_all": 1, "through_all_both": 2}[condition]
                hole_params: dict[str, Any] = {"hole_type": style, "diameter_mm": standard_through_diameter or _number(p.get("holeDiameter"), True), "depth_mm": depth, "end_condition": {"type": condition, "solidworks_code": condition_code}, "positions": positions, "host_face": host_attachment if host_attachment is not None else {"frame": frame}}
                if style.upper() in {"COUNTERSINK", "C_SINK"}:
                    hole_params["countersink"] = {"diameter_mm": _number(p.get("countersinkDiameter") or p.get("cSinkDiameter") or p.get("majorDiameter"), True), "angle_rad": math.radians(_number(p.get("countersinkAngle") or p.get("cSinkAngle") or 90.0))}
                if standard_through_diameter is None and style.upper() in {"COUNTERBORE", "C_BORE"}:
                    hole_params["counterbore"] = {"diameter_mm": _number(p.get("counterboreDiameter") or p.get("cBoreDiameter") or p.get("majorDiameter"), True), "depth_mm": _number(p.get("counterboreDepth") or p.get("cBoreDepth"), True)}
                if _bool(p.get("isTappedThrough")) or p.get("tapSize") is not None: hole_params["thread"] = {"source": "CADFS", "decorative": True}
                if p.get("scope") is None:
                    raise UnsupportedCapability(
                        "hole_scope_body_source",
                        "current CDSL CADFS hole lowering requires an explicit scope",
                    )
                hole_params["scope_feature_id"] = _hole_scope_body_source(
                    p["scope"], previous, body_transform_aliases, lowered_body_members,
                )
                feature = {"id": fid, "name": item.feature_id, "atomic_id": "hole_wizard", "depends_on": depends, "params": hole_params, "execution_status": "supported"}
            elif item.operation == "circularPattern":
                sources = _pattern_source_features(p.get("entities"), previous)
                sources = _pattern_body_history_sources(
                    p.get("entities"), sources, previous, feature_by_id,
                    body_transform_aliases,
                )
                axis = _circular_pattern_axis(p.get("axis"), feature_frames, sketch_by_source, entity_by_sketch)
                count = int(_number(p.get("instanceCount")))
                if count < 1:
                    raise ValueError("circular pattern instanceCount must be positive")
                operation = str(p.get("operationType") or "NEW").split(".")[-1].upper()
                operation_mode = "remove" if any(value in operation for value in ("REMOVE", "CUT")) else "add"
                if operation_mode == "remove":
                    for source in sources:
                        source_feature = feature_by_id.get(source)
                        if source_feature is None:
                            raise ValueError("circular remove pattern source is unresolved")
                        _pattern_remove_source(source_feature)
                feature = {
                    "id": fid,
                    "name": item.feature_id,
                    "atomic_id": "pattern_circular",
                    "depends_on": list(dict.fromkeys(sources + depends)),
                    "params": {
                        "source_feature_ids": sources,
                        "axis": axis,
                        "pattern_count": count,
                        "sweep_angle_deg": _number(p.get("angle", 360.0)),
                        "operation_mode": operation_mode,
                    },
                    "execution_status": "supported",
                }
            elif item.operation == "mirror":
                owners = []
                mirror_current_body = False
                for call in walk_calls(p.get("entities")):
                    if call.name == "makeQuery" and call.args:
                        owner = symbolic_string(call.args[0]);
                        if "F" in owner:
                            source_id = "f_" + owner[owner.find("F"):].split(".", 1)[0]
                            if source_id in previous and source_id not in owners: owners.append(source_id)
                        query = parse_query(call)
                        if query.topology_type == "SWEPT_BODY" and query.kind in {"body", "entitytype.body"}:
                            mirror_current_body = True
                if not owners: raise ValueError("mirror source features are unresolved")
                plane_query = p.get("mirrorPlane"); plane_info = parse_query(plane_query); plane_owner = f"f_{plane_info.owner_feature}" if plane_info.owner_feature else None
                if plane_owner and any(existing["id"] == plane_owner and existing["atomic_id"] == "reference_plane" for existing in features):
                    mirror_plane = {"kind": "plane", "owner_feature_id": plane_owner, "stable_id": f"cadfs_{fid}_plane", "source": "runtime_snapshot", "confidence": 1.0, "selector_intent": _explicit_datum_selector_intent(plane_query, kind="plane")}
                    source_plane = feature_frames.get(plane_info.owner_feature or "", {}).get("start")
                    if source_plane is None: raise ValueError("mirror plane frame is unresolved")
                else:
                    plane = _mirror_plane_from_query(
                        plane_query,
                        feature_frames,
                        sketch_by_source,
                        entity_by_sketch,
                        feature_by_id,
                        sketches_by_id,
                        previous,
                        owners,
                        model.featurescript_version,
                    )
                    if plane is None: raise ValueError("mirror plane is not a default or reference plane")
                    plane_owner = f"{fid}_plane"
                    features.append({"id": plane_owner, "name": f"{item.feature_id} plane", "atomic_id": "reference_plane", "depends_on": depends, "params": {"plane": plane}, "execution_status": "supported"})
                    previous.append(plane_owner)
                    mirror_plane = {"kind": "plane", "owner_feature_id": plane_owner, "stable_id": f"cadfs_{fid}_plane", "source": "runtime_snapshot", "confidence": 1.0, "selector_intent": _explicit_datum_selector_intent(plane_query, kind="plane")}
                    source_plane = plane
                feature = {"id": fid, "name": item.feature_id, "atomic_id": "pattern_mirror", "depends_on": list(dict.fromkeys(owners + [plane_owner])), "params": {"source_feature_ids": owners, "mirror_plane": mirror_plane}, "selectors": [mirror_plane], "execution_status": "supported"}
                if mirror_current_body: feature["params"]["mirror_current_body"] = True
                # COPY(CAP_FACE) query 属于 pattern 的特定 instance，不能直接回退到
                # source loft 的端盖。保存镜像变换和 source feature，供后续草图
                # 在 lowering 期从 CADFS provenance 复算物理端盖 frame。
                feature_frames[item.feature_id] = {
                    "copy_transform": {"type": "mirror", "plane": source_plane},
                    "copy_source_features": [source[2:] for source in owners],
                }
            else:
                raise ValueError(f"operation mapping not implemented: {item.operation}")
            features.append(feature); feature_by_id[fid] = feature; feature_source_by_id[fid] = item.feature_id
            if (
                item.operation == "transform"
                and feature.get("atomic_id") == "transform_bodies"
                and not bool(feature["params"].get("make_copy"))
                and not feature["params"].get("pattern_instance_refs")
            ):
                _record_non_copy_body_successors(
                    body_transform_aliases,
                    list(feature["params"].get("source_feature_ids") or ()),
                    fid,
                )
            _record_single_body_successor(
                body_transform_aliases,
                single_body_successor_state,
                feature,
            )
            _record_lowered_body_members(lowered_body_members, feature)
            if (
                item.operation == "extrude"
                and surface_profile_sketch is not None
                and not pure_surface_operation
            ):
                features.append(surface_feature)
                surface_profiles.append({
                    "profile": deepcopy(surface_profile_sketch["profile"]),
                    "workplane": dict(surface_profile_sketch["workplane"]),
                    **surface_feature["params"],
                })
            if item.operation == "extrude" and pure_surface_operation:
                # A surface shell has no CAP/SWEPT body lifecycle. Do not let
                # subsequent source queries inherit a static prism frame.
                feature_frames.pop(item.feature_id, None)
            if item.operation != "assignVariable":
                previous.append(fid)
        except UnsupportedCapability as exc:
            diagnostics.append({"code": "unsupported_engine_capability", "capability": exc.capability, "feature_id": item.feature_id, "operation": item.operation, "message": str(exc)}); complete = False
        except Exception as exc:
            diagnostics.append({"code": "feature_deferred", "feature_id": item.feature_id, "operation": item.operation, "message": str(exc)}); complete = False
    if not features: return LoweringResult(None, "deferred_no_executable_feature", diagnostics, history)
    source_featurescript = {
        **({"version": model.featurescript_version} if model.featurescript_version else {}),
        **({"standard_library": model.standard_library} if model.standard_library else {}),
        **({"standard_library_version": model.standard_library_version} if model.standard_library_version else {}),
        **({"standard_library_imports": deepcopy(model.standard_library_imports)} if model.standard_library_imports else {}),
    }
    cdsl = {"schema": "cad.cdsl.llm.v1", "schema_version": "1.1.0", "kind": "part", "part_id": model.sample_id,
            "meta": {"unit": "mm", "source": "CADFS", "provenance": provenance, "capability_gaps": sorted({d.get("operation") for d in diagnostics if d.get("operation")}),
                     "source_featurescript": source_featurescript},
            "geometry": {"sketches": sketches}, "features": features}
    _finalize_selector_intents(cdsl, model)
    return LoweringResult(cdsl, "converted_complete" if complete else "converted_partial", diagnostics, history)