unicad-kit 0.1.0__py3-none-any.whl

convert/adapters/freecad/EditRead/Sketch/SketchGraph.py

@@ -0,0 +1,152 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+from collections.abc import Collection, Iterable
+from xml.etree.ElementTree import Element
+
+from convert.adapters.freecad.EditRead.EditPlacement import CheckEditFrame
+from convert.adapters.freecad.EditRead.Formula.SheetScaffold import CheckEmptyProxy
+from convert.adapters.freecad.EditRead.Sketch.SketchDefaults import (
+    CheckExtensions,
+    CheckSketchOpts,
+    KSketchObjExtra,
+)
+from convert.adapters.freecad.EditRead.XmlField import CheckNoEditExpr, EditScalar
+from convert.adapters.freecad.Native import NativeObject, ParseObjects
+from interchange.geometry.models.Transform import KTransformIdentity
+
+# these mutable properties are validated separately or carry only presentation state
+KCheckedElsewhere = frozenset(
+    {
+        "Label",
+        "Visibility",
+        "KitManifestData",
+        "KitManifestSHA256",
+        "Placement",
+        "Geometry",
+        "Constraints",
+        "Shape",
+        "InternalShape",
+        "cells",
+        "columnWidths",
+        "rowHeights",
+    }
+)
+
+
+# comparing the generated property payload avoids trusting replacement native links or formulas
+def IsSameNode(Actual: Element, Expected: Element) -> bool:
+    return (
+        Actual.tag == Expected.tag
+        and Actual.attrib == Expected.attrib
+        and (Actual.text or "").strip() == (Expected.text or "").strip()
+        and len(Actual) == len(Expected)
+        and all(
+            IsSameNode(Value, Original)
+            for Value, Original in zip(Actual, Expected, strict=True)
+        )
+    )
+
+
+# native saves can add only the expected typed defaults for each generated object
+def CheckObjFields(
+    Actual: NativeObject,
+    Expected: NativeObject,
+    *,
+    Mutable: Collection[str] = (),
+    Optional: Collection[str] = (),
+) -> None:
+    Extra = KSketchObjExtra.get(Actual.type_id, {})
+    Common = {
+        "Label2": "App::PropertyString",
+        "ExpressionEngine": "App::PropertyExpressionEngine",
+    }
+    if not Expected.properties.keys() - Optional <= Actual.properties.keys():
+        raise ValueError("FreeCAD editable sketch object is missing a native property")
+    for NameValue, Property in Actual.properties.items():
+        Original = Expected.properties.get(NameValue)
+        TypeName = (
+            Original.get("type")
+            if Original is not None
+            else Extra.get(NameValue, Common.get(NameValue))
+        )
+        if TypeName is None or Property.get("type") != TypeName:
+            raise ValueError(
+                f"FreeCAD editable sketch {Actual.name}.{NameValue} native property changed"
+            )
+        if (
+            Original is not None
+            and NameValue not in KCheckedElsewhere
+            and NameValue not in Mutable
+            and (
+                len(Property) != len(Original)
+                or not all(
+                    IsSameNode(Value, OldValue)
+                    for Value, OldValue in zip(Property, Original, strict=True)
+                )
+            )
+        ):
+            raise ValueError(
+                f"FreeCAD editable sketch {Actual.name}.{NameValue} binding changed"
+            )
+        if NameValue not in {"Shape", "InternalShape"} and any(
+            Value.get("file") for Value in Property.iter()
+        ):
+            raise ValueError(
+                "FreeCAD editable sketch has additional native file references"
+            )
+
+
+# unrelated carrier objects retain empty default behavior while sketch options stay fixed
+def CheckObjState(Actual: NativeObject, Expected: NativeObject) -> None:
+    CheckExtensions(Actual)
+    CheckEmptyProxy(Actual)
+    if (
+        "ExpressionEngine" in Actual.properties
+        and "ExpressionEngine" not in Expected.properties
+    ):
+        CheckNoEditExpr(Actual)
+    if Actual.type_id == "Sketcher::SketchObject":
+        CheckSketchOpts(Actual)
+    if Actual.type_id == "Part::Feature":
+        CheckEditFrame(Actual, "Placement", KTransformIdentity, Optional=True)
+    if (
+        Actual.type_id == "App::Plane"
+        and "Role" in Actual.properties
+        and EditScalar(Actual, "Role", "App::PropertyString", "String")
+    ):
+        raise ValueError("FreeCAD editable sketch plane role changed")
+
+
+# exact generated objects and dependency sets delimit all mutable sketch state
+def ReadSketchGraph(
+    RootValue: Element, Template: Element
+) -> tuple[dict[str, NativeObject], dict[str, NativeObject]]:
+    Objects = {Value.name: Value for Value in ParseObjects(RootValue)}
+    Expected = {Value.name: Value for Value in ParseObjects(Template)}
+    if Objects.keys() != Expected.keys():
+        raise ValueError(
+            "FreeCAD editable sketch has an additional or missing native object"
+        )
+    for NameValue, Actual in Objects.items():
+        Original = Expected[NameValue]
+        if Actual.type_id != Original.type_id or set(Actual.dependencies) != set(
+            Original.dependencies
+        ):
+            raise ValueError("FreeCAD editable sketch native dependency graph changed")
+        CheckObjFields(Actual, Original)
+        CheckObjState(Actual, Original)
+    return Objects, Expected
+
+
+# indexing native identities once keeps multi sketch readback linear
+def IndexSketchObjs(Objects: Iterable[NativeObject]) -> dict[str, NativeObject]:
+    Result: dict[str, NativeObject] = {}
+    for Native in Objects:
+        if Native.type_id not in {"App::Plane", "Sketcher::SketchObject"}:
+            continue
+        Identity = EditScalar(Native, "KitId", "App::PropertyString", "String")
+        if not Identity or Identity in Result:
+            raise ValueError("FreeCAD editable sketch native identity is ambiguous")
+        Result[Identity] = Native
+    return Result

convert/adapters/freecad/EditRead/Sketch/SketchParams.py

@@ -0,0 +1,61 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+from collections.abc import Mapping
+from dataclasses import replace as Replace
+
+from convert.adapters.freecad.Archive import ParamCatalog
+from convert.adapters.freecad.EditRead.EditSheet import EditCells
+from convert.adapters.freecad.EditRead.Formula.SavedLiteral import ReadSavedLeaf
+from convert.adapters.freecad.EditRead.Formula.SavedQuantity import (
+    KeepQuantity,
+    KCanonicalUnits,
+)
+from convert.adapters.freecad.EditRead.Formula.SheetLayout import CheckSheetShape
+from convert.adapters.freecad.Native import NativeObject
+from convert.geometry.Formula.FormulaUnits import GetQuantity, IsMatchingQty
+from interchange.records.RecordParameter import Parameter
+
+
+# only driving dimensions may take their new literal values from the worksheet
+def ReadSketchVals(
+    Sheet: NativeObject,
+    Catalog: ParamCatalog,
+    Original: tuple[Parameter, ...],
+    Drivers: Mapping[str, bool],
+) -> dict[str, Parameter]:
+    Cells = EditCells(Sheet, True)
+    CheckSheetShape(Sheet, Cells, Catalog)
+    Result: dict[str, Parameter] = {}
+    for ParamValue in Original:
+        Content = Cells[Catalog.Aliases[ParamValue.id]].get("content", "")
+        if not Content.startswith("="):
+            raise ValueError(
+                "FreeCAD editable sketch dimension has no live worksheet quantity"
+            )
+        Updated = ReadSavedLeaf(ParamValue, Content[1:])
+        if not Drivers[ParamValue.id] and Updated is not ParamValue:
+            raise ValueError(
+                "FreeCAD editable sketch reference worksheet value was changed"
+            )
+        Result[ParamValue.id] = Updated
+    return Result
+
+
+# measured reference dimensions follow corroborated geometry instead of stale worksheet values
+def KeepSketchRef(ParamValue: Parameter, Measure: float) -> Parameter:
+    Quantity = GetQuantity(ParamValue.value)
+    Expression = ParamValue.expression
+    if Quantity is None or Expression is None:
+        raise ValueError(
+            "FreeCAD editable sketch reference dimension has no typed quantity"
+        )
+    NewQuantity = (Measure, Quantity[1])
+    if IsMatchingQty(NewQuantity, ParamValue.value):
+        return ParamValue
+    UnitValue = KCanonicalUnits[Quantity[1]]
+    return Replace(
+        ParamValue,
+        value=KeepQuantity(ParamValue.value, NewQuantity),
+        expression=Replace(Expression, source=f"{Measure:.17g} {UnitValue}"),
+    )

convert/adapters/freecad/EditRead/Sketch/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt

convert/adapters/freecad/EditRead/XmlField.py

@@ -0,0 +1,95 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+from math import isfinite as IsFinite
+from re import compile as CompilePattern
+from xml.etree.ElementTree import Element
+
+from convert.adapters.freecad.Native import NativeObject
+
+# strict numeric tokens prevent permissive fallback values from concealing archive edits
+KEditNumber = CompilePattern(
+    r"[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?"
+)
+
+
+# duplicate child records cannot establish which value the native object used
+def OnlyEditChild(Parent: Element, TagName: str) -> Element:
+    if len(Parent) != 1 or Parent[0].tag != TagName:
+        raise ValueError(
+            f"FreeCAD editable {Parent.get('name', Parent.tag)} has an invalid {TagName} record"
+        )
+    return Parent[0]
+
+
+# proof reads declared native property types without silent coercion or missing defaults
+def EditChild(
+    ObjectValue: NativeObject, NameValue: str, TypeName: str, ChildName: str
+) -> Element:
+    PropValue = ObjectValue.properties.get(NameValue)
+    if PropValue is None or PropValue.get("type") != TypeName:
+        raise ValueError(
+            f"FreeCAD editable {ObjectValue.name}.{NameValue} has a missing or changed property type"
+        )
+    return OnlyEditChild(PropValue, ChildName)
+
+
+# missing values differ from explicitly empty native links
+def EditAttr(NodeValue: Element, AttrName: str) -> str:
+    TextValue = NodeValue.get(AttrName)
+    if TextValue is None:
+        raise ValueError(f"FreeCAD editable {NodeValue.tag} lacks {AttrName}")
+    return TextValue
+
+
+# quantities from validated xml must still have a finite exact numeric representation
+def EditFloat(NodeValue: Element, AttrName: str) -> float:
+    TextValue = EditAttr(NodeValue, AttrName)
+    if len(TextValue) > 128 or KEditNumber.fullmatch(TextValue) is None:
+        raise ValueError(
+            f"FreeCAD editable {NodeValue.tag}.{AttrName} is not a numeric value"
+        )
+    Number = float(TextValue)
+    if not IsFinite(Number):
+        raise ValueError(f"FreeCAD editable {NodeValue.tag}.{AttrName} is nonfinite")
+    return Number
+
+
+# simple values share the strict typed property and child qualification
+def EditScalar(
+    ObjectValue: NativeObject, NameValue: str, TypeName: str, ChildName: str
+) -> str:
+    return EditAttr(EditChild(ObjectValue, NameValue, TypeName, ChildName), "value")
+
+
+# native depth and placement expressions must retain their single direct reference
+def CheckEditExpr(ObjectValue: NativeObject, PathValue: str, Expected: str) -> None:
+    Engine = EditChild(
+        ObjectValue,
+        "ExpressionEngine",
+        "App::PropertyExpressionEngine",
+        "ExpressionEngine",
+    )
+    Expression = OnlyEditChild(Engine, "Expression")
+    if (
+        Engine.get("count") != "1"
+        or Expression.get("path") != PathValue
+        or Expression.get("expression") != Expected
+    ):
+        raise ValueError(
+            f"FreeCAD editable {ObjectValue.name}.{PathValue} expression binding changed"
+        )
+
+
+# undriven saved objects must not acquire a second expression path
+def CheckNoEditExpr(ObjectValue: NativeObject) -> None:
+    Engine = EditChild(
+        ObjectValue,
+        "ExpressionEngine",
+        "App::PropertyExpressionEngine",
+        "ExpressionEngine",
+    )
+    if len(Engine) or Engine.get("count") != "0":
+        raise ValueError(
+            f"FreeCAD editable {ObjectValue.name} property expressions changed"
+        )

convert/adapters/freecad/EditRead/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt

convert/adapters/freecad/EditRev/ApplyRevEdit.py

@@ -0,0 +1,59 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+from dataclasses import replace as Replace
+
+from convert.adapters.freecad.EditRev.RebuildRevDoc import RebuildRevDoc
+from convert.adapters.freecad.EditRev.RevAngles import ReadRevAngles
+from convert.adapters.freecad.EditRing.RingChange import CheckRingEdit
+from interchange.document.models.DocumentModel import CadDocument
+from interchange.features.FeatureAngleRev import AngularRevolve
+from interchange.features.RevolveSpan import GetAngleSpan
+from interchange.geometry.models.Sketch import Sketch
+from interchange.records.RecordParameter import Expression, Parameter
+
+
+# keep original native ownership and literal spelling when a saved angle is unchanged
+def SetRevAngle(Param: Parameter, Radians: float, SourceText: str) -> Parameter:
+    if Param.value.value == Radians:
+        return Param
+    return Replace(
+        Param,
+        value=Replace(Param.value, value=Radians),
+        expression=Expression(SourceText, language="freecad"),
+    )
+
+
+# one neutral rebuild keeps the edited controls and the original solid identity together
+def ApplyRevEdit(
+    DocValue: CadDocument,
+    Profile: Sketch,
+    Along: tuple[float, str],
+    Against: tuple[float, str] | None,
+) -> CadDocument:
+    Feature = DocValue.feature_timeline[-1]
+    Definition = Feature.definition
+    if not isinstance(Definition, AngularRevolve):
+        raise ValueError("FreeCAD editable Revolve source definition is unavailable")
+    if (Definition.AgainstParameterId is None) != (Against is None):
+        raise ValueError("FreeCAD editable Revolve against angle binding changed")
+    AngleEdits = {Definition.AlongParameterId: Along}
+    if Definition.AgainstParameterId is not None and Against is not None:
+        AngleEdits[Definition.AgainstParameterId] = Against
+    Parameters = tuple(
+        SetRevAngle(Value, *AngleEdits[Value.id]) for Value in DocValue.parameters
+    )
+    (Original,) = DocValue.sketches
+    if Profile == Original and Parameters == DocValue.parameters:
+        return DocValue
+    if Profile != Original:
+        CheckRingEdit(Original, Profile)
+    AlongValue, AgainstValue = ReadRevAngles(Feature, Definition, Parameters)
+    SpanValue = GetAngleSpan(AlongValue, AgainstValue, Definition.SideMode)
+    (PlaneValue,) = DocValue.support_planes
+    return RebuildRevDoc(
+        Replace(DocValue, parameters=Parameters),
+        Profile,
+        PlaneValue.transform,
+        SpanValue,
+    )

convert/adapters/freecad/EditRev/RebuildRevDoc.py

@@ -0,0 +1,48 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+from dataclasses import replace as Replace
+
+from convert.formats.Fusion.Revolves.BuildRevGeom import BuildRevGeom
+from interchange.document.models.DocumentModel import CadDocument
+from interchange.features.FeatureAngleRev import AngularRevolve
+from interchange.features.FeaturePlaneRev import PlaneRevolve
+from interchange.geometry.models.Sketch import Sketch
+from interchange.geometry.models.Transform import Transform
+
+
+# angular and plane driven edits regenerate one exact solid with its original identity
+def RebuildRevDoc(
+    DocValue: CadDocument,
+    Profile: Sketch,
+    Frame: Transform,
+    SpanValue: tuple[float, float],
+) -> CadDocument:
+    Feature = DocValue.feature_timeline[-1]
+    Definition = Feature.definition
+    if not isinstance(Definition, (AngularRevolve, PlaneRevolve)):
+        raise ValueError("FreeCAD editable Revolve source definition is unavailable")
+    (BodyValue,) = DocValue.bodies
+    Model, Volume, AreaValue, Bounds = BuildRevGeom(
+        BodyValue.id, Feature, Definition, SpanValue, Profile, Frame
+    )
+    if len(Model.regions) != 1 or Model.validate(frozenset({BodyValue.id})):
+        raise ValueError("FreeCAD editable Revolve rebuilt an invalid solid")
+    Topology = Replace(
+        BodyValue.topology,
+        solid_count=len(Model.regions),
+        shell_count=len(Model.shells),
+        face_count=len(Model.faces),
+        edge_count=len(Model.edges),
+        vertex_count=len(Model.vertices),
+        volume=Volume,
+        surface_area=AreaValue,
+        bounding_box=Bounds,
+        valid=True,
+    )
+    return Replace(
+        DocValue,
+        sketches=(Profile,),
+        bodies=(Replace(BodyValue, topology=Topology),),
+        brep=Model,
+    )

convert/adapters/freecad/EditRev/ReconcileRev.py

@@ -0,0 +1,84 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+from collections.abc import Mapping
+from xml.etree.ElementTree import Element
+from zipfile import ZipFile, ZipInfo
+
+from convert.adapters.freecad.EditableRev import ReadEditRevolve
+from convert.adapters.freecad.EditAxisRev.AxisRevBinding import KAxisRevBinding
+from convert.adapters.freecad.EditAxisRev.ReconcileAxis import ReconcileAxis
+from convert.adapters.freecad.EditBodyRev.BodyRevBinding import KBodyRevBinding
+from convert.adapters.freecad.EditBodyRev.BodyRevPlan import ReadBodyRev
+from convert.adapters.freecad.EditBodyRev.ReconcileBody import ReconcileBody
+from convert.adapters.freecad.EditBinding import HasLegacyEdit, ReadEditBinding
+from convert.adapters.freecad.EditRead.Revolve.ReadRevFields import ReadRevFields
+from convert.adapters.freecad.EditRev.ApplyRevEdit import ApplyRevEdit
+from convert.adapters.freecad.EditRev.RevBinding import KRevBinding
+from convert.adapters.freecad.EditRev.RevCacheProof import CheckRevSolid, CheckRevWire
+from interchange.document.models.DocumentModel import CadDocument
+from interchange.features.FeatureAngleRev import AngularRevolve
+
+
+# only a saved solid and profile consistent with all native controls may replace the snapshot
+def ReconcileRev(
+    DocValue: CadDocument,
+    Manifest: Mapping[str, object],
+    RootValue: Element,
+    Archive: ZipFile,
+    Members: Mapping[str, ZipInfo],
+) -> CadDocument:
+    Binding = ReadEditBinding(RootValue, KRevBinding)
+    AxisBinding = ReadEditBinding(RootValue, KAxisRevBinding)
+    BodyBinding = ReadEditBinding(RootValue, KBodyRevBinding)
+    Feature = DocValue.feature_timeline[-1] if DocValue.feature_timeline else None
+    if BodyBinding is not None:
+        if (
+            Binding is not None
+            or AxisBinding is not None
+            or Feature is None
+            or BodyBinding != Feature.id
+        ):
+            raise ValueError(
+                "FreeCAD editable body axis binding disagrees with its source"
+            )
+        BodyPlan = ReadBodyRev(DocValue, Feature)
+        if BodyPlan is None:
+            raise ValueError("FreeCAD editable body axis has no qualified source")
+        return ReconcileBody(DocValue, Manifest, RootValue, Archive, Members, BodyPlan)
+    if AxisBinding is not None:
+        if Binding is not None:
+            raise ValueError(
+                "FreeCAD editable sketch axis binding disagrees with its source"
+            )
+        return ReconcileAxis(
+            DocValue, Manifest, RootValue, Archive, Members, AxisBinding
+        )
+    IsAngular = Feature is not None and isinstance(Feature.definition, AngularRevolve)
+    if Binding is None and not (IsAngular and HasLegacyEdit(RootValue)):
+        return DocValue
+    if Feature is None or (Binding is not None and Binding != Feature.id):
+        raise ValueError("FreeCAD editable Revolve binding disagrees with its source")
+    PlanValue = ReadEditRevolve(DocValue, Feature)
+    if PlanValue is None:
+        raise ValueError("FreeCAD editable Revolve binding has no qualified source")
+    Fields = ReadRevFields(RootValue, DocValue, PlanValue)
+    CheckRevWire(
+        Archive,
+        Members,
+        Fields.SketchEntry,
+        Fields.EmptyEntries,
+        DocValue.sketches[0],
+        Fields.ProfileSketch,
+        DocValue.support_planes[0].transform,
+    )
+    Against = (
+        (Fields.AgainstRad, Fields.AgainstText)
+        if Fields.AgainstRad is not None and Fields.AgainstText is not None
+        else None
+    )
+    Rebuilt = ApplyRevEdit(
+        DocValue, Fields.ProfileSketch, (Fields.AlongRad, Fields.AlongText), Against
+    )
+    CheckRevSolid(Archive, Members, Fields.ShapeEntry, Rebuilt)
+    return Rebuilt

convert/adapters/freecad/EditRev/RevAngles.py

@@ -0,0 +1,107 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+
+from convert.adapters.freecad.LiteralQuantity import IsLiteralQty
+from convert.formats.Fusion.FeatureLabels import KFeatureFields
+from convert.geometry.Formula.Arithmetic import (
+    EvalFormula,
+    IsLiteralExpr,
+    ReadFormula,
+)
+from convert.geometry.Formula.FormulaUnits import IsMatchingQty
+from interchange.enums.EnumFeatures import FeatureKind
+from interchange.enums.EnumValues import ParameterRole, ValueKind
+from interchange.features.FeatureAngleRev import AngularRevolve
+from interchange.features.FeatureStep import FeatureStep
+from interchange.records.RecordParameter import Parameter
+
+
+# qualified native literals can retain freecad syntax across repeated exports
+def IsRevLiteral(Param: Parameter) -> bool:
+    Expression = Param.expression
+    if Expression is None or Expression.parameter_ids:
+        return False
+    if Expression.language == "fusion":
+        Value = Param.value
+        return IsLiteralQty(Expression.source, Value.kind, Value.value, Value.unit)
+    if Expression.language != "freecad":
+        return False
+    Formula = ReadFormula(Expression.source)
+    if Formula is None or not IsLiteralExpr(Formula):
+        return False
+    Quantity = EvalFormula(Formula, {})
+    return Quantity is not None and IsMatchingQty(Quantity, Param.value)
+
+
+# source parameters must be reciprocal finite literal angular bindings owned by the feature
+def ReadRevAngle(Param: Parameter, FeatureValue: FeatureStep, RoleName: str) -> float:
+    Origin = FeatureValue.provenance
+    Evidence = Param.provenance
+    Value = Param.value
+    Attrs = Param.attributes
+    BindingId = Attrs.get("fusion.binding_id")
+    if (
+        Origin is None
+        or Origin.adapter != "fusion.f3d"
+        or not Origin.spans
+        or KFeatureFields.get(Origin.spans[0].record_kind)
+        != ("Revolve", FeatureKind.KRevolution)
+        or Evidence is None
+        or Evidence.adapter != "fusion.f3d"
+        or Param.id != f"fusion-parameter-{Evidence.native_id}"
+        or Param.owner_id != FeatureValue.id
+        or Param.role != ParameterRole.KReference
+        or Attrs.get("fusion.native_role") != RoleName
+        or Attrs.get("fusion.owner_object_id") != int(Origin.native_id)
+        or Attrs.get("fusion.owner_class_guid") != Origin.spans[0].record_kind
+        or type(BindingId) is not int
+        or BindingId <= 0
+        or Value.kind != ValueKind.KAngle
+        or Value.unit != "rad"
+        or type(Value.value) is not float
+        or not IsRevLiteral(Param)
+    ):
+        raise ValueError(
+            "FreeCAD editable Revolve requires literal native angle bindings"
+        )
+    return Value.value
+
+
+# one sided and mirrored limits preserve their distinct original control roles
+def ReadRevAngles(
+    FeatureValue: FeatureStep,
+    Definition: AngularRevolve,
+    Parameters: tuple[Parameter, ...],
+) -> tuple[float, float | None]:
+    Attrs = FeatureValue.attributes
+    AlongId, AgainstId = Definition.AlongParameterId, Definition.AgainstParameterId
+    ParamIds = {AlongId} if AgainstId is None else {AlongId, AgainstId}
+    Params = {Value.id: Value for Value in Parameters}
+    if (
+        Attrs.get("fusion.revolve.operation") != "new_body"
+        or Attrs.get("fusion.revolve.extent") != "angle"
+        or Attrs.get("fusion.revolve.sidedness") != Definition.SideMode
+        or Attrs.get("fusion.revolve.project_axis") is not False
+        or Attrs.get("fusion.revolve.solid") is not True
+        or Attrs.get("fusion.revolve.along_parameter_id") != AlongId
+        or Attrs.get("fusion.revolve.along_active") is not True
+        or Attrs.get("fusion.revolve.against_parameter_id") != AgainstId
+        or Attrs.get("fusion.revolve.target_selection_ids") != ()
+        or len(Params) != len(Parameters)
+        or len(FeatureValue.parameter_ids) != len(ParamIds)
+        or set(FeatureValue.parameter_ids) != ParamIds
+        or Params.keys() != ParamIds
+    ):
+        raise ValueError("FreeCAD editable Revolve angle ownership is unresolved")
+    Along = ReadRevAngle(Params[AlongId], FeatureValue, "AlongAngle")
+    Against = (
+        None
+        if AgainstId is None
+        else ReadRevAngle(Params[AgainstId], FeatureValue, "AgainstAngle")
+    )
+    if Definition.SideMode == "symmetric" and Along != Against:
+        raise ValueError(
+            "FreeCAD editable Revolve mirrored native angle values disagree"
+        )
+    return Along, Against

convert/adapters/freecad/EditRev/RevAxisProof.py

@@ -0,0 +1,66 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+
+from convert.formats.Fusion.DesignZip import KDesignPrefix
+from convert.formats.Fusion.Revolves.OriginAxis import KAxisGuid, KOriginGuid
+from convert.formats.Fusion.SelectionProxy import KSelectProxy
+from convert.formats.Fusion.SelectionRef import KSelectDesc, KSelectLeaf
+from convert.geometry.Revolve.SweepVector import DotVector, OffsetVector
+from interchange.features.FeatureAngleRev import AngularRevolve
+from interchange.features.FeatureStep import FeatureStep
+from interchange.geometry.models.Selection import Selection
+from interchange.geometry.models.Transform import Transform
+
+
+# source axis ownership remains exact only for the captured component origin axes
+def CheckRevAxis(
+    FeatureValue: FeatureStep,
+    Definition: AngularRevolve,
+    AxisPick: Selection,
+    FrameValue: Transform,
+) -> None:
+    Attrs = FeatureValue.attributes
+    NativeId = Attrs.get("fusion.revolve.axis_selection_id")
+    AxisId = Attrs.get("fusion.revolve.axis_object_id")
+    Origin = AxisPick.provenance
+    AxisName = AxisPick.query.get("axis")
+    if (
+        type(NativeId) is not int
+        or NativeId <= 0
+        or type(AxisId) is not int
+        or AxisId <= 0
+        or AxisPick.id != f"fusion-selection-{NativeId}-axis"
+        or AxisPick.id != Definition.AxisSelectionId
+        or FeatureValue.selection_ids != (AxisPick.id,)
+        or AxisPick.path
+        or AxisPick.query != {"kind": "component_origin_axis", "axis": AxisName}
+        or AxisName not in ("X", "Y", "Z")
+        or Origin is None
+        or Origin.adapter != "fusion.f3d"
+        or Origin.native_id != str(NativeId)
+    ):
+        raise ValueError("FreeCAD editable Revolve has no exact origin axis selection")
+    Kinds = {
+        SpanValue.record_kind
+        for SpanValue in Origin.spans
+        if SpanValue.stream == KDesignPrefix + "BulkStream.dat"
+        and SpanValue.offset >= 0
+        and SpanValue.length > 0
+    }
+    AxisValue = Definition.AxisDirection
+    Start = Definition.AxisOrigin
+    Offset = OffsetVector(Start, FrameValue.origin, -1.0)
+    if (
+        not {KSelectProxy, KSelectDesc, KSelectLeaf, KAxisGuid, KOriginGuid} <= Kinds
+        or any(abs(Value) > 1e-8 for Value in (Start.x, Start.y, Start.z))
+        or any(
+            abs(abs(Value) - float(NameValue == AxisName)) > 1e-9
+            for NameValue, Value in zip(
+                "XYZ", (AxisValue.x, AxisValue.y, AxisValue.z), strict=True
+            )
+        )
+        or abs(DotVector(FrameValue.z_axis, AxisValue)) > 1e-9
+        or abs(DotVector(FrameValue.z_axis, Offset)) > 1e-8
+    ):
+        raise ValueError("FreeCAD editable Revolve axis evidence or geometry disagrees")