diff --git a/Cargo.lock b/Cargo.lock
index 9acbdfdf0..bf2583875 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -12,6 +12,7 @@ dependencies = [
"bincode",
"bytemuck",
"cadkernel",
+ "cadkernel-constraints",
"clap",
"console_error_panic_hook",
"cosmic-text 0.15.0",
@@ -38,7 +39,6 @@ dependencies = [
"objc2 0.5.2",
"objc2-app-kit 0.2.2",
"objc2-foundation 0.2.2",
- "ocs_doc_api",
"ocs_plugin_api",
"open",
"printpdf",
@@ -79,7 +79,7 @@ checksum = "366ffbaa4442f4684d91e2cd7c5ea7c4ed8add41959a31447066e279e432b618"
[[package]]
name = "acadrust"
version = "0.5.4"
-source = "git+https://github.com/HakanSeven12/cadcodec.git?rev=f23ffc873228e5f41b876485c741e4a8ac20a67d#f23ffc873228e5f41b876485c741e4a8ac20a67d"
+source = "git+https://github.com/HakanSeven12/cadcodec.git?rev=2f2cd25832db298524fb5eb36ced5a438a877e95#2f2cd25832db298524fb5eb36ced5a438a877e95"
dependencies = [
"ahash 0.8.12",
"anyhow",
@@ -323,6 +323,15 @@ version = "1.0.103"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2a4385e2e34eb35d6b3efe798b9eb88096925d87726c0798709bf56d9ed84af3"
+[[package]]
+name = "approx"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6"
+dependencies = [
+ "num-traits",
+]
+
[[package]]
name = "arbitrary"
version = "1.4.2"
@@ -885,7 +894,7 @@ checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
[[package]]
name = "cadkernel"
version = "0.1.0"
-source = "git+https://github.com/HakanSeven12/cadkernel.git?rev=0507b720fef47bd7da0d4f777f97f1743a4f4038#0507b720fef47bd7da0d4f777f97f1743a4f4038"
+source = "git+https://github.com/HakanSeven12/cadkernel.git?rev=0a24ed40d0872ca8b3ac54bf8c280ce7824ec6c5#0a24ed40d0872ca8b3ac54bf8c280ce7824ec6c5"
dependencies = [
"acadrust",
"cavalier_contours",
@@ -893,6 +902,14 @@ dependencies = [
"spade",
]
+[[package]]
+name = "cadkernel-constraints"
+version = "0.1.0"
+source = "git+https://github.com/HakanSeven12/cadkernel.git?rev=0a24ed40d0872ca8b3ac54bf8c280ce7824ec6c5#0a24ed40d0872ca8b3ac54bf8c280ce7824ec6c5"
+dependencies = [
+ "nalgebra",
+]
+
[[package]]
name = "calloop"
version = "0.13.0"
@@ -3178,6 +3195,16 @@ dependencies = [
"num-traits",
]
+[[package]]
+name = "matrixmultiply"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f607c237553f086e7043417a51df26b2eb899d3caff94e6a67592ff992fedc7"
+dependencies = [
+ "autocfg",
+ "rawpointer",
+]
+
[[package]]
name = "maybe-rayon"
version = "0.1.1"
@@ -3358,6 +3385,33 @@ dependencies = [
"unicode-ident",
]
+[[package]]
+name = "nalgebra"
+version = "0.33.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d43ddcacf343185dfd6de2ee786d9e8b1c2301622afab66b6c73baf9882abfd"
+dependencies = [
+ "approx",
+ "matrixmultiply",
+ "nalgebra-macros",
+ "num-complex",
+ "num-rational",
+ "num-traits",
+ "simba",
+ "typenum",
+]
+
+[[package]]
+name = "nalgebra-macros"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "254a5372af8fc138e36684761d3c0cdb758a4410e938babcff1c860ce14ddbfc"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
[[package]]
name = "ndk"
version = "0.9.0"
@@ -3891,20 +3945,6 @@ dependencies = [
"objc2-foundation 0.2.2",
]
-[[package]]
-name = "ocs_doc_api"
-version = "0.1.0"
-dependencies = [
- "acadrust",
- "bincode",
- "cadkernel",
- "ocs_plugin_api",
- "serde",
- "serde_json",
- "thiserror 1.0.69",
- "toml 1.1.3+spec-1.1.0",
-]
-
[[package]]
name = "ocs_plugin_api"
version = "0.2.1"
@@ -4607,6 +4647,12 @@ dependencies = [
"objc2-quartz-core 0.3.2",
]
+[[package]]
+name = "rawpointer"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
+
[[package]]
name = "rayon"
version = "1.12.0"
@@ -5015,6 +5061,15 @@ version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+[[package]]
+name = "safe_arch"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96b02de82ddbe1b636e6170c21be622223aea188ef2e139be0a5b219ec215323"
+dependencies = [
+ "bytemuck",
+]
+
[[package]]
name = "same-file"
version = "1.0.6"
@@ -5228,6 +5283,19 @@ dependencies = [
"libc",
]
+[[package]]
+name = "simba"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c99284beb21666094ba2b75bbceda012e610f5479dfcc2d6e2426f53197ffd95"
+dependencies = [
+ "approx",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "wide",
+]
+
[[package]]
name = "simd-adler32"
version = "0.3.10"
@@ -6532,6 +6600,16 @@ dependencies = [
"web-sys",
]
+[[package]]
+name = "wide"
+version = "0.7.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce5da8ecb62bcd8ec8b7ea19f69a51275e91299be594ea5cc6ef7819e16cd03"
+dependencies = [
+ "bytemuck",
+ "safe_arch",
+]
+
[[package]]
name = "widestring"
version = "1.2.1"
diff --git a/Cargo.toml b/Cargo.toml
index 0a526489a..df90de83a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,7 +11,6 @@ members = [
"crates/ocs_web_worker",
"crates/dwg-thumbnailer",
"crates/dwg-thumbnailer-win",
- "crates/ocs_doc_api",
]
[target.'cfg(windows)'.build-dependencies]
@@ -31,8 +30,9 @@ glam = { version = "0.33", features = ["bytemuck"] }
rfd = "0.17"
clap = { version = "4", features = ["derive", "string"] }
env_logger = "0.11"
-acadrust = { git = "https://github.com/HakanSeven12/cadcodec.git", rev = "f23ffc873228e5f41b876485c741e4a8ac20a67d", features = ["serde"] }
-cadkernel = { git = "https://github.com/HakanSeven12/cadkernel.git", rev = "0507b720fef47bd7da0d4f777f97f1743a4f4038", features = ["acis", "offset"] }
+acadrust = { git = "https://github.com/HakanSeven12/cadcodec.git", rev = "2f2cd25832db298524fb5eb36ced5a438a877e95", features = ["serde"] }
+cadkernel = { git = "https://github.com/HakanSeven12/cadkernel.git", rev = "0a24ed40d0872ca8b3ac54bf8c280ce7824ec6c5", features = ["acis", "offset"] }
+cadkernel-constraints = { git = "https://github.com/HakanSeven12/cadkernel.git", rev = "0a24ed40d0872ca8b3ac54bf8c280ce7824ec6c5" }
dwg-thumbnailer = { path = "crates/dwg-thumbnailer" }
flate2 = "1"
image = { version = "0.25", default-features = false, features = ["png", "jpeg", "bmp", "tiff"] }
@@ -76,7 +76,6 @@ iced_widget = { git = "https://github.com/iced-rs/iced.git", rev = "23604ff22ab0
[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
getrandom = "0.3"
ocs_plugin_api = { path = "crates/ocs_plugin_api", features = ["host"] }
-ocs_doc_api = { path = "crates/ocs_doc_api", features = ["host", "ipc"] }
bincode = "1.3"
meshopt = "0.6.2"
i18n-embed = { version = "0.16", features = ["desktop-requester"] }
diff --git a/assets/icons/constrain/angle.svg b/assets/icons/constrain/angle.svg
new file mode 100644
index 000000000..e632dd2c8
--- /dev/null
+++ b/assets/icons/constrain/angle.svg
@@ -0,0 +1,5 @@
+
diff --git a/assets/icons/constrain/center_point.svg b/assets/icons/constrain/center_point.svg
new file mode 100644
index 000000000..cb4cb7333
--- /dev/null
+++ b/assets/icons/constrain/center_point.svg
@@ -0,0 +1,4 @@
+
diff --git a/assets/icons/constrain/coincident.svg b/assets/icons/constrain/coincident.svg
new file mode 100644
index 000000000..263234192
--- /dev/null
+++ b/assets/icons/constrain/coincident.svg
@@ -0,0 +1,4 @@
+
diff --git a/assets/icons/constrain/colinear.svg b/assets/icons/constrain/colinear.svg
new file mode 100644
index 000000000..be8d671c9
--- /dev/null
+++ b/assets/icons/constrain/colinear.svg
@@ -0,0 +1,4 @@
+
diff --git a/assets/icons/constrain/concentric.svg b/assets/icons/constrain/concentric.svg
new file mode 100644
index 000000000..d68acc43b
--- /dev/null
+++ b/assets/icons/constrain/concentric.svg
@@ -0,0 +1,4 @@
+
diff --git a/assets/icons/constrain/distance.svg b/assets/icons/constrain/distance.svg
new file mode 100644
index 000000000..278ee92ee
--- /dev/null
+++ b/assets/icons/constrain/distance.svg
@@ -0,0 +1,7 @@
+
diff --git a/assets/icons/constrain/equal.svg b/assets/icons/constrain/equal.svg
new file mode 100644
index 000000000..bee8e3fec
--- /dev/null
+++ b/assets/icons/constrain/equal.svg
@@ -0,0 +1,4 @@
+
diff --git a/assets/icons/constrain/equal_distance.svg b/assets/icons/constrain/equal_distance.svg
new file mode 100644
index 000000000..9b027b7fd
--- /dev/null
+++ b/assets/icons/constrain/equal_distance.svg
@@ -0,0 +1,8 @@
+
diff --git a/assets/icons/constrain/fixed.svg b/assets/icons/constrain/fixed.svg
new file mode 100644
index 000000000..b0e75becb
--- /dev/null
+++ b/assets/icons/constrain/fixed.svg
@@ -0,0 +1,7 @@
+
diff --git a/assets/icons/constrain/horizontal.svg b/assets/icons/constrain/horizontal.svg
new file mode 100644
index 000000000..2259c70bf
--- /dev/null
+++ b/assets/icons/constrain/horizontal.svg
@@ -0,0 +1,3 @@
+
diff --git a/assets/icons/constrain/midpoint.svg b/assets/icons/constrain/midpoint.svg
new file mode 100644
index 000000000..23ac2c0f1
--- /dev/null
+++ b/assets/icons/constrain/midpoint.svg
@@ -0,0 +1,4 @@
+
diff --git a/assets/icons/constrain/normal.svg b/assets/icons/constrain/normal.svg
new file mode 100644
index 000000000..f4ddef0cd
--- /dev/null
+++ b/assets/icons/constrain/normal.svg
@@ -0,0 +1,5 @@
+
diff --git a/assets/icons/constrain/parallel.svg b/assets/icons/constrain/parallel.svg
new file mode 100644
index 000000000..891fd41f1
--- /dev/null
+++ b/assets/icons/constrain/parallel.svg
@@ -0,0 +1,4 @@
+
diff --git a/assets/icons/constrain/perpendicular.svg b/assets/icons/constrain/perpendicular.svg
new file mode 100644
index 000000000..520becabb
--- /dev/null
+++ b/assets/icons/constrain/perpendicular.svg
@@ -0,0 +1,4 @@
+
diff --git a/assets/icons/constrain/point_on_curve.svg b/assets/icons/constrain/point_on_curve.svg
new file mode 100644
index 000000000..745845a1e
--- /dev/null
+++ b/assets/icons/constrain/point_on_curve.svg
@@ -0,0 +1,4 @@
+
diff --git a/assets/icons/constrain/symmetric.svg b/assets/icons/constrain/symmetric.svg
new file mode 100644
index 000000000..6a73ba883
--- /dev/null
+++ b/assets/icons/constrain/symmetric.svg
@@ -0,0 +1,6 @@
+
diff --git a/assets/icons/constrain/tangent.svg b/assets/icons/constrain/tangent.svg
new file mode 100644
index 000000000..7d0422129
--- /dev/null
+++ b/assets/icons/constrain/tangent.svg
@@ -0,0 +1,5 @@
+
diff --git a/assets/icons/constrain/vertical.svg b/assets/icons/constrain/vertical.svg
new file mode 100644
index 000000000..81c68fe6e
--- /dev/null
+++ b/assets/icons/constrain/vertical.svg
@@ -0,0 +1,3 @@
+
diff --git a/assets/icons/modify_align.svg b/assets/icons/modify_align.svg
new file mode 100644
index 000000000..3b661c84f
--- /dev/null
+++ b/assets/icons/modify_align.svg
@@ -0,0 +1 @@
+
diff --git a/assets/icons/modify_break.svg b/assets/icons/modify_break.svg
new file mode 100644
index 000000000..83c41029a
--- /dev/null
+++ b/assets/icons/modify_break.svg
@@ -0,0 +1 @@
+
diff --git a/assets/icons/modify_breakatpoint.svg b/assets/icons/modify_breakatpoint.svg
new file mode 100644
index 000000000..588d967f8
--- /dev/null
+++ b/assets/icons/modify_breakatpoint.svg
@@ -0,0 +1 @@
+
diff --git a/assets/icons/modify_draworder.svg b/assets/icons/modify_draworder.svg
new file mode 100644
index 000000000..a5ae19f04
--- /dev/null
+++ b/assets/icons/modify_draworder.svg
@@ -0,0 +1 @@
+
diff --git a/assets/icons/modify_hatchedit.svg b/assets/icons/modify_hatchedit.svg
new file mode 100644
index 000000000..82ea41111
--- /dev/null
+++ b/assets/icons/modify_hatchedit.svg
@@ -0,0 +1 @@
+
diff --git a/assets/icons/modify_join.svg b/assets/icons/modify_join.svg
new file mode 100644
index 000000000..687232f44
--- /dev/null
+++ b/assets/icons/modify_join.svg
@@ -0,0 +1 @@
+
diff --git a/assets/icons/modify_lengthen.svg b/assets/icons/modify_lengthen.svg
new file mode 100644
index 000000000..834650c5d
--- /dev/null
+++ b/assets/icons/modify_lengthen.svg
@@ -0,0 +1 @@
+
diff --git a/assets/icons/modify_ncopy.svg b/assets/icons/modify_ncopy.svg
new file mode 100644
index 000000000..a7ce9f0ba
--- /dev/null
+++ b/assets/icons/modify_ncopy.svg
@@ -0,0 +1 @@
+
diff --git a/assets/icons/modify_overkill.svg b/assets/icons/modify_overkill.svg
new file mode 100644
index 000000000..3ddb7bfa8
--- /dev/null
+++ b/assets/icons/modify_overkill.svg
@@ -0,0 +1 @@
+
diff --git a/assets/icons/modify_pedit.svg b/assets/icons/modify_pedit.svg
new file mode 100644
index 000000000..ef1459050
--- /dev/null
+++ b/assets/icons/modify_pedit.svg
@@ -0,0 +1 @@
+
diff --git a/assets/icons/modify_reverse.svg b/assets/icons/modify_reverse.svg
new file mode 100644
index 000000000..04c802a8d
--- /dev/null
+++ b/assets/icons/modify_reverse.svg
@@ -0,0 +1 @@
+
diff --git a/assets/icons/modify_setbylayer.svg b/assets/icons/modify_setbylayer.svg
new file mode 100644
index 000000000..9ce5827de
--- /dev/null
+++ b/assets/icons/modify_setbylayer.svg
@@ -0,0 +1 @@
+
diff --git a/assets/icons/modify_splinedit.svg b/assets/icons/modify_splinedit.svg
new file mode 100644
index 000000000..977c90ddc
--- /dev/null
+++ b/assets/icons/modify_splinedit.svg
@@ -0,0 +1 @@
+
diff --git a/crates/ocs_doc_api/ARCHITECTURE.md b/crates/ocs_doc_api/ARCHITECTURE.md
deleted file mode 100644
index 8603f8a10..000000000
--- a/crates/ocs_doc_api/ARCHITECTURE.md
+++ /dev/null
@@ -1,45 +0,0 @@
-# Document API architecture
-
-`DocApi → Document → collections → typed handles` builds DTO requests.
-`Transport::apply` carries one operation or a read-only query batch to the
-executor. The native adapter binds each request to its existing `HostSession`.
-
-For out-of-process / worker-thread plugins, `doc_api_for_host(host)` constructs a
-`DocApi` backed by `OcsPluginApiIpc`, which sends `PluginRequest::DocApiRequest`
-through the host's `PluginRequestSender` and deserializes
-`PluginResponse::DocApiResponse`. This keeps plugin code free of manual envelope
-serialization while reusing the same executor that the in-process transport uses.
-
-The executor validates inputs and dispatches through `DocApiBackend`. Backends
-must prepare fallible geometry and serialization before changing the document.
-Bulk writes prepare all entities, begin one undo record, apply the prepared
-changes, then finalize once. Cancellation releases a pending undo capture;
-it is not a rollback mechanism for partially applied writes.
-
-The native adapter reuses scene changes, document history, entity transforms
-and profile conversion. Solid construction, sweeps, booleans, meshing and mass
-properties belong to cadkernel. Profile planes preserve their source elevation
-and orientation. Geometry revisions advance when the scene changes; a compound
-operation may advance the revision more than once while recording one undo step.
-
-`Operation` and `Query` are manually maintained wire enums. Append variants;
-do not reorder them. The consistency tests verify their bincode discriminants.
-`spec/entities.toml` supplies family, constructor and method mappings. `build.rs`
-generates the API reference and binding schema. The layout snapshot is curated
-vocabulary, not a reflected binary codec schema.
-
-Layer CRUD is a document-table family, not an entity family. The API carries
-layer properties in the plain-data `LayerInfo` DTO and the host translates them
-to/from `acadrust::tables::Layer`. Layer names are case-insensitive. The host
-rejects duplicate names, deletion of layer "0" or the current layer, and removal
-of a layer that still has entities assigned.
-
-XDATA and XRECORD are serialization roundtrip families: the API carries their
-payloads as plain-data DTOs and the host stores/retrieves them without semantic
-interpretation. XDATA records are keyed by registered application name on any
-entity; XRECORD objects are standalone named dictionaries of group-code/value
-entries. Both preserve exact bytes/values across save and reload.
-
-To extend the API, update the DTO, backend, executor, facade and spec together,
-add a native behavior test, and rebuild the generated reference/schema. New
-backend methods must reject unsupported behavior explicitly.
diff --git a/crates/ocs_doc_api/Cargo.toml b/crates/ocs_doc_api/Cargo.toml
deleted file mode 100644
index 744d3559e..000000000
--- a/crates/ocs_doc_api/Cargo.toml
+++ /dev/null
@@ -1,66 +0,0 @@
-[package]
-name = "ocs_doc_api"
-version = "0.1.0"
-edition = "2021"
-description = "Object-oriented, transport-agnostic CAD entity API for OpenCADStudio plugins and hosts (v2)."
-license = "MIT"
-build = "build.rs"
-
-# Dependency wiring: pin the SAME cadkernel/acadrust git revs
-# as the host so `Body`/`EntityType` types are ABI-identical.
-[dependencies]
-serde = { version = "1", features = ["derive"] }
-bincode = "1.3"
-thiserror = "1"
-
-# Host adapters convert ObjectId to acadrust handles; kernel handles stay local.
-acadrust = { git = "https://github.com/HakanSeven12/cadcodec.git", rev = "f23ffc873228e5f41b876485c741e4a8ac20a67d", features = ["serde"], optional = true }
-cadkernel = { git = "https://github.com/HakanSeven12/cadkernel.git", rev = "0507b720fef47bd7da0d4f777f97f1743a4f4038", features = ["acis", "offset"], optional = true }
-ocs_plugin_api = { path = "../ocs_plugin_api", optional = true, features = ["host"] }
-
-[build-dependencies]
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
-toml = "1"
-
-[dev-dependencies]
-serde_json = "1"
-toml = "1"
-
-[features]
-# Default keeps the facade and DTOs independent of geometry dependencies.
-default = []
-# host: pull acadrust + cadkernel + the executor/backend trait (in-process side).
-host = ["acadrust", "cadkernel"]
-# ipc: pull ocs_plugin_api for the IPC transport adapter (plugin side).
-ipc = ["acadrust", "ocs_plugin_api"]
-# doc_api_host: convenience helper that builds a DocApi from a HostApi (IPC-only).
-doc_api_host = ["ipc"]
-
-[lib]
-name = "ocs_doc_api"
-path = "src/lib.rs"
-
-[[test]]
-name = "mock_backend"
-required-features = ["host"]
-
-[[example]]
-name = "e1_primitives_and_queries"
-required-features = ["host"]
-
-[[example]]
-name = "e2_intersect_two_solids"
-required-features = ["host"]
-
-[[example]]
-name = "e3_transform_and_chain"
-required-features = ["host"]
-
-[[example]]
-name = "e4_2d_entities_and_bulk"
-required-features = ["host"]
-
-[[example]]
-name = "e5_failure_and_guards"
-required-features = ["host"]
diff --git a/crates/ocs_doc_api/README.md b/crates/ocs_doc_api/README.md
deleted file mode 100644
index cc38a56ca..000000000
--- a/crates/ocs_doc_api/README.md
+++ /dev/null
@@ -1,139 +0,0 @@
-# ocs_doc_api
-
-Typed document operations and queries for OpenCADStudio plugins and hosts.
-The same facade runs over an in-process backend or the plugin IPC channel.
-
-```rust
-use ocs_doc_api::{ApiResult, DocApi};
-
-fn intersect_solids(api: &DocApi) -> ApiResult {
- let doc = api.document(api.active_tab());
- let a = doc.solids().create_cuboid([0.0; 3], [10.0; 3])?;
- let b = doc.solids().create_cuboid([5.0; 3], [10.0; 3])?;
- a.intersect(&b)?.volume()
-}
-```
-
-Each successful write marks the document changed and records one undo step.
-A failed operation leaves the document unchanged. Bulk creation and transforms
-prepare every entity before applying changes. Separate calls commit separately;
-`OpGroup` offers best-effort cleanup of creations, not rollback.
-
-Boolean `intersect`, `union` and `subtract` replace the first solid and erase the
-second. `intersects` only tests bounding-box overlap. Volume and centroid are
-computed by the kernel from a tessellated solid (chord tolerance 0.1 drawing units,
-angular tolerance 0.0001 radians), then cached per geometry revision. A request
-may compute at most 32 uncached mass properties; excess work returns an error.
-Bulk operations and query batches are capped at 100,000 items.
-
-Transports bind to one document tab. Typed handles from another transport and
-requests for another tab are rejected. Raw `ObjectId` values are relative to the
-receiving document. Errors are serialized as `ApiError` variants over IPC.
-
-Layer CRUD is exposed through `Document::layers()`, `create_layer(info)`,
-`update_layer(name, info)`, `delete_layer(name)` and through the `layer()` /
-`set_layer(...)` methods on every entity handle (`Line`, `Circle`, `Solid`,
-`Entity`, etc.). Layer properties are carried as the plain-data `LayerInfo` DTO
-with `LayerFlags`, `Color` and `LineWeight`. The host enforces CAD-style rules:
-layer "0" and the current layer cannot be deleted, duplicate names are rejected,
-and a layer still referenced by entities cannot be removed.
-
-XDATA and XRECORD payloads are carried as plain-data, serde-compatible DTOs
-(`XDataRecord`, `XRecordSpec`, and their value/entry types) and roundtripped
-verbatim by the host. Every `Entity` handle can read/write one XDATA record per
-registered application name via `xdata(application_name)` and `set_xdata(...)`,
-and standalone XRECORD objects can be created with `doc.entities().create_xrecord(...)`
-and updated through the `XRecord` handle.
-
-| Feature | Use |
-|---|---|
-| Default | DTOs, facade, transport trait and binding schema |
-| `host` | Kernel and entity adapters, executor, `DocApiBackend`, `InProcess` |
-| `ipc` | `OcsPluginApiIpc` adapter for a plugin connected to the host |
-| `doc_api_host` | Convenience `doc_api_for_host(&dyn HostApi) -> Option` for out-of-process / worker-thread plugins |
-
-### Connecting from a plugin
-
-For out-of-process or worker-thread plugins that receive `&dyn HostApi` (or any
-`ocs_plugin_api::host::HostApi` implementor), enable the `doc_api_host` feature
-and use the helper instead of manually serializing `DocApiEnvelope`s:
-
-```rust
-use ocs_doc_api::doc_api_for_host;
-use ocs_plugin_api::host::HostApi;
-
-fn on_dispatch(host: &mut dyn HostApi) -> Option<()> {
- let doc_api = doc_api_for_host(host)?;
- let doc = doc_api.document(host.tab_id());
- let cube = doc.solids().create_cuboid([0.0; 3], [10.0; 3]).ok()?;
- Some(())
-}
-```
-
-`doc_api_for_host` returns `None` for hosts that do not expose a
-`PluginRequestSender` (for example the in-process `HostSession`). In-process code
-should use `DocApi::in_process(backend, tab_id)` with a concrete
-`DocApiBackend`.
-
-### Plugin example: create, read, update and delete a line
-
-```rust
-use ocs_doc_api::{doc_api_for_host, ApiResult, Color, LayerInfo, LineWeight};
-use ocs_plugin_api::host::HostApi;
-
-fn draw_and_modify_line(host: &mut dyn HostApi) -> ApiResult<()> {
- // Build a DocApi from the host's plugin request channel.
- let api = doc_api_for_host(host).ok_or_else(|| {
- ocs_doc_api::ApiError::Transport("host does not expose a DocApi channel".into())
- })?;
- let doc = api.document(api.active_tab());
-
- // Ensure a target layer exists.
- let mut info = LayerInfo::new("MyLayer");
- info.color = Color::Index(1);
- info.line_weight = LineWeight::Value(25);
- let _ = doc.create_layer(&info); // ok if it already exists
-
- // Create a line on that layer.
- let line = doc.curves().create_line([0.0, 0.0, 0.0], [10.0, 0.0, 0.0])?;
- line.set_layer("MyLayer")?;
-
- // Read it back.
- assert_eq!(line.layer()?, "MYLAYER");
-
- // Move the endpoint in place (same ObjectId).
- line.transform(ocs_doc_api::PlacementSpec::at([5.0, 0.0, 0.0]))?;
-
- // Delete it; the document is left unchanged if this failed.
- line.delete()?;
- Ok(())
-}
-```
-
-### Plugin example: create a box and read its volume
-
-```rust
-use ocs_doc_api::{doc_api_for_host, ApiResult};
-use ocs_plugin_api::host::HostApi;
-
-fn create_box_and_measure(host: &mut dyn HostApi) -> ApiResult {
- let api = doc_api_for_host(host).ok_or_else(|| {
- ocs_doc_api::ApiError::Transport("host does not expose a DocApi channel".into())
- })?;
- let doc = api.document(api.active_tab());
-
- let box_ = doc.solids().create_cuboid([0.0; 3], [10.0; 3])?;
- let volume = box_.volume()?;
-
- // Boolean example: intersect with a second box.
- let other = doc.solids().create_cuboid([5.0; 3], [10.0; 3])?;
- let intersection = box_.intersect(&other)?;
- let _intersection_volume = intersection.volume()?;
-
- Ok(volume)
-}
-```
-
-See the [API reference](src/gen/api_reference.md) for constructors and methods,
-[architecture](ARCHITECTURE.md) for backend rules, and
-[binding guide](bindings/README.md) for the Python facade and transport contract.
diff --git a/crates/ocs_doc_api/bindings/README.md b/crates/ocs_doc_api/bindings/README.md
deleted file mode 100644
index deb13c55d..000000000
--- a/crates/ocs_doc_api/bindings/README.md
+++ /dev/null
@@ -1,59 +0,0 @@
-# Language bindings
-
-`src/gen/binding_schema.json` describes handle families, constructors, methods,
-arguments and operation/query mappings. `build.rs` derives it from
-`spec/entities.toml`. Its `layouts` section is manually maintained vocabulary;
-it does not contain everything needed to generate a bincode codec.
-
-Generate and test the Python facade from the repository root:
-
-```sh
-python3 crates/ocs_doc_api/bindings/python/generate.py > /tmp/ocs_doc.py
-python3 -m unittest discover -s crates/ocs_doc_api/bindings/python
-```
-
-The generated `DocApi(transport, active_tab)` expects a caller-supplied
-`transport.apply(envelope) -> Receipt`. It does not open a plugin connection.
-An envelope has `version` and a Python tuple `("Op", operation_dict)` or
-`("Queries", [query_dict])`. Enum payloads use externally tagged dictionaries,
-for example `{"CreateSolid": {"Sphere": {"centre": [0, 0, 0], "radius": 2}}}`.
-The bridge converts these objects to the Rust DTOs and bincode 1.3 wire format,
-sends `DocApiRequest { tab_id, bytes }`, and decodes `Result`.
-Host plugin API version 6 and document envelope version 1 are required.
-
-For Rust plugins compiled against `ocs_doc_api` with the `doc_api_host` feature,
-use the `doc_api_for_host` helper to build a typed `DocApi` from any
-`ocs_plugin_api::host::HostApi` that exposes a `PluginRequestSender`
-(out-of-process / worker-thread hosts):
-
-```rust
-use ocs_doc_api::doc_api_for_host;
-use ocs_plugin_api::host::HostApi;
-
-fn on_dispatch(host: &mut dyn HostApi) -> Option<()> {
- let doc_api = doc_api_for_host(host)?;
- let doc = doc_api.document(host.tab_id());
- let cube = doc.solids().create_cuboid([0.0; 3], [10.0; 3]).ok()?;
- // ...
- Some(())
-}
-```
-
-In-process plugins should use `DocApi::in_process(backend, tab_id)` with a
-concrete `DocApiBackend`; `doc_api_for_host` returns `None` for hosts that do not
-expose a `PluginRequestSender`.
-
-Decode receipt outcomes as `{"NewId": 42}` or `{"NewIds": [42, 43]}` and query
-results as externally tagged dictionaries such as `{"Volume": 12.5}`. The facade
-unwraps these into typed handles or values. Layer results use `{"Layers": [...]}`
-and `{"EntityLayer": "WALLS"}`. Layer properties (`LayerInfo`, `LayerFlags`,
-`Color`, `LineWeight`) appear as plain dictionaries in operation payloads, e.g.
-`{"CreateLayer": {"name": "Walls", "flags": {"frozen": false, "locked": false,
-"frozen_in_new_viewport": false, "off": false}, "color": {"Index": 7},
-"line_type": "Continuous", "line_weight": {"Default": null},
-"plot_style": "", "is_plottable": true}}`.
-XDATA and XRECORD payloads appear as nested externally tagged dictionaries
-(e.g. `{"XData": {"application_name": ..., "values": [...]}}` or
-`{"XRecord": {"name": ..., "entries": [...]}}`). The bridge must raise an
-exception for an error response. Transport binding determines the tab; requesting
-another tab or combining typed handles from different documents raises an error.
diff --git a/crates/ocs_doc_api/bindings/python/generate.py b/crates/ocs_doc_api/bindings/python/generate.py
deleted file mode 100644
index d361493ba..000000000
--- a/crates/ocs_doc_api/bindings/python/generate.py
+++ /dev/null
@@ -1,185 +0,0 @@
-#!/usr/bin/env python3
-"""Generate a Python facade over a caller-supplied document transport.
-
-Usage: python generate.py ../../src/gen/binding_schema.json > ocs_doc.py
-The transport converts these Python DTOs to/from the Rust wire representation.
-"""
-import json
-import sys
-from pathlib import Path
-
-HEADER = '''"""Generated document facade. See bindings/README.md for the transport contract."""
-from dataclasses import dataclass
-from typing import Any
-
-@dataclass
-class DocApiEnvelope:
- version: int
- body: Any
-
-@dataclass
-class Receipt:
- outcome: Any
- query_results: list
- new_revision: int
-
-@dataclass
-class Entity:
- id: int
- _doc: "Document"
-
- def bounds(self):
- return self._doc._apply_query({"GetBounds": {"id": self.id}})
-
- def transform(self, placement):
- self._doc._apply_op({"Transform": {"id": self.id, "placement": placement}})
-
- def delete(self):
- self._doc._apply_op({"Delete": {"id": self.id}})
-
- def layer(self):
- return self._doc._apply_query({"GetEntityLayer": {"id": self.id}})
-
- def set_layer(self, layer):
- self._doc._apply_op({"SetEntityLayer": {"id": self.id, "layer": layer}})
-'''
-
-DOCUMENT = '''
-@dataclass
-class Document:
- _transport: Any
- _tab: int
-
- def _id(self, value):
- if isinstance(value, Entity):
- if value._doc._transport is not self._transport or value._doc._tab != self._tab:
- raise ValueError("handle belongs to another document")
- return value.id
- return int(value)
-
- def _apply_op(self, op, want=None):
- receipt = self._transport.apply(DocApiEnvelope(ENVELOPE_VERSION, ("Op", op)))
- if want is None:
- return None
- if want.startswith("Vec<"):
- handle = globals()[want[4:-1]]
- return [handle(i, self) for i in receipt.outcome["NewIds"]]
- return globals()[want](receipt.outcome["NewId"], self)
-
- def _apply_query(self, query):
- receipt = self._transport.apply(DocApiEnvelope(ENVELOPE_VERSION, ("Queries", [query])))
- if len(receipt.query_results) != 1:
- raise ValueError("expected one query result")
- result = receipt.query_results[0]
- if not isinstance(result, dict) or len(result) != 1:
- raise ValueError("invalid query result")
- return next(iter(result.values()))
-
- def revision(self):
- return self._apply_query("GetGeometryRevision")
-
- def block_entities(self, block_name):
- return self._apply_query({"GetBlockEntities": {"block_name": block_name}})
-
- def solids(self): return Solids(self)
- def curves(self): return Curves(self)
- def entities(self): return Entities(self)
-
- def layers(self):
- return self._apply_query({"ListLayers": {}})
-
- def create_layer(self, info):
- self._apply_op({"CreateLayer": info})
-
- def update_layer(self, name, info):
- self._apply_op({"UpdateLayer": {"name": name, "info": info}})
-
- def delete_layer(self, name):
- self._apply_op({"DeleteLayer": {"name": name}})
-
-@dataclass
-class DocApi:
- _transport: Any
- active_tab: int = 0
-
- def document(self, tab):
- if tab != self.active_tab:
- raise ValueError("transport is bound to another tab")
- return Document(self._transport, tab)
-'''
-
-
-def render_method(method, constructor=False):
- args = method.get("args", [])
- signature = "".join(", " + a["name"] for a in args)
- variant = method.get("op") or method["query"]
- fields = {}
- for arg in args:
- name, ty = arg["name"], arg["ty"]
- if ty in ("EntityRef", "Solid", "ObjectId"):
- fields[name] = f"self._doc._id({name})"
- elif ty == "&[EntityRef]":
- fields[name] = f"[self._doc._id(p) for p in {name}]"
- else:
- fields[name] = name
- fixed = dict(method.get("fixed") or {})
- if variant in ("SolidBoolean", "GetIntersects"):
- fields = {"a": "self.id", "b": fields.pop("other"), **fields}
- fields.pop("other", None)
- elif not constructor:
- fields = {"id": "self.id", **fields}
- if variant == "Revolve":
- fields["axis"] = "(pivot, axis)"
- fields.pop("pivot")
- nested = fixed.pop("primitive", fixed.pop("curve", None))
- fields.update({key: repr(value) for key, value in fixed.items()})
- payload = "{" + ", ".join(repr(k) + ": " + v for k, v in fields.items()) + "}"
- if variant == "CreateMany":
- payload = "[{'Curve': {'Point': {'position': p}}} for p in positions]"
- elif nested:
- payload = "{" + repr(nested) + ": " + payload + "}"
- message = "{" + repr(variant) + ": " + payload + "}"
- if method.get("kind") == "query":
- call = f"self._doc._apply_query({message})"
- else:
- want = method.get("returns")
- if want == "()":
- want = None
- call = f"self._doc._apply_op({message}, {want!r})"
- return f" def {method['name']}(self{signature}):\n return {call}\n"
-
-
-def render(schema):
- out = [HEADER, f"ENVELOPE_VERSION = {schema['envelope_version']}\n"]
- handles = {name: {} for name in schema["object_model"]["handles"]}
- collections = {"solids": {}, "curves": {}, "entities": {}}
- for family in schema["families"]:
- handle = family.get("handle") or family["name"]
- for method in family.get("methods", []):
- existing = handles[handle].get(method["name"])
- if existing is not None and existing != method:
- raise ValueError(f"conflicting method: {handle}.{method['name']}")
- handles[handle][method["name"]] = method
- for constructor in family.get("constructors", []):
- collections[family["collection"]][constructor["name"]] = constructor
- # Families sharing Entity contribute to one class, preserving all methods.
- entity_methods = "\n".join(render_method(m) for m in handles.pop("Entity").values())
- out[0] += entity_methods
- for handle, methods in handles.items():
- out.append(f"\nclass {handle}(Entity):\n" + (
- "\n".join(render_method(m) for m in methods.values()) or " pass\n"))
- for collection, constructors in collections.items():
- out.append(f"\nclass {collection.title()}:\n def __init__(self, doc):\n self._doc = doc\n")
- out.extend(render_method(c, constructor=True) for c in constructors.values())
- out.append(DOCUMENT)
- return "\n".join(out)
-
-
-def main():
- default = Path(__file__).resolve().parents[2] / "src/gen/binding_schema.json"
- path = Path(sys.argv[1]) if len(sys.argv) > 1 else default
- sys.stdout.write(render(json.loads(path.read_text(encoding="utf-8"))))
-
-
-if __name__ == "__main__":
- main()
diff --git a/crates/ocs_doc_api/bindings/python/test_generate.py b/crates/ocs_doc_api/bindings/python/test_generate.py
deleted file mode 100644
index b63ed1fe8..000000000
--- a/crates/ocs_doc_api/bindings/python/test_generate.py
+++ /dev/null
@@ -1,75 +0,0 @@
-import inspect
-import json
-from pathlib import Path
-import types
-import sys
-import unittest
-
-from generate import render
-
-
-class BindingTest(unittest.TestCase):
- def setUp(self):
- self.schema = json.loads((Path(__file__).resolve().parents[2] / 'src/gen/binding_schema.json').read_text())
- self.module = types.ModuleType('generated')
- sys.modules['generated'] = self.module
- self.addCleanup(sys.modules.pop, 'generated')
- exec(render(self.schema), self.module.__dict__)
- module = self.module
-
- class Transport:
- def __init__(self):
- self.calls = []
-
- def apply(self, envelope):
- self.calls.append(envelope)
- kind, payload = envelope.body
- if kind == 'Queries':
- return module.Receipt(None, [{'Volume': 125.0}], 2)
- if 'CreateMany' in payload:
- return module.Receipt({'NewIds': [10, 11]}, [], 2)
- return module.Receipt({'NewId': 9}, [], 2)
-
- self.transport = Transport()
- self.api = module.DocApi(self.transport, active_tab=4)
- self.doc = self.api.document(4)
-
- def test_constructors_returns_and_wire_payloads(self):
- solid = self.doc.solids().create_cuboid([0, 0, 0], [5, 5, 5])
- self.assertIsInstance(solid, self.module.Solid)
- self.assertEqual(self.transport.calls[-1].body, ('Op', {'CreateSolid': {'Cuboid': {'origin': [0, 0, 0], 'size': [5, 5, 5]}}}))
- self.assertEqual(solid.volume(), 125.0)
- self.assertIsInstance(solid.intersect(solid), self.module.Solid)
- self.assertEqual(self.transport.calls[-1].body[1], {'SolidBoolean': {'a': 9, 'b': 9, 'op': 'Intersection', 'erase_sources': True}})
- points = self.doc.curves().create_points([[0, 0, 0], [1, 1, 1]])
- self.assertEqual([p.id for p in points], [10, 11])
- self.assertTrue(all(isinstance(p, self.module.Point) for p in points))
- self.doc.solids().revolve(points[0], [0, 0, 0], [0, 0, 1], 3.14)
- self.assertEqual(self.transport.calls[-1].body[1]['Revolve']['axis'], ([0, 0, 0], [0, 0, 1]))
- self.doc.solids().loft(points)
- self.assertEqual(self.transport.calls[-1].body[1], {'Loft': {'profiles': [10, 11]}})
- self.assertIsNone(points[0].delete())
-
- def test_every_schema_method_and_constructor_survives_generation(self):
- for family in self.schema['families']:
- handle = getattr(self.module, family['handle'])
- collection = getattr(self.doc, family['collection'])()
- for method in family['methods']:
- self.assertTrue(callable(getattr(handle, method['name'])))
- for constructor in family['constructors']:
- method = getattr(collection, constructor['name'])
- self.assertEqual(list(inspect.signature(method).parameters), [a['name'] for a in constructor['args']])
-
- def test_foreign_handles_and_tab_mismatch_do_not_send(self):
- with self.assertRaises(ValueError):
- self.api.document(5)
- foreign = self.module.Solid(9, self.module.DocApi(object(), 4).document(4))
- local = self.module.Solid(9, self.doc)
- for operation in [lambda: local.union(foreign), lambda: self.doc.solids().extrude(foreign, [0, 0, 1]), lambda: self.doc.solids().loft([foreign])]:
- with self.assertRaises(ValueError):
- operation()
- self.assertEqual(self.transport.calls, [])
-
-
-if __name__ == '__main__':
- unittest.main()
diff --git a/crates/ocs_doc_api/build.rs b/crates/ocs_doc_api/build.rs
deleted file mode 100644
index c951f0d66..000000000
--- a/crates/ocs_doc_api/build.rs
+++ /dev/null
@@ -1,452 +0,0 @@
-//! Regenerate the API reference and binding schema from the curated spec.
-
-use std::env;
-use std::fs;
-use std::path::PathBuf;
-
-use serde::Deserialize;
-
-#[derive(Deserialize)]
-struct Spec {
- meta: Meta,
- #[serde(default)]
- family: Vec,
- #[serde(default)]
- kernel_map: Vec,
-}
-
-#[derive(Deserialize)]
-struct Meta {
- envelope_version: u16,
-}
-
-#[derive(Deserialize)]
-struct Family {
- name: String,
- #[serde(default)]
- acadrust_variant: Option,
- #[serde(default)]
- handle: Option,
- #[serde(default)]
- collection: Option,
- #[serde(default)]
- description: Option,
- #[serde(default)]
- constructor: Vec,
- #[serde(default)]
- method: Vec,
-}
-
-#[derive(Deserialize)]
-// `op`/`fixed` are part of the spec schema (used by binding_schema consumers and
-// future codegen) even though api_reference generation doesn't read them yet.
-#[allow(dead_code)]
-struct Constructor {
- name: String,
- #[serde(default)]
- args: Vec,
- #[serde(default)]
- op: Option,
- #[serde(default)]
- fixed: Option,
- #[serde(default)]
- bulk: bool,
- #[serde(default)]
- returns: Option,
- #[serde(default)]
- status: Option,
-}
-
-#[derive(Deserialize)]
-struct Method {
- name: String,
- kind: String, // "op" | "query"
- #[serde(default)]
- op: Option,
- #[serde(default)]
- query: Option,
- #[serde(default)]
- args: Vec,
- #[serde(default)]
- returns: Option,
- #[serde(default)]
- fixed: Option,
- #[serde(default)]
- status: Option,
-}
-
-#[derive(Deserialize)]
-struct Arg {
- name: String,
- ty: String,
-}
-
-#[derive(Deserialize)]
-struct KernelMap {
- op: String,
- kernel: String,
- returns: String,
-}
-
-fn main() {
- let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
- let spec_path = manifest_dir.join("spec/entities.toml");
- println!("cargo:rerun-if-changed={}", spec_path.display());
-
- println!("cargo:rerun-if-changed=src/gen/layouts.json");
- let spec_src = fs::read_to_string(&spec_path).expect("read spec/entities.toml");
- let spec: Spec = toml::from_str(&spec_src).expect("parse spec/entities.toml");
-
- let gen_dir = manifest_dir.join("src/gen");
- fs::create_dir_all(&gen_dir).unwrap();
-
- write_if_changed(&gen_dir.join("api_reference.md"), &api_reference_md(&spec));
-
- write_if_changed(
- &gen_dir.join("binding_schema.json"),
- &binding_schema_json(&spec),
- );
-}
-
-/// Rewrite a generated file only when content changed (keeps mtime/CI stable).
-fn write_if_changed(path: &PathBuf, content: &str) {
- let unchanged = fs::read_to_string(path)
- .map(|old| old == content)
- .unwrap_or(false);
- if !unchanged {
- fs::write(path, content).unwrap_or_else(|e| panic!("write {}: {e}", path.display()));
- }
-}
-
-/// Render a method/constructor's `fixed` fields compactly (e.g.
-/// `, op="Intersection", erase_sources=true`). Empty when no fixed fields.
-fn fmt_fixed(fixed: Option<&toml::Value>) -> String {
- let Some(fixed) = fixed else {
- return String::new();
- };
- let Some(tbl) = fixed.as_table() else {
- return String::new();
- };
- if tbl.is_empty() {
- return String::new();
- }
- let parts: Vec = tbl.iter().map(|(k, v)| format!("{k}={v}")).collect();
- format!("; fixed {}", parts.join(", "))
-}
-
-fn fmt_args(args: &[Arg]) -> String {
- // Renders `(...)` with the args, or `()` for a zero-arg method.
- if args.is_empty() {
- return String::new();
- }
- args.iter()
- .map(|a| format!("{}: {}", a.name, a.ty))
- .collect::>()
- .join(", ")
-}
-
-/// The parenthesised argument list: `(a: T, b: U)` or `()` for zero args.
-fn fmt_call_args(args: &[Arg]) -> String {
- if args.is_empty() {
- return "()".to_string();
- }
- format!("({})", fmt_args(args))
-}
-
-/// The generic handle methods + cross-cutting surface (applies to every handle;
-/// documented once here rather than per-family).
-fn generic_reference_md() -> String {
- r#"## Generic methods (every handle)
-
-Every typed handle (`Solid`, `Line`, `Circle`, `Polyline`, `Point`, `ArcCurve`,
-`Ellipse`, `Spline`, `Ray`, `XLine`, `Text`, `MText`, `Dimension`, `Entity`) is a
-`Clone`, `Send`, `Sync` token `{ ObjectId, session }` and supports:
-
-- **`id()` -> `ObjectId`** — the stable entity identity.
-- **`bounds()` -> `Aabb`** — coarse bounding box (solids lift-on-miss; 2D entities
- computed; later families may be `Unsupported`).
-- **`transform(placement)`** — in-place rigid similarity (same `ObjectId`). **v1:
- solids only.**
-- **`delete()`** — remove the entity (one undo step).
-- **`layer()` -> `String`** — the name of the layer the entity is on.
-- **`set_layer(layer)`** — move the entity to an existing layer (one undo step;
- blocked if the entity or target layer is locked).
-
-`Entity` additionally has `view()` (id + kind + bounds), `as_solid()` (typed
-downcast when `kind == "Solid3D"`), and XDATA access through
-`xdata(application_name)` / `set_xdata(application_name, record)`.
-
-## Layer table
-
-Layers are a named document table, not an entity family. `Document::layers()`
-lists all layers as `Vec`. Table-level ops are `CreateLayer(info)`,
-`UpdateLayer { name, info }` and `DeleteLayer { name }`. `Entity::layer()`
-returns the layer name and `Entity::set_layer(layer)` moves the entity to an
-existing layer. The host rejects duplicate names, deletion of layer "0" or the
-current layer, and removing a layer that still has entities assigned.
-
-## Transports
-
-- **`InProcess`** (feature `host`) — drives a `DocApiBackend` directly in the host.
-- **`OcsPluginApiIpc`** (feature `ipc`) — serializes envelopes over the
- `ocs_plugin_api` `PluginRequestSender`/`PluginRequest` channel. The host routes
- `DocApiRequest { tab_id, bytes }` to the same executor.
-- **`doc_api_for_host(host)`** (feature `doc_api_host`) — convenience helper that
- builds a `DocApi` from any `ocs_plugin_api::host::HostApi` exposing a
- `PluginRequestSender` (out-of-process / worker-thread plugins).
-
-## Collections & cross-cutting
-
-- **`DocApi`** — root: `document(tab)`, `active_tab()`, `alive()`.
-- **`Document`** — `solids()` / `curves()` / `entities()` factories + lookup,
- `revision()`, `assert_revision(rev)` (read-guard), `query_batch(|q| …)` (read-only
- batch, one round-trip, **no revision bump**).
-- **`EntityCollection`** — `get(id) -> Entity`, `delete(id)`,
- `transform_many(&ids, placement)`, `delete_many(&ids)`.
-- **`OpGroup`** — best-effort client-side failure cleanup (`track` / `commit` /
- `compensate`). **Not** a transaction: no atomicity, no rollback.
-
-## Bulk ops — single op, all-or-nothing, item-capped
-
-`CreateMany` / `TransformMany` / `DeleteMany` are **single** write ops: one undo
-step, one publish, and **all-or-nothing via upfront validation** (no rollback).
-Item-capped at `BULK_ITEM_CAP = 100_000` to bound host execution. Use them for
-bulk data (N ≳ a few hundred); per-op autocommit is the right tool for
-modeling-scale work.
-
-## Semantics
-
-- **Per-op autocommit, no write transactions.** Every write op is ONE atomic host
- call = one undo step. Multi-op write transactions were removed (security/
- integrity review).
-- **Per-op atomicity.** Validate + compute geometry **before** any mutation; a
- failed op applies nothing and records no undo step. `erase_sources` booleans run
- only on success.
-- **Structured errors.** `ApiError::{Validation, Geometry, UnknownId, Unsupported,
- Transport}`; bulk validation names the failing index; a stale handle returns
- `UnknownId` (never a panic).
-
-"#
- .to_string()
-}
-
-fn status_suffix(status: Option<&str>) -> &'static str {
- match status {
- Some("unsupported") => " — **not yet supported** (returns `ApiError::Unsupported`)",
- Some("planned") => " — **planned** (no callable surface yet)",
- _ => "",
- }
-}
-
-fn api_reference_md(spec: &Spec) -> String {
- let mut s = String::new();
- s.push_str("# ocs_doc_api — API reference (auto-generated)\n\n");
- s.push_str(&format!(
- "Envelope version: `{}`\n\n",
- spec.meta.envelope_version
- ));
- s.push_str("Do NOT edit: regenerated by `build.rs` from `spec/entities.toml`.\n\n");
-
- for fam in &spec.family {
- let collection = fam.collection.as_deref().unwrap_or("-");
- let handle = fam.handle.as_deref().unwrap_or(&fam.name);
- s.push_str(&format!(
- "## `{}` (acadrust `{}`, collection `{}`)\n\n",
- handle,
- fam.acadrust_variant.as_deref().unwrap_or("-"),
- collection
- ));
- if let Some(d) = &fam.description {
- s.push_str(&format!("{d}\n\n"));
- }
-
- if !fam.constructor.is_empty() {
- s.push_str(&format!("### Constructors (`doc.{collection}()`)\n\n"));
- for c in &fam.constructor {
- let ret = c.returns.as_deref().unwrap_or(handle);
- let bulk = if c.bulk { " *(bulk op)*" } else { "" };
- let op = c.op.as_deref().unwrap_or("-");
- let fixed = fmt_fixed(c.fixed.as_ref());
- s.push_str(&format!(
- "- **{}**{} -> `{ret}`{bulk} — `{op}`{fixed}{}\n",
- c.name,
- fmt_call_args(&c.args),
- status_suffix(c.status.as_deref())
- ));
- }
- s.push('\n');
- }
-
- if !fam.method.is_empty() {
- s.push_str("### Methods\n\n");
- for m in &fam.method {
- let target = m.op.as_deref().or(m.query.as_deref()).unwrap_or("-");
- let fixed = fmt_fixed(m.fixed.as_ref());
- s.push_str(&format!(
- "- **{}**{} -> `{}` — {} `{}`{fixed}{}\n",
- m.name,
- fmt_call_args(&m.args),
- m.returns.as_deref().unwrap_or("()"),
- m.kind,
- target,
- status_suffix(m.status.as_deref())
- ));
- }
- s.push('\n');
- }
- }
-
- s.push_str(&generic_reference_md());
-
- s.push_str("## Kernel mapping\n\n| op | kernel call | returns |\n|---|---|---|\n");
- for k in &spec.kernel_map {
- s.push_str(&format!("| {} | `{}` | {} |\n", k.op, k.kernel, k.returns));
- }
- s.push('\n');
- s.push_str(&wire_vocabulary_md());
- s.push('\n');
- s.push_str(&error_and_envelope_md());
- s
-}
-
-/// The wire vocabulary section: every `Operation`/`Query` variant with its payload,
-/// read from `src/gen/layouts.json` (the curated wire-layout snapshot).
-fn wire_vocabulary_md() -> String {
- let layouts = read_layouts();
- let mut s = String::from("## Wire vocabulary\n\nEvery `Operation` is ONE atomic write op (one undo step); every `Query` is read-only (safe to batch). Variants are append-only (bincode discriminant stability). Requests ride `DocApiEnvelope`: `Op(Operation)` for a write, `Queries(Vec)` for a read batch.\n\n");
- s.push_str("### `Operation`\n\n");
- if let Some(variants) = layouts
- .get("Operation")
- .and_then(|o| o.get("enum"))
- .and_then(|v| v.as_array())
- {
- for v in variants {
- if let Some(name) = v.as_str() {
- s.push_str(&format!("- `{name}`\n"));
- }
- }
- }
- s.push_str("\n### `Query`\n\n");
- if let Some(variants) = layouts
- .get("Query")
- .and_then(|o| o.get("enum"))
- .and_then(|v| v.as_array())
- {
- for v in variants {
- if let Some(name) = v.as_str() {
- s.push_str(&format!("- `{name}`\n"));
- }
- }
- }
- s
-}
-
-/// The error model + envelope/transport section.
-fn error_and_envelope_md() -> String {
- r#"## Errors (`ApiError`)
-
-| Variant | Meaning |
-|---|---|
-| `Validation { op, reason }` | Input rejected before any document mutation. |
-| `Geometry { kind, msg }` | The kernel failed (boolean refused, invalid input, ACIS lift/lower). |
-| `UnknownId(ObjectId)` | The handle is stale / deleted / never existed (never a panic). |
-| `Unsupported(String)` | Capability not supported for this entity or backend. |
-| `Transport(String)` | The channel failed (disconnected / oversized / timeout). |
-
-`ApiError` is serializable, so IPC returns the same structured error the in-process
-executor produced.
-
-## Envelope & transport
-
-`DocApiEnvelope { version, body }` — `body` is `Op(Operation)` (a single write) or
-`Queries(Vec)` (a read batch). bincode-serialized; `version` is the crate's
-envelope version (bridges must check it). Transports: `InProcess` (host) and
-`OcsPluginApiIpc` (plugin over `ocs_plugin_api`), both behind the `Transport:
-Send + Sync` trait (`apply(envelope) -> Receipt`, `alive()`). `Receipt` carries
-`outcome` (per-op result), `query_results`, and `new_revision`.
-"#
- .to_string()
-}
-
-/// The merged, self-contained binding handover schema (§10.2). Object model +
-/// method signatures + op/query mapping + curated wire vocabulary inlined per node.
-/// The handle types for the binding schema, derived from the spec's families
-/// ("Entity" always first, then the deduped family handles in spec order).
-fn handles_for_schema(spec: &Spec) -> Vec {
- let mut out = vec!["Entity".to_string()];
- for fam in &spec.family {
- let h = fam.handle.as_deref().unwrap_or(&fam.name);
- if h != "Entity" && !out.iter().any(|x| x == h) {
- out.push(h.to_string());
- }
- }
- out
-}
-
-fn binding_schema_json(spec: &Spec) -> String {
- let registry = read_layouts();
-
- let families: Vec = spec
- .family
- .iter()
- .map(|fam| {
- let methods: Vec = fam
- .method
- .iter()
- .map(|m| {
- serde_json::json!({
- "name": m.name,
- "kind": m.kind,
- "op": m.op,
- "query": m.query,
- "args": m.args.iter().map(|a| serde_json::json!({"name": a.name, "ty": a.ty})).collect::>(),
- "returns": m.returns,
- "bulk": m.op.as_deref() == Some("CreateMany"),
- "read_only": m.kind == "query",
- "fixed": m.fixed,
- })
- })
- .collect();
- serde_json::json!({
- "name": fam.name,
- "handle": fam.handle,
- "collection": fam.collection,
- "acadrust_variant": fam.acadrust_variant,
- "methods": methods,
- "constructors": fam.constructor.iter().map(|c| serde_json::json!({
- "name": c.name, "op": c.op, "fixed": c.fixed, "bulk": c.bulk,
- "returns": c.returns.as_deref().unwrap_or(fam.handle.as_deref().unwrap_or(&fam.name)),
- "args": c.args.iter().map(|a| serde_json::json!({"name": a.name, "ty": a.ty})).collect::>()
- })).collect::>(),
- })
- })
- .collect();
-
- let schema = serde_json::json!({
- "schema": "ocs_doc_api/binding_schema",
- "envelope_version": spec.meta.envelope_version,
- "object_model": {
- "root": "DocApi",
- "document": "Document",
- "collections": ["solids", "curves", "entities"],
- // Derived from the spec's family handles (deduped, "Entity" first) so
- // new handle families appear in the handover automatically.
- "handles": handles_for_schema(spec),
- },
- "families": families,
- // Curated wire vocabulary (not a complete binary codec schema).
- "layouts": registry,
- });
-
- serde_json::to_string_pretty(&schema).expect("serialize binding schema")
-}
-
-/// Read the manually maintained wire vocabulary; malformed snapshots fail the build.
-fn read_layouts() -> serde_json::Value {
- let src = fs::read_to_string(layouts_snapshot_path()).expect("read layouts.json");
- serde_json::from_str(&src).expect("parse layouts.json")
-}
-
-fn layouts_snapshot_path() -> PathBuf {
- PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap()).join("src/gen/layouts.json")
-}
diff --git a/crates/ocs_doc_api/examples/common/mod.rs b/crates/ocs_doc_api/examples/common/mod.rs
deleted file mode 100644
index 8b7b7454b..000000000
--- a/crates/ocs_doc_api/examples/common/mod.rs
+++ /dev/null
@@ -1,710 +0,0 @@
-//! Shared in-memory `DocApiBackend` for the runnable examples.
-//!
-//! Lets the examples run without the host binary: an in-process mock document
-//! (HashMap + a kind table) behind the `InProcess` transport.
-//! Not for production use — the real backend lives in the host (`src/app/doc_api.rs`).
-
-use std::collections::HashMap;
-
-use ocs_doc_api::backend::{DocApiBackend, KernelBody};
-use ocs_doc_api::{
- normalize_layer_name, Aabb, ApiError, ApiResult, Curve2Spec, EntityView, GeometryErrorKind,
- GeometryRevision, LayerInfo, ObjectId, PlacementSpec,
-};
-
-
-#[derive(Clone)]
-pub struct MockBackend {
- next_id: u64,
- revision: u64,
- undo_steps: u32,
- bodies: HashMap,
- kinds: HashMap,
- /// Stored 2D curve specs so `bounds()` works on non-solid entities too.
- curves: HashMap,
- /// Stored text content for Text/MText annotations.
- text_values: HashMap,
- /// Stored hatch boundary loops.
- hatch_boundaries: HashMap>>,
- /// Stored dimension measurements.
- dimension_measurements: HashMap,
- /// Stored insert attributes.
- attributes_store: HashMap>,
- /// Stored viewport views (target, height).
- viewport_views: HashMap,
- /// Stored XDATA records keyed by (entity id, application name).
- xdata_store: HashMap<(ObjectId, String), ocs_doc_api::XDataRecord>,
- /// Stored XRECORD payloads keyed by entity id.
- xrecord_store: HashMap,
- /// Stored layer table.
- layers: HashMap,
- /// Layer name assigned to each entity.
- entity_layers: HashMap,
-}
-
-impl Default for MockBackend {
- fn default() -> Self {
- let mut backend = Self {
- next_id: 0,
- revision: 0,
- undo_steps: 0,
- bodies: HashMap::new(),
- kinds: HashMap::new(),
- curves: HashMap::new(),
- text_values: HashMap::new(),
- hatch_boundaries: HashMap::new(),
- dimension_measurements: HashMap::new(),
- attributes_store: HashMap::new(),
- viewport_views: HashMap::new(),
- xdata_store: HashMap::new(),
- xrecord_store: HashMap::new(),
- layers: HashMap::new(),
- entity_layers: HashMap::new(),
- };
- backend.layers.insert("0".to_string(), LayerInfo::new("0"));
- backend
- }
-}
-
-impl MockBackend {
- fn alloc(&mut self, kind: &str) -> ObjectId {
- self.next_id += 1;
- let id = ObjectId::from_u64(self.next_id);
- self.kinds.insert(id, kind.to_string());
- id
- }
- fn body(&self, id: ObjectId) -> ApiResult<&KernelBody> {
- self.bodies.get(&id).ok_or(ApiError::UnknownId(id))
- }
- #[allow(dead_code)]
- pub fn undo_steps(&self) -> u32 {
- self.undo_steps
- }
-}
-
-/// Coarse bounds for a stored 2D curve spec (mirrors the host's entity_bounds).
-fn curve_bounds(spec: &Curve2Spec) -> Aabb {
- match spec {
- Curve2Spec::Line { start, end, .. } => Aabb {
- min: [
- start[0].min(end[0]),
- start[1].min(end[1]),
- start[2].min(end[2]),
- ],
- max: [
- start[0].max(end[0]),
- start[1].max(end[1]),
- start[2].max(end[2]),
- ],
- },
- Curve2Spec::Circle { centre, radius, .. } => Aabb {
- min: [centre[0] - radius, centre[1] - radius, centre[2]],
- max: [centre[0] + radius, centre[1] + radius, centre[2]],
- },
- Curve2Spec::Point { position, .. } => Aabb {
- min: *position,
- max: *position,
- },
- Curve2Spec::Polyline { points, .. } => {
- let mut min = [f64::INFINITY; 3];
- let mut max = [f64::NEG_INFINITY; 3];
- for p in points {
- for i in 0..3 {
- min[i] = min[i].min(p[i]);
- max[i] = max[i].max(p[i]);
- }
- }
- Aabb { min, max }
- }
- Curve2Spec::Arc { centre, radius, .. } => Aabb {
- min: [centre[0] - radius, centre[1] - radius, centre[2]],
- max: [centre[0] + radius, centre[1] + radius, centre[2]],
- },
- Curve2Spec::Ellipse {
- centre, major_axis, ..
- } => {
- let r = (major_axis[0] * major_axis[0]
- + major_axis[1] * major_axis[1]
- + major_axis[2] * major_axis[2])
- .sqrt();
- Aabb {
- min: [centre[0] - r, centre[1] - r, centre[2] - r],
- max: [centre[0] + r, centre[1] + r, centre[2] + r],
- }
- }
- Curve2Spec::Spline { control_points, .. } => {
- let mut min = [f64::INFINITY; 3];
- let mut max = [f64::NEG_INFINITY; 3];
- for p in control_points {
- for i in 0..3 {
- min[i] = min[i].min(p[i]);
- max[i] = max[i].max(p[i]);
- }
- }
- Aabb { min, max }
- }
- Curve2Spec::Ray { origin, .. } | Curve2Spec::XLine { origin, .. } => Aabb {
- min: *origin,
- max: *origin,
- },
- }
-}
-
-impl DocApiBackend for MockBackend {
- fn resolve_body(&mut self, id: ObjectId) -> ApiResult {
- Ok(self.body(id)?.clone())
- }
- fn store_solid(&mut self, body: &KernelBody) -> ApiResult {
- let id = self.alloc("Solid3D");
- self.bodies.insert(id, body.clone());
- Ok(id)
- }
- fn update_solid(&mut self, id: ObjectId, body: &KernelBody) -> ApiResult<()> {
- if self.bodies.insert(id, body.clone()).is_none() {
- return Err(ApiError::UnknownId(id));
- }
- Ok(())
- }
- fn create_many(&mut self, specs: &[ocs_doc_api::EntitySpec]) -> ApiResult> {
- // Validate per-spec layers up front so the op is atomic.
- for spec in specs {
- if let Some(name) = spec.layer() {
- self.lookup_layer(name).map_err(|e| ApiError::validation(
- "CreateMany",
- e.to_string(),
- ))?;
- }
- }
- let mut next = self.clone();
- let ids = specs
- .iter()
- .map(|spec| match spec {
- ocs_doc_api::EntitySpec::Solid(spec) => {
- next.store_solid(&ocs_doc_api::geom::make_solid(spec)?)
- }
- ocs_doc_api::EntitySpec::Curve(spec) => {
- ocs_doc_api::convert::curve_spec_to_entity(spec)?;
- next.add_curve(spec)
- }
- })
- .collect::>>()?;
- next.push_undo("CreateMany");
- next.finalize_op();
- *self = next;
- Ok(ids)
- }
- fn transform_many(&mut self, ids: &[ObjectId], placement: &PlacementSpec) -> ApiResult<()> {
- let mut next = self.clone();
- for &id in ids {
- next.transform_entity(id, placement)?;
- }
- next.push_undo("TransformMany");
- next.finalize_op();
- *self = next;
- Ok(())
- }
- fn add_curve(&mut self, spec: &Curve2Spec) -> ApiResult {
- let kind = match spec {
- Curve2Spec::Line { .. } => "Line",
- Curve2Spec::Circle { .. } => "Circle",
- Curve2Spec::Polyline { .. } => "LwPolyline",
- Curve2Spec::Point { .. } => "Point",
- Curve2Spec::Arc { .. } => "Arc",
- Curve2Spec::Ellipse { .. } => "Ellipse",
- Curve2Spec::Spline { .. } => "Spline",
- Curve2Spec::Ray { .. } => "Ray",
- Curve2Spec::XLine { .. } => "XLine",
- };
- let layer = spec
- .layer()
- .map(|name| {
- self.lookup_layer(name).map(|info| info.normalized_name())
- })
- .transpose()?;
- let id = self.alloc(kind);
- self.curves.insert(id, spec.clone());
- self.entity_layers
- .insert(id, layer.unwrap_or_else(|| "0".to_string()));
- Ok(id)
- }
-
- fn lookup_layer(&self, name: &str) -> ApiResult {
- let norm = normalize_layer_name(name);
- if norm.is_empty() {
- return Err(ApiError::validation("LookupLayer", "empty layer name"));
- }
- self.layers
- .get(&norm)
- .cloned()
- .ok_or_else(|| ApiError::validation("LookupLayer", format!("layer '{name}' does not exist")))
- }
- fn add_insert(&mut self, spec: &ocs_doc_api::ops::InsertSpec) -> ApiResult {
- if spec.block_name.is_empty() {
- return Err(ApiError::validation("CreateInsert", "empty block name"));
- }
- Ok(self.alloc("Insert"))
- }
- fn add_viewport(&mut self, spec: &ocs_doc_api::ops::ViewportSpec) -> ApiResult {
- let id = self.alloc("Viewport");
- self.viewport_views
- .insert(id, (spec.view_target, spec.view_height));
- Ok(id)
- }
- fn add_text(&mut self, spec: &ocs_doc_api::ops::TextSpec) -> ApiResult {
- let id = self.alloc("Text");
- self.text_values.insert(id, spec.value.clone());
- Ok(id)
- }
- fn add_mtext(&mut self, spec: &ocs_doc_api::ops::MTextSpec) -> ApiResult {
- let id = self.alloc("MText");
- self.text_values.insert(id, spec.value.clone());
- Ok(id)
- }
- fn set_text_content(&mut self, id: ObjectId, value: &str) -> ApiResult<()> {
- if let std::collections::hash_map::Entry::Occupied(mut e) = self.text_values.entry(id) {
- e.insert(value.to_string());
- Ok(())
- } else {
- Err(ApiError::UnknownId(id))
- }
- }
- fn text_content(&self, id: ObjectId) -> ApiResult {
- self.text_values
- .get(&id)
- .cloned()
- .ok_or(ApiError::UnknownId(id))
- }
- fn add_hatch(&mut self, spec: &ocs_doc_api::ops::HatchSpec) -> ApiResult {
- let id = self.alloc("Hatch");
- self.hatch_boundaries
- .insert(id, vec![spec.boundary.clone()]);
- Ok(id)
- }
- fn hatch_boundary(&self, id: ObjectId) -> ApiResult>> {
- self.hatch_boundaries
- .get(&id)
- .cloned()
- .ok_or(ApiError::UnknownId(id))
- }
- fn add_dimension_linear(
- &mut self,
- spec: &ocs_doc_api::ops::DimensionSpec,
- ) -> ApiResult {
- let id = self.alloc("Dimension");
- let d = ((spec.first_point[0] - spec.second_point[0]).powi(2)
- + (spec.first_point[1] - spec.second_point[1]).powi(2)
- + (spec.first_point[2] - spec.second_point[2]).powi(2))
- .sqrt();
- self.dimension_measurements.insert(id, d);
- Ok(id)
- }
- fn add_dimension_radius(
- &mut self,
- spec: &ocs_doc_api::ops::DimensionRadialSpec,
- ) -> ApiResult {
- let id = self.alloc("Dimension");
- let d = ((spec.center[0] - spec.point[0]).powi(2)
- + (spec.center[1] - spec.point[1]).powi(2)
- + (spec.center[2] - spec.point[2]).powi(2))
- .sqrt();
- self.dimension_measurements.insert(id, d);
- Ok(id)
- }
- fn add_dimension_diameter(
- &mut self,
- spec: &ocs_doc_api::ops::DimensionRadialSpec,
- ) -> ApiResult {
- self.add_dimension_radius(spec)
- }
- fn add_dimension_angular(
- &mut self,
- _spec: &ocs_doc_api::ops::DimensionAngularSpec,
- ) -> ApiResult {
- let id = self.alloc("Dimension");
- self.dimension_measurements.insert(id, 90.0);
- Ok(id)
- }
- fn dimension_measurement(&self, id: ObjectId) -> ApiResult {
- self.dimension_measurements
- .get(&id)
- .copied()
- .ok_or(ApiError::UnknownId(id))
- }
- fn add_attribute_definition(
- &mut self,
- spec: &ocs_doc_api::ops::AttributeDefinitionSpec,
- ) -> ApiResult {
- if spec.tag.is_empty() {
- return Err(ApiError::validation(
- "CreateAttributeDefinition",
- "empty tag",
- ));
- }
- Ok(self.alloc("AttributeDefinition"))
- }
- fn add_dimension_angular2ln(
- &mut self,
- _spec: &ocs_doc_api::ops::DimensionAngularSpec,
- ) -> ApiResult {
- let id = self.alloc("Dimension");
- self.dimension_measurements.insert(id, 90.0);
- Ok(id)
- }
- fn add_table(&mut self, spec: &ocs_doc_api::ops::TableSpec) -> ApiResult {
- let cols = spec.data.first().map(|r| r.len()).unwrap_or(0);
- if spec.data.is_empty() || cols == 0 || spec.data.iter().any(|r| r.len() != cols) {
- return Err(ApiError::validation(
- "CreateTable",
- "table needs a non-empty rectangular grid",
- ));
- }
- Ok(self.alloc("Table"))
- }
- fn set_attribute(&mut self, id: ObjectId, tag: &str, value: &str) -> ApiResult<()> {
- if !self.entity_exists(id) {
- return Err(ApiError::UnknownId(id));
- }
- let attrs = self.attributes_store.entry(id).or_default();
- if let Some(a) = attrs.iter_mut().find(|(t, _)| t == tag) {
- a.1 = value.to_string();
- } else {
- attrs.push((tag.to_string(), value.to_string()));
- }
- Ok(())
- }
- fn attributes(&self, id: ObjectId) -> ApiResult> {
- self.attributes_store
- .get(&id)
- .cloned()
- .ok_or(ApiError::UnknownId(id))
- }
- fn block_entities(&self, _block_name: &str) -> ApiResult> {
- Ok(Vec::new())
- }
- fn add_raster_image(
- &mut self,
- _spec: &ocs_doc_api::ops::RasterImageSpec,
- ) -> ApiResult {
- Ok(self.alloc("RasterImage"))
- }
- fn loft(
- &mut self,
- sections: &[(cadkernel::space::Plane, Vec)],
- ) -> ApiResult {
- if sections.len() < 2 {
- return Err(ApiError::validation("Loft", "loft needs >= 2 profiles"));
- }
- let body = cadkernel::brep::make::cuboid([0.0, 0.0, 0.0], [1.0; 3])
- .ok_or_else(|| ApiError::geometry(GeometryErrorKind::InvalidInput, "make cuboid"))?;
- self.store_solid(&body)
- }
- fn set_viewport_view(
- &mut self,
- id: ObjectId,
- view_target: [f64; 3],
- view_height: f64,
- ) -> ApiResult<()> {
- if !self.entity_exists(id) {
- return Err(ApiError::UnknownId(id));
- }
- self.viewport_views.insert(id, (view_target, view_height));
- Ok(())
- }
- fn viewport_view(&self, id: ObjectId) -> ApiResult<([f64; 3], f64)> {
- self.viewport_views
- .get(&id)
- .copied()
- .ok_or(ApiError::UnknownId(id))
- }
- fn set_xdata(
- &mut self,
- id: ObjectId,
- application_name: &str,
- record: Option<&ocs_doc_api::XDataRecord>,
- ) -> ApiResult<()> {
- if !self.entity_exists(id) {
- return Err(ApiError::UnknownId(id));
- }
- let key = (id, application_name.to_string());
- match record {
- Some(r) => {
- self.xdata_store.insert(key, r.clone());
- }
- None => {
- self.xdata_store.remove(&key);
- }
- }
- Ok(())
- }
- fn xdata(
- &self,
- id: ObjectId,
- application_name: &str,
- ) -> ApiResult> {
- if !self.entity_exists(id) {
- return Err(ApiError::UnknownId(id));
- }
- Ok(self
- .xdata_store
- .get(&(id, application_name.to_string()))
- .cloned())
- }
- fn add_xrecord(&mut self, spec: &ocs_doc_api::XRecordSpec) -> ApiResult {
- let id = self.alloc("XRecord");
- self.xrecord_store.insert(id, spec.clone());
- Ok(id)
- }
- fn set_xrecord(&mut self, id: ObjectId, spec: &ocs_doc_api::XRecordSpec) -> ApiResult<()> {
- if !self.object_exists(id) {
- return Err(ApiError::validation(
- "SetXRecord",
- format!("unknown ObjectId {id:?}"),
- ));
- }
- self.xrecord_store.insert(id, spec.clone());
- Ok(())
- }
- fn xrecord(&self, id: ObjectId) -> ApiResult> {
- if !self.object_exists(id) {
- return Err(ApiError::validation(
- "GetXRecord",
- format!("unknown ObjectId {id:?}"),
- ));
- }
- Ok(self.xrecord_store.get(&id).cloned())
- }
- fn create_layer(&mut self, info: &LayerInfo) -> ApiResult<()> {
- let name = normalize_layer_name(&info.name);
- if name.is_empty() {
- return Err(ApiError::validation("CreateLayer", "empty layer name"));
- }
- if self.layers.contains_key(&name) {
- return Err(ApiError::validation(
- "CreateLayer",
- format!("layer '{name}' already exists"),
- ));
- }
- let mut stored = info.clone();
- stored.name = name.clone();
- self.layers.insert(name, stored);
- Ok(())
- }
- fn update_layer(&mut self, name: &str, info: &LayerInfo) -> ApiResult<()> {
- let name_upper = normalize_layer_name(name);
- if !self.layers.contains_key(&name_upper) {
- return Err(ApiError::validation(
- "UpdateLayer",
- format!("layer '{name}' does not exist"),
- ));
- }
- let mut stored = info.clone();
- stored.name = name_upper.clone();
- self.layers.insert(name_upper, stored);
- Ok(())
- }
- fn delete_layer(&mut self, name: &str) -> ApiResult<()> {
- let name_upper = normalize_layer_name(name);
- if name_upper == "0" {
- return Err(ApiError::validation("DeleteLayer", "cannot delete layer 0"));
- }
- if self.entity_layers.values().any(|l| normalize_layer_name(l) == name_upper) {
- return Err(ApiError::validation(
- "DeleteLayer",
- format!("layer '{name_upper}' still in use"),
- ));
- }
- if self.layers.remove(&name_upper).is_none() {
- return Err(ApiError::validation(
- "DeleteLayer",
- format!("layer '{name}' does not exist"),
- ));
- }
- Ok(())
- }
- fn set_entity_layer(&mut self, id: ObjectId, layer: &str) -> ApiResult<()> {
- if !self.entity_exists(id) {
- return Err(ApiError::UnknownId(id));
- }
- let layer_upper = normalize_layer_name(layer);
- let target = self
- .layers
- .get(&layer_upper)
- .ok_or_else(|| {
- ApiError::validation(
- "SetEntityLayer",
- format!("layer '{layer_upper}' does not exist"),
- )
- })?;
- if target.flags.locked {
- return Err(ApiError::Unsupported(format!(
- "entity {id:?} cannot be moved to locked layer '{layer_upper}'"
- )));
- }
- self.entity_layers.insert(id, layer_upper);
- Ok(())
- }
- fn layers(&self) -> ApiResult> {
- let mut v: Vec<_> = self.layers.values().cloned().collect();
- v.sort_by(|a, b| a.name.cmp(&b.name));
- Ok(v)
- }
- fn entity_layer(&self, id: ObjectId) -> ApiResult {
- self.entity_layers
- .get(&id)
- .cloned()
- .ok_or(ApiError::UnknownId(id))
- }
- fn add_vertex(&mut self, id: ObjectId, _at: usize, _point: [f64; 3]) -> ApiResult<()> {
- if self.entity_exists(id) {
- Ok(())
- } else {
- Err(ApiError::UnknownId(id))
- }
- }
- fn remove_entity(&mut self, id: ObjectId) -> ApiResult {
- self.bodies.remove(&id);
- self.xdata_store.retain(|(k, _), _| *k != id);
- self.xrecord_store.remove(&id);
- self.entity_layers.remove(&id);
- Ok(self.kinds.remove(&id).is_some())
- }
- fn enumerate_entities(
- &self,
- kind: Option<&str>,
- layer: Option<&str>,
- include_bounds: bool,
- ) -> ApiResult> {
- let mut out = Vec::new();
- for (id, kind_name) in &self.kinds {
- if let Some(k) = kind {
- if !k.eq_ignore_ascii_case(kind_name) {
- continue;
- }
- }
- let entity_layer = self
- .entity_layers
- .get(id)
- .cloned()
- .unwrap_or_else(|| "0".to_string());
- if let Some(l) = layer {
- if !l.eq_ignore_ascii_case(&entity_layer) {
- continue;
- }
- }
- let bounds = if include_bounds {
- self.curves.get(id).map(curve_bounds)
- } else {
- None
- };
- out.push(EntityView {
- id: *id,
- kind: kind_name.clone(),
- layer: entity_layer,
- bounds,
- });
- }
- Ok(out)
- }
- fn point_position(&self, id: ObjectId) -> ApiResult<[f64; 3]> {
- let spec = self.curves.get(&id).ok_or(ApiError::UnknownId(id))?;
- match spec {
- Curve2Spec::Point { position, .. } => Ok(*position),
- _ => Err(ApiError::Unsupported(
- "GetPointPosition is only for Point entities".into(),
- )),
- }
- }
- fn line_geometry(&self, id: ObjectId) -> ApiResult<([f64; 3], [f64; 3])> {
- let spec = self.curves.get(&id).ok_or(ApiError::UnknownId(id))?;
- match spec {
- Curve2Spec::Line { start, end, .. } => Ok((*start, *end)),
- _ => Err(ApiError::Unsupported(
- "GetLineGeometry is only for Line entities".into(),
- )),
- }
- }
- fn get_entity(&mut self, id: ObjectId) -> ApiResult {
- let kind = self.kinds.get(&id).ok_or(ApiError::UnknownId(id))?.clone();
- let layer = self
- .entity_layers
- .get(&id)
- .cloned()
- .unwrap_or_else(|| "0".to_string());
- let bounds = self.bodies.get(&id).and_then(|b| {
- cadkernel::brep::body_bounds(b).map(|bb| Aabb {
- min: bb.min,
- max: bb.max,
- })
- });
- Ok(EntityView {
- id,
- kind,
- layer,
- bounds,
- })
- }
- fn transform_entity(&mut self, id: ObjectId, placement: &PlacementSpec) -> ApiResult<()> {
- if !self.entity_exists(id) {
- return Err(ApiError::UnknownId(id));
- }
- if let Some(body) = self.bodies.get(&id).cloned() {
- let place = cadkernel::brep::Placement {
- x_axis: placement.x_axis,
- y_axis: placement.y_axis,
- z_axis: placement.z_axis,
- origin: placement.origin,
- };
- let moved = cadkernel::brep::transform(&body, &place).ok_or_else(|| {
- ApiError::geometry(GeometryErrorKind::InvalidInput, "transform failed")
- })?;
- self.bodies.insert(id, moved);
- }
- Ok(())
- }
- fn profile_curves(&self, _id: ObjectId) -> ApiResult> {
- Err(ApiError::Unsupported("profiles not mocked".into()))
- }
- fn bounds(&mut self, id: ObjectId) -> ApiResult {
- // Solids via the kernel body; 2D curves from their stored spec.
- if let Some(body) = self.bodies.get(&id) {
- let bb = cadkernel::brep::body_bounds(body)
- .ok_or_else(|| ApiError::geometry(GeometryErrorKind::Empty, "no bounds"))?;
- return Ok(Aabb {
- min: bb.min,
- max: bb.max,
- });
- }
- if let Some(spec) = self.curves.get(&id) {
- return Ok(curve_bounds(spec));
- }
- Err(ApiError::UnknownId(id))
- }
- fn centroid(&mut self, id: ObjectId) -> ApiResult<[f64; 3]> {
- let body = self.body(id)?;
- Ok(mesh_vc(&cadkernel::brep::mesh_body(body, 0.5, 1e-3)).1)
- }
- fn volume(&mut self, id: ObjectId) -> ApiResult {
- let body = self.body(id)?;
- Ok(mesh_vc(&cadkernel::brep::mesh_body(body, 0.5, 1e-3)).0)
- }
- fn entity_exists(&self, id: ObjectId) -> bool {
- self.kinds.contains_key(&id)
- }
- fn object_exists(&self, id: ObjectId) -> bool {
- self.xrecord_store.contains_key(&id)
- }
- fn revision(&self) -> GeometryRevision {
- GeometryRevision(self.revision)
- }
- fn push_undo(&mut self, _label: &str) {}
- fn finalize_op(&mut self) {
- self.undo_steps += 1;
- self.revision += 1;
- }
-}
-
-/// Signed volume + centroid of a closed mesh — delegates to the crate's single
-/// source of truth (divergence theorem) so the example mock can't drift.
-fn mesh_vc(mesh: &cadkernel::brep::Mesh) -> (f64, [f64; 3]) {
- ocs_doc_api::geom::mesh_volume_centroid(mesh)
-}
diff --git a/crates/ocs_doc_api/examples/e1_primitives_and_queries.rs b/crates/ocs_doc_api/examples/e1_primitives_and_queries.rs
deleted file mode 100644
index 3d3312f11..000000000
--- a/crates/ocs_doc_api/examples/e1_primitives_and_queries.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-//! Example 1 — Create solid primitives and query their geometry.
-//!
-//! Run: `cargo run --example e1_primitives_and_queries --features host`
-//!
-//! Shows: `doc.solids().create_*` for the supported primitives, and the read
-//! queries `bounds()` / `volume()` / `centroid()` on a `Solid`.
-
-mod common;
-
-use ocs_doc_api::DocApi;
-
-fn main() -> ocs_doc_api::ApiResult<()> {
- // In-process document over the mock backend (no host binary needed).
- let api = DocApi::in_process(common::MockBackend::default(), 0);
- let doc = api.document(api.active_tab());
-
- // The supported solid primitives.
- let block = doc
- .solids()
- .create_cuboid([0.0, 0.0, 0.0], [10.0, 10.0, 10.0])?;
- let ball = doc.solids().create_sphere([5.0, 5.0, 5.0], 6.0)?;
- let cyl = doc.solids().create_cylinder([0.0, 0.0, 0.0], 4.0, 12.0)?;
-
- // Geometric queries are entity methods — one host call each.
- let bb = block.bounds()?;
- let vol = ball.volume()?;
- let cg = cyl.centroid()?;
-
- println!("cuboid bounds : {bb:?}");
- println!("sphere volume : {vol:.2} (analytic ~904.78)");
- println!("cylinder centroid: {cg:?}");
-
- // Read-only batching: same queries, ONE round-trip.
- let res = doc.query_batch(|q| {
- q.bounds(&block);
- q.volume(&ball);
- q.centroid(&cyl);
- })?;
- let (bb2, vol2, cg2) = (res.bounds(0)?, res.volume(1)?, res.centroid(2)?);
- assert_eq!(bb, bb2);
- assert!((vol - vol2).abs() < 1e-9);
- assert_eq!(cg, cg2);
- println!("query_batch matches the per-call results");
- Ok(())
-}
diff --git a/crates/ocs_doc_api/examples/e2_intersect_two_solids.rs b/crates/ocs_doc_api/examples/e2_intersect_two_solids.rs
deleted file mode 100644
index dd117c6fd..000000000
--- a/crates/ocs_doc_api/examples/e2_intersect_two_solids.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-//! Example 2 — Construct two solids and intersect them (the canonical boolean).
-//!
-//! Run: `cargo run --example e2_intersect_two_solids --features host`
-//!
-//! Shows: `intersect` / `union` / `subtract` on `Solid`, `erase_sources`
-//! semantics (the result lives at the first input's id, the second is erased),
-//! and `OpGroup` cleanup on failure.
-
-mod common;
-
-use ocs_doc_api::{DocApi, HasId, OpGroup};
-
-fn main() -> ocs_doc_api::ApiResult<()> {
- let api = DocApi::in_process(common::MockBackend::default(), 0);
- let doc = api.document(api.active_tab());
- let mut grp = OpGroup::new();
-
- // Two overlapping boxes: [0,10]^3 and [5,15]^3.
- let a = grp.track(doc.solids().create_cuboid([0.0, 0.0, 0.0], [10.0; 3]))?;
- let b = grp.track(doc.solids().create_cuboid([5.0, 5.0, 5.0], [10.0; 3]))?;
-
- // intersect -> SolidBoolean{Intersection, erase_sources:true}. The result is
- // returned AT `a`'s id; `b` is erased. [5,10]^3 = volume 125.
- let lens = match a.intersect(&b) {
- Ok(l) => {
- grp.commit(); // keep everything
- l
- }
- Err(e) => {
- grp.compensate(&doc)?; // best-effort: delete the two boxes
- return Err(e);
- }
- };
-
- assert_eq!(lens.id(), a.id(), "result lives at the first input's id");
- let vol = lens.volume()?;
- let bb = lens.bounds()?;
- println!("intersection volume = {vol:.2} (expected 125)");
- println!("intersection bounds = {bb:?}");
-
- // union / subtract follow the same shape. Fresh inputs (b was erased above).
- let c = doc.solids().create_cuboid([0.0, 0.0, 0.0], [10.0; 3])?;
- let d = doc.solids().create_cuboid([5.0, 5.0, 5.0], [10.0; 3])?;
- let uni = c.union(&d)?;
- // union volume = 1000 + 1000 - 125 (overlap) = 1875.
- println!("union volume = {:.2} (expected 1875)", uni.volume()?);
-
- let e = doc.solids().create_cuboid([0.0, 0.0, 0.0], [10.0; 3])?;
- let f = doc.solids().create_cuboid([5.0, 5.0, 5.0], [10.0; 3])?;
- let diff = e.subtract(&f)?;
- println!("difference volume = {:.2} (expected 875)", diff.volume()?);
- Ok(())
-}
diff --git a/crates/ocs_doc_api/examples/e3_transform_and_chain.rs b/crates/ocs_doc_api/examples/e3_transform_and_chain.rs
deleted file mode 100644
index 1229f2997..000000000
--- a/crates/ocs_doc_api/examples/e3_transform_and_chain.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-//! Example 3 — Transform a solid and chain geometric operations.
-//!
-//! Run: `cargo run --example e3_transform_and_chain --features host`
-//!
-//! Shows: `transform(PlacementSpec)` (in-place, same ObjectId), how bounds shift
-//! exactly by the translation, and chaining intersect -> transform.
-
-mod common;
-
-use ocs_doc_api::{DocApi, PlacementSpec};
-
-fn main() -> ocs_doc_api::ApiResult<()> {
- let api = DocApi::in_process(common::MockBackend::default(), 0);
- let doc = api.document(api.active_tab());
-
- let a = doc.solids().create_cuboid([0.0, 0.0, 0.0], [10.0; 3])?;
- let b = doc.solids().create_cuboid([5.0, 5.0, 5.0], [10.0; 3])?;
-
- // Boolean first: lens = [5,10]^3.
- let lens = a.intersect(&b)?;
- let before = lens.bounds()?;
- println!("lens bounds before transform: {before:?}");
-
- // Transform is in-place: the SAME ObjectId is preserved; bounds shift by the
- // translation. [5,10]^3 moved +100 in X -> [105,110] x [5,10] x [5,10].
- lens.transform(PlacementSpec::at([100.0, 0.0, 0.0]))?;
- let after = lens.bounds()?;
- println!("lens bounds after +100 X : {after:?}");
- assert!((after.min[0] - 105.0).abs() < 1e-4);
- assert!((after.max[0] - 110.0).abs() < 1e-4);
- assert_eq!(after.min[1], before.min[1], "Y unchanged");
-
- // Volume is invariant under a rigid transform.
- let vol = lens.volume()?;
- println!("lens volume after transform = {vol:.2} (still ~125)");
- assert!((vol - 125.0).abs() < 1.0);
- Ok(())
-}
diff --git a/crates/ocs_doc_api/examples/e4_2d_entities_and_bulk.rs b/crates/ocs_doc_api/examples/e4_2d_entities_and_bulk.rs
deleted file mode 100644
index eb1ff0b5b..000000000
--- a/crates/ocs_doc_api/examples/e4_2d_entities_and_bulk.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-//! Example 4 — 2D entities and bulk creation.
-//!
-//! Run: `cargo run --example e4_2d_entities_and_bulk --features host`
-//!
-//! Shows: the minimal-2D constructors (`create_line`/`create_circle`/
-//! `create_polyline`/`create_point`), `bounds()` on 2D entities, and the bulk op
-//! `create_points` (one op, all-or-nothing, one undo step).
-
-mod common;
-
-use ocs_doc_api::{DocApi, HasId};
-
-fn main() -> ocs_doc_api::ApiResult<()> {
- let api = DocApi::in_process(common::MockBackend::default(), 0);
- let doc = api.document(api.active_tab());
-
- // Individual 2D constructors.
- let line = doc
- .curves()
- .create_line([0.0, 0.0, 0.0], [10.0, 0.0, 0.0])?;
- let circle = doc.curves().create_circle([5.0, 5.0, 0.0], 3.0)?;
- let poly = doc.curves().create_polyline(
- &[
- [0.0, 0.0, 0.0],
- [1.0, 0.0, 0.0],
- [1.0, 1.0, 0.0],
- [0.0, 1.0, 0.0],
- ],
- true,
- )?;
-
- println!("line bounds: {:?}", line.bounds()?); // [0,10] in X
- println!("circle bounds: {:?}", circle.bounds()?); // centre ± radius
- println!("poly bounds: {:?}", poly.bounds()?); // unit square
-
- // Bulk: 1000 points in ONE op (all-or-nothing, one undo step — not 1000).
- let coords: Vec<[f64; 3]> = (0..1000)
- .map(|i| [i as f64, (i % 10) as f64, 0.0])
- .collect();
- let pts = doc.curves().create_points(&coords)?;
- println!("created {} points in one bulk op", pts.len());
- assert_eq!(pts.len(), 1000);
-
- // Generic lookup: any id -> Entity -> kind.
- let e = doc.entities().get(line.id())?;
- println!("line entity kind: {}", e.view()?.kind);
-
- Ok(())
-}
diff --git a/crates/ocs_doc_api/examples/e5_failure_and_guards.rs b/crates/ocs_doc_api/examples/e5_failure_and_guards.rs
deleted file mode 100644
index 2cc82dbe5..000000000
--- a/crates/ocs_doc_api/examples/e5_failure_and_guards.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//! Example 5 — Failure semantics: atomicity, OpGroup compensation, revision guard.
-//!
-//! Run: `cargo run --example e5_failure_and_guards --features host`
-//!
-//! Shows: per-op atomicity (a failed op applies nothing and moves no revision),
-//! `OpGroup` best-effort cleanup, `ApiError` handling, and the `assert_revision`
-//! read-guard.
-
-mod common;
-
-use ocs_doc_api::{ApiError, DocApi, HasId, ObjectId, OpGroup};
-
-fn main() -> ocs_doc_api::ApiResult<()> {
- let api = DocApi::in_process(common::MockBackend::default(), 0);
- let doc = api.document(api.active_tab());
-
- // ── Per-op atomicity: a boolean against a deleted id fails cleanly ──
- let a = doc.solids().create_cuboid([0.0, 0.0, 0.0], [10.0; 3])?;
- let ghost = doc.solids().create_sphere([5.0, 5.0, 5.0], 4.0)?;
- ghost.delete()?; // now a stale handle
-
- let rev_before = doc.revision()?;
- match a.intersect(&ghost) {
- Err(ApiError::UnknownId(id)) => println!("boolean failed as expected: unknown id {id:?}"),
- Err(e) => println!("boolean failed: {e}"),
- Ok(_) => panic!("expected the boolean to fail"),
- }
- // `a` is still live (failed op mutated nothing) and the revision did not move.
- assert!(a.bounds().is_ok(), "input solid survives a failed boolean");
- assert_eq!(
- doc.revision()?,
- rev_before,
- "failed op records no revision bump"
- );
-
- // ── OpGroup: clean up a partially-built logical operation on failure ──
- let mut grp = OpGroup::new();
- let p1 = grp.track(doc.solids().create_cuboid([0.0, 0.0, 0.0], [4.0; 3]))?;
- let p2 = grp.track(doc.solids().create_sphere([2.0, 2.0, 2.0], 3.0))?;
- // Simulate a downstream failure: abandon the group and delete what we made.
- grp.compensate(&doc)?;
- for h in [p1.id(), p2.id()] {
- assert!(doc.entities().get(h).is_err(), "compensated entity is gone");
- }
- println!("OpGroup compensated: created entities deleted");
-
- // ── assert_revision: read-modify-write guard ──
- let rev = doc.revision()?;
- doc.assert_revision(rev)?; // unchanged -> ok
- doc.solids().create_cuboid([0.0, 0.0, 0.0], [1.0; 3])?; // moves the revision
- match doc.assert_revision(rev) {
- Err(ApiError::Validation { reason, .. }) => println!("revision guard caught: {reason}"),
- other => panic!("expected the revision guard to fail, got {other:?}"),
- }
-
- // A totally unknown id also surfaces a structured error.
- assert!(doc.entities().get(ObjectId::from_u64(0xDEAD)).is_err());
- println!("failure semantics verified");
- Ok(())
-}
diff --git a/crates/ocs_doc_api/spec/entities.toml b/crates/ocs_doc_api/spec/entities.toml
deleted file mode 100644
index 4de4cf6eb..000000000
--- a/crates/ocs_doc_api/spec/entities.toml
+++ /dev/null
@@ -1,566 +0,0 @@
-# Curated source of truth for ocs_doc_api codegen (plan §10, decision #6).
-# Maps entity families + their construction ops, geometric actions, and queries
-# to kernel fns / acadrust variants. build.rs regenerates src/gen/* from this;
-# CI fails on drift. New op/query variants append at the END only (bincode
-# discriminant stability).
-#
-# `status` values: "supported" (default), "unsupported" (present but errors),
-# "planned" (roadmap; no callable surface). Generic handle methods
-# (bounds/transform/delete) are documented once in build.rs and apply to every
-# family unless overridden here.
-
-[meta]
-envelope_version = 1
-
-# ============================================================================
-# SOLID FAMILY (phase 1) — B-rep solids via cadkernel
-# ============================================================================
-[[family]]
-name = "Solid"
-acadrust_variant = "Solid3D"
-handle = "Solid"
-collection = "solids"
-description = "B-rep solid. Host resolves bodies via the solid_models cache (lift-on-miss from ACIS SAT)."
-
-[[family.constructor]]
-name = "create_cuboid"
-args = [{ name = "origin", ty = "[f64; 3]" }, { name = "size", ty = "[f64; 3]" }]
-op = "CreateSolid"
-fixed = { primitive = "Cuboid" }
-
-[[family.constructor]]
-name = "create_sphere"
-args = [{ name = "centre", ty = "[f64; 3]" }, { name = "radius", ty = "f64" }]
-op = "CreateSolid"
-fixed = { primitive = "Sphere" }
-
-[[family.constructor]]
-name = "create_cylinder"
-args = [{ name = "base", ty = "[f64; 3]" }, { name = "radius", ty = "f64" }, { name = "height", ty = "f64" }]
-op = "CreateSolid"
-fixed = { primitive = "Cylinder" }
-
-[[family.constructor]]
-name = "create_cone"
-args = [{ name = "base", ty = "[f64; 3]" }, { name = "radius", ty = "f64" }, { name = "height", ty = "f64" }]
-op = "CreateSolid"
-fixed = { primitive = "Cone" }
-
-[[family.constructor]]
-name = "create_torus"
-args = [{ name = "centre", ty = "[f64; 3]" }, { name = "major_radius", ty = "f64" }, { name = "minor_radius", ty = "f64" }]
-op = "CreateSolid"
-fixed = { primitive = "Torus" }
-
-[[family.constructor]]
-name = "create_wedge"
-args = [{ name = "origin", ty = "[f64; 3]" }, { name = "size", ty = "[f64; 3]" }]
-op = "CreateSolid"
-fixed = { primitive = "Wedge" }
-
-[[family.constructor]]
-name = "extrude"
-args = [{ name = "profile", ty = "EntityRef" }, { name = "direction", ty = "[f64; 3]" }]
-op = "Extrude"
-
-[[family.constructor]]
-name = "revolve"
-args = [{ name = "profile", ty = "EntityRef" }, { name = "pivot", ty = "[f64; 3]" }, { name = "axis", ty = "[f64; 3]" }, { name = "angle", ty = "f64" }]
-op = "Revolve"
-
-[[family.constructor]]
-name = "loft"
-args = [{ name = "profiles", ty = "&[EntityRef]" }]
-op = "Loft"
-
-[[family.method]]
-name = "intersect"
-kind = "op"
-op = "SolidBoolean"
-args = [{ name = "other", ty = "Solid" }]
-returns = "Solid"
-fixed = { op = "Intersection", erase_sources = true }
-
-[[family.method]]
-name = "union"
-kind = "op"
-op = "SolidBoolean"
-args = [{ name = "other", ty = "Solid" }]
-returns = "Solid"
-fixed = { op = "Union", erase_sources = true }
-
-[[family.method]]
-name = "subtract"
-kind = "op"
-op = "SolidBoolean"
-args = [{ name = "other", ty = "Solid" }]
-returns = "Solid"
-fixed = { op = "Difference", erase_sources = true }
-
-[[family.method]]
-name = "volume"
-kind = "query"
-query = "GetVolume"
-returns = "f64"
-
-[[family.method]]
-name = "centroid"
-kind = "query"
-query = "GetCentroid"
-returns = "[f64; 3]"
-
-[[family.method]]
-name = "intersects"
-kind = "query"
-query = "GetIntersects"
-args = [{ name = "other", ty = "Solid" }]
-returns = "bool"
-
-# ============================================================================
-# CURVE FAMILY (phase 1, minimal 2D)
-# ============================================================================
-[[family]]
-name = "Line"
-acadrust_variant = "Line"
-handle = "Line"
-collection = "curves"
-
-[[family.constructor]]
-name = "create_line"
-args = [{ name = "start", ty = "[f64; 3]" }, { name = "end", ty = "[f64; 3]" }]
-op = "CreateCurve"
-fixed = { curve = "Line" }
-
-[[family]]
-name = "Circle"
-acadrust_variant = "Circle"
-handle = "Circle"
-collection = "curves"
-
-[[family.constructor]]
-name = "create_circle"
-args = [{ name = "centre", ty = "[f64; 3]" }, { name = "radius", ty = "f64" }]
-op = "CreateCurve"
-fixed = { curve = "Circle" }
-
-[[family]]
-name = "Polyline"
-acadrust_variant = "LwPolyline"
-handle = "Polyline"
-collection = "curves"
-
-[[family.constructor]]
-name = "create_polyline"
-args = [{ name = "points", ty = "&[[f64; 3]]" }, { name = "closed", ty = "bool" }]
-op = "CreateCurve"
-fixed = { curve = "Polyline" }
-
-[[family.method]]
-name = "add_vertex"
-kind = "op"
-op = "AddVertex"
-args = [{ name = "at", ty = "usize" }, { name = "point", ty = "[f64; 3]" }]
-returns = "()"
-
-[[family]]
-name = "Point"
-acadrust_variant = "Point"
-handle = "Point"
-collection = "curves"
-
-[[family.constructor]]
-name = "create_point"
-args = [{ name = "position", ty = "[f64; 3]" }]
-op = "CreateCurve"
-fixed = { curve = "Point" }
-
-[[family.constructor]]
-name = "create_points"
-args = [{ name = "positions", ty = "&[[f64; 3]]" }]
-op = "CreateMany"
-fixed = { curve = "Point" }
-bulk = true
-returns = "Vec"
-
-[[family]]
-name = "Arc"
-acadrust_variant = "Arc"
-handle = "ArcCurve"
-collection = "curves"
-
-[[family.constructor]]
-name = "create_arc"
-args = [{ name = "centre", ty = "[f64; 3]" }, { name = "radius", ty = "f64" }, { name = "start_angle", ty = "f64" }, { name = "end_angle", ty = "f64" }]
-op = "CreateCurve"
-fixed = { curve = "Arc" }
-
-[[family]]
-name = "Ellipse"
-acadrust_variant = "Ellipse"
-handle = "Ellipse"
-collection = "curves"
-
-[[family.constructor]]
-name = "create_ellipse"
-args = [{ name = "centre", ty = "[f64; 3]" }, { name = "major_axis", ty = "[f64; 3]" }, { name = "ratio", ty = "f64" }, { name = "start", ty = "f64" }, { name = "end", ty = "f64" }]
-op = "CreateCurve"
-fixed = { curve = "Ellipse" }
-
-[[family]]
-name = "Spline"
-acadrust_variant = "Spline"
-handle = "Spline"
-collection = "curves"
-
-[[family.constructor]]
-name = "create_spline"
-args = [{ name = "degree", ty = "i32" }, { name = "control_points", ty = "&[[f64; 3]]" }, { name = "knots", ty = "&[f64]" }, { name = "weights", ty = "&[f64]" }]
-op = "CreateCurve"
-fixed = { curve = "Spline" }
-
-[[family]]
-name = "Ray"
-acadrust_variant = "Ray"
-handle = "Ray"
-collection = "curves"
-
-[[family.constructor]]
-name = "create_ray"
-args = [{ name = "origin", ty = "[f64; 3]" }, { name = "direction", ty = "[f64; 3]" }]
-op = "CreateCurve"
-fixed = { curve = "Ray" }
-
-[[family]]
-name = "XLine"
-acadrust_variant = "XLine"
-handle = "XLine"
-collection = "curves"
-
-[[family.constructor]]
-name = "create_xline"
-args = [{ name = "origin", ty = "[f64; 3]" }, { name = "direction", ty = "[f64; 3]" }]
-op = "CreateCurve"
-fixed = { curve = "XLine" }
-
-# ============================================================================
-# ANNOTATION FAMILY (phase 2b) — text annotations
-# ============================================================================
-[[family]]
-name = "Text"
-acadrust_variant = "Text"
-handle = "Text"
-collection = "curves"
-description = "Single-line text annotation. content()/set_content() read+replace the value; transform moves insertion point."
-
-[[family.constructor]]
-name = "create_text"
-args = [{ name = "value", ty = "&str" }, { name = "insertion_point", ty = "[f64; 3]" }, { name = "height", ty = "f64" }, { name = "rotation", ty = "f64" }]
-op = "CreateText"
-
-[[family.method]]
-name = "content"
-kind = "query"
-query = "GetTextContent"
-returns = "String"
-
-[[family.method]]
-name = "set_content"
-kind = "op"
-op = "SetTextContent"
-args = [{ name = "value", ty = "&str" }]
-returns = "()"
-
-[[family]]
-name = "MText"
-acadrust_variant = "MText"
-handle = "MText"
-collection = "curves"
-description = "Multi-line text annotation. content()/set_content() read+replace the value; transform moves insertion point."
-
-[[family.constructor]]
-name = "create_mtext"
-args = [{ name = "value", ty = "&str" }, { name = "insertion_point", ty = "[f64; 3]" }, { name = "height", ty = "f64" }]
-op = "CreateMText"
-
-[[family.method]]
-name = "content"
-kind = "query"
-query = "GetTextContent"
-returns = "String"
-
-[[family.method]]
-name = "set_content"
-kind = "op"
-op = "SetTextContent"
-args = [{ name = "value", ty = "&str" }]
-returns = "()"
-
-# ============================================================================
-# HATCH FAMILY (phase 2b) — filled regions
-# ============================================================================
-[[family]]
-name = "Hatch"
-acadrust_variant = "Hatch"
-handle = "Entity"
-collection = "curves"
-description = "Filled region over a closed polyline boundary. boundary() returns the loops; bounds from boundary; generic delete."
-
-[[family.constructor]]
-name = "create_hatch"
-args = [{ name = "boundary", ty = "&[[f64; 2]]" }, { name = "solid", ty = "bool" }]
-op = "CreateHatch"
-
-[[family.method]]
-name = "boundary"
-kind = "query"
-query = "GetHatchBoundary"
-returns = "Vec>"
-
-# ============================================================================
-# DIMENSION FAMILY (phase 2c) — linear dimensions
-# ============================================================================
-[[family]]
-name = "Dimension"
-acadrust_variant = "Dimension"
-handle = "Dimension"
-collection = "curves"
-description = "Linear dimension between two measured points. measurement() reads the distance; bounds from the measured + definition points."
-
-[[family.constructor]]
-name = "create_dimension_linear"
-args = [{ name = "first_point", ty = "[f64; 3]" }, { name = "second_point", ty = "[f64; 3]" }, { name = "definition_point", ty = "[f64; 3]" }]
-op = "CreateDimensionLinear"
-
-[[family.constructor]]
-name = "create_dimension_radius"
-args = [{ name = "center", ty = "[f64; 3]" }, { name = "point", ty = "[f64; 3]" }]
-op = "CreateDimensionRadius"
-
-[[family.constructor]]
-name = "create_dimension_diameter"
-args = [{ name = "center", ty = "[f64; 3]" }, { name = "point", ty = "[f64; 3]" }]
-op = "CreateDimensionDiameter"
-
-[[family.constructor]]
-name = "create_dimension_angular"
-args = [{ name = "vertex", ty = "[f64; 3]" }, { name = "first_point", ty = "[f64; 3]" }, { name = "second_point", ty = "[f64; 3]" }, { name = "arc_location", ty = "[f64; 3]" }]
-op = "CreateDimensionAngular"
-
-[[family.constructor]]
-name = "create_dimension_angular2ln"
-args = [{ name = "vertex", ty = "[f64; 3]" }, { name = "first_point", ty = "[f64; 3]" }, { name = "second_point", ty = "[f64; 3]" }, { name = "arc_location", ty = "[f64; 3]" }]
-op = "CreateDimensionAngular2Ln"
-
-[[family.method]]
-name = "measurement"
-kind = "query"
-query = "GetDimensionMeasurement"
-returns = "f64"
-
-# ============================================================================
-# CONTAINER FAMILY (phase 3) — block references
-# ============================================================================
-[[family]]
-name = "Insert"
-acadrust_variant = "Insert"
-handle = "Entity"
-collection = "entities"
-description = "Block reference. Place an existing BlockRecord by name; transform moves its insert point."
-
-[[family.constructor]]
-name = "create_insert"
-args = [{ name = "block_name", ty = "&str" }, { name = "insert_point", ty = "[f64; 3]" }, { name = "scale", ty = "f64" }, { name = "rotation", ty = "f64" }]
-op = "CreateInsert"
-
-[[family.method]]
-name = "attributes"
-kind = "query"
-query = "GetAttributes"
-returns = "Vec<(String, String)>"
-
-[[family.method]]
-name = "set_attribute"
-kind = "op"
-op = "SetAttribute"
-args = [{ name = "tag", ty = "&str" }, { name = "value", ty = "&str" }]
-returns = "()"
-
-# ============================================================================
-# ATTRIBUTE-DEFINITION FAMILY (phase 3-ii) — in-block attribute definitions
-# ============================================================================
-[[family]]
-name = "AttributeDefinition"
-acadrust_variant = "AttributeDefinition"
-handle = "Entity"
-collection = "entities"
-description = "In-block attribute definition (ATTDEF): tag/prompt/default at an insertion point."
-
-[[family.constructor]]
-name = "create_attribute_definition"
-args = [{ name = "tag", ty = "&str" }, { name = "prompt", ty = "&str" }, { name = "default_value", ty = "&str" }, { name = "insertion_point", ty = "[f64; 3]" }, { name = "height", ty = "f64" }, { name = "rotation", ty = "f64" }]
-op = "CreateAttributeDefinition"
-
-# ============================================================================
-# PAPER-SPACE FAMILY (phase 4) — viewports
-# ============================================================================
-[[family]]
-name = "Viewport"
-acadrust_variant = "Viewport"
-handle = "Entity"
-collection = "entities"
-description = "Paper-space viewport: a width×height window at center looking at view_target with view_height zoom. bounds = center ± w/2,h/2; transform moves center."
-
-[[family.constructor]]
-name = "create_viewport"
-args = [{ name = "center", ty = "[f64; 3]" }, { name = "width", ty = "f64" }, { name = "height", ty = "f64" }, { name = "view_target", ty = "[f64; 3]" }, { name = "view_height", ty = "f64" }]
-op = "CreateViewport"
-
-[[family.method]]
-name = "viewport_view"
-kind = "query"
-query = "GetViewportView"
-returns = "([f64; 3], f64)"
-
-[[family.method]]
-name = "set_view"
-kind = "op"
-op = "SetViewportView"
-args = [{ name = "view_target", ty = "[f64; 3]" }, { name = "view_height", ty = "f64" }]
-returns = "()"
-
-# ============================================================================
-# MEDIA & MISC (phase 5, read-mostly) — read-only EntityView, no typed create.
-# These families report a real `kind` via GetEntity and coarse bounds where
-# computable; they have no typed construction/geometric ops in v1.
-# ============================================================================
-[[family]]
-name = "RasterImage"
-acadrust_variant = "RasterImage"
-handle = "Entity"
-collection = "entities"
-description = "Raster image: create_raster_image(file_path, insertion, u, v, size) places an image (host auto-registers the ImageDefinition); bounds (4-corner bracket); delete."
-
-[[family.constructor]]
-name = "create_raster_image"
-args = [{ name = "file_path", ty = "&str" }, { name = "insertion_point", ty = "[f64; 3]" }, { name = "u_vector", ty = "[f64; 3]" }, { name = "v_vector", ty = "[f64; 3]" }, { name = "size", ty = "[f64; 2]" }]
-op = "CreateRasterImage"
-
-[[family]]
-name = "Table"
-acadrust_variant = "Table"
-handle = "Entity"
-collection = "entities"
-description = "Table: create_table(insertion_point, data[row][col]) builds rows x columns of text cells; non-rectangular grid -> Validation; delete."
-
-[[family.constructor]]
-name = "create_table"
-args = [{ name = "insertion_point", ty = "[f64; 3]" }, { name = "data", ty = "&[Vec]" }]
-op = "CreateTable"
-
-# ============================================================================
-# XDATA / XRECORD FAMILY — application-specific extended data roundtrip
-# ============================================================================
-[[family]]
-name = "XRecord"
-acadrust_variant = "XRecord"
-handle = "XRecord"
-collection = "entities"
-description = "Extended record (XRecord): arbitrary DXF group-code/value pairs. Roundtripped verbatim as an XRecordSpec payload."
-
-[[family.constructor]]
-name = "create_xrecord"
-args = [{ name = "spec", ty = "XRecordSpec" }]
-op = "CreateXRecord"
-returns = "XRecord"
-
-[[family.method]]
-name = "payload"
-kind = "query"
-query = "GetXRecord"
-returns = "XRecordSpec"
-
-[[family.method]]
-name = "set_payload"
-kind = "op"
-op = "SetXRecord"
-args = [{ name = "spec", ty = "XRecordSpec" }]
-returns = "()"
-
-# ============================================================================
-# Cross-cutting ops (generic handles + bulk) — documented in build.rs
-# ============================================================================
-# - Generic handle methods on EVERY handle: bounds() -> Aabb, transform(placement),
-# delete(), id() -> ObjectId. (transform is solids-only in v1.)
-# - EntityCollection: get(id) -> Entity, delete(id), transform_many(&ids, pl),
-# delete_many(&ids).
-# - Bulk ops (CreateMany / TransformMany / DeleteMany): single op, all-or-nothing
-# via upfront validation, item-capped (BULK_ITEM_CAP).
-# - Read-only batching: query_batch(|q| ...) — one round-trip, no revision bump.
-# - OpGroup: best-effort client-side failure cleanup (NOT a transaction).
-
-# ============================================================================
-# LAYER family (named drawing layers)
-# ============================================================================
-[[family]]
-name = "Layer"
-handle = "Layer"
-collection = "layers"
-description = "Named drawing layer (color, linetype, lineweight, visibility). Not an entity handle; accessed through Document::layers()."
-
-[[family.method]]
-name = "list"
-kind = "query"
-query = "ListLayers"
-returns = "Vec"
-
-[[family.method]]
-name = "create"
-kind = "op"
-op = "CreateLayer"
-args = [{ name = "info", ty = "LayerInfo" }]
-returns = "()"
-
-[[family.method]]
-name = "update"
-kind = "op"
-op = "UpdateLayer"
-args = [{ name = "name", ty = "String" }, { name = "info", ty = "LayerInfo" }]
-returns = "()"
-
-[[family.method]]
-name = "delete"
-kind = "op"
-op = "DeleteLayer"
-args = [{ name = "name", ty = "String" }]
-returns = "()"
-
-# ---- Kernel/op mapping (reference for the executor + docs) ----
-[[kernel_map]]
-op = "CreateSolid.Cuboid"
-kernel = "cadkernel::brep::make::cuboid"
-returns = "Option"
-
-[[kernel_map]]
-op = "CreateSolid.Sphere"
-kernel = "cadkernel::brep::make::sphere"
-returns = "Option"
-
-[[kernel_map]]
-op = "SolidBoolean"
-kernel = "cadkernel::brep::combine"
-returns = "Result"
-
-[[kernel_map]]
-op = "Transform"
-kernel = "cadkernel::brep::transform"
-returns = "Option"
-
-[[kernel_map]]
-op = "GetBounds"
-kernel = "cadkernel::brep::body_bounds"
-returns = "Option"
-
-[[kernel_map]]
-op = "GetVolume"
-kernel = "cadkernel::brep::mesh_body + divergence"
-returns = "computed"
diff --git a/crates/ocs_doc_api/src/backend.rs b/crates/ocs_doc_api/src/backend.rs
deleted file mode 100644
index 51e4cfafe..000000000
--- a/crates/ocs_doc_api/src/backend.rs
+++ /dev/null
@@ -1,313 +0,0 @@
-//! The thin host hook. The host implements this trait;
-//! the crate's [`crate::executor`] drives it. Both the in-process transport and
-//! the host's IPC executor call into it. Logic lives in the versioned crate; the
-//! host only provides scene primitives.
-
-use crate::error::{ApiError, ApiResult};
-use crate::id::ObjectId;
-use crate::ops::{Curve2Spec, LayerInfo};
-use crate::query::{Aabb, EntityView};
-use crate::revision::GeometryRevision;
-
-/// A kernel B-rep solid body, opaque to the wire. On `host` this is
-/// `cadkernel::brep::Body`; kernel keys never cross the API (decision #7).
-pub type KernelBody = cadkernel::brep::Body;
-
-/// The per-op host hook. Every method maps to an already-present scene primitive.
-/// The executor calls `push_undo` BEFORE applying a write op and `finalize_op`
-/// AFTER — recording exactly one undo step + one geometry bump per applied op.
-pub trait DocApiBackend {
- // ── identity / solid lookup ────────────────────────────────────────────
- /// Resolve a live B-rep body for `id` (solid cache; re-lift from AcisData on
- /// miss). `UnknownId` if `id` is not a live solid. NOTE: returns an OWNED body
- /// (a clone of the cache entry); use `with_body` for read-only queries.
- fn resolve_body(&mut self, id: ObjectId) -> ApiResult;
-
- /// Borrow the cached body read-only for a query, avoiding the `resolve_body`
- /// deep clone. Default: falls back to `resolve_body` (clone). The host overrides
- /// this to borrow the `solid_models` cache in place (O(1), no copy).
- fn with_body(
- &mut self,
- id: ObjectId,
- f: &mut dyn FnMut(&KernelBody) -> ApiResult,
- ) -> ApiResult {
- let body = self.resolve_body(id)?;
- f(&body)
- }
-
- /// Store a new solid body as a `Solid3D` entity; returns the fresh `ObjectId`.
- /// Mirrors host `add_solid_model` (edge wires + `solid_to_sat` +
- /// `set_sat_document` + `register_solid_model`).
- fn store_solid(&mut self, body: &KernelBody) -> ApiResult;
-
- /// Replace the body of an existing solid in place (same `ObjectId`).
- /// Re-embeds SAT and refreshes the solid cache.
- fn update_solid(&mut self, id: ObjectId, body: &KernelBody) -> ApiResult<()>;
-
- // ── plain (2D) entities ────────────────────────────────────────────────
- /// Add a 2D curve entity; returns the fresh `ObjectId`.
- fn add_curve(&mut self, spec: &Curve2Spec) -> ApiResult;
-
- /// Prepare every entity before recording one undo step and committing the batch.
- fn create_many(&mut self, specs: &[crate::ops::EntitySpec]) -> ApiResult>;
-
- /// Prepare all transformed geometry before committing any entity.
- fn transform_many(
- &mut self,
- ids: &[ObjectId],
- placement: &crate::PlacementSpec,
- ) -> ApiResult<()>;
-
- /// Add a block reference (`INSERT`). Validates `block_name` exists; returns
- /// the fresh `ObjectId`. `Validation` if the block is unknown.
- fn add_insert(&mut self, spec: &crate::ops::InsertSpec) -> ApiResult;
-
- /// Add a paper-space `VIEWPORT`; returns the fresh `ObjectId`.
- fn add_viewport(&mut self, spec: &crate::ops::ViewportSpec) -> ApiResult;
-
- /// Add a single-line `TEXT` annotation; returns the fresh `ObjectId`.
- fn add_text(&mut self, spec: &crate::ops::TextSpec) -> ApiResult;
-
- /// Add a multi-line `MTEXT` annotation; returns the fresh `ObjectId`.
- fn add_mtext(&mut self, spec: &crate::ops::MTextSpec) -> ApiResult;
-
- /// Set the text content of a Text/MText annotation in place.
- fn set_text_content(&mut self, id: ObjectId, value: &str) -> ApiResult<()>;
-
- /// The text content of a Text/MText annotation. `Unsupported` for other kinds.
- fn text_content(&self, id: ObjectId) -> ApiResult;
-
- /// Add a `HATCH` (single closed polyline boundary); returns the fresh `ObjectId`.
- fn add_hatch(&mut self, spec: &crate::ops::HatchSpec) -> ApiResult;
-
- /// A hatch's boundary loops (outer + islands) as closed polylines.
- fn hatch_boundary(&self, id: ObjectId) -> ApiResult>>;
-
- /// Add a linear `DIMENSION`; returns the fresh `ObjectId`.
- fn add_dimension_linear(&mut self, spec: &crate::ops::DimensionSpec) -> ApiResult;
-
- /// Add a radial `DIMENSION`; returns the fresh `ObjectId`.
- fn add_dimension_radius(
- &mut self,
- spec: &crate::ops::DimensionRadialSpec,
- ) -> ApiResult;
-
- /// Add a diameter `DIMENSION`; returns the fresh `ObjectId`.
- fn add_dimension_diameter(
- &mut self,
- spec: &crate::ops::DimensionRadialSpec,
- ) -> ApiResult;
-
- /// Add a 3-point angular `DIMENSION`; returns the fresh `ObjectId`.
- fn add_dimension_angular(
- &mut self,
- spec: &crate::ops::DimensionAngularSpec,
- ) -> ApiResult;
-
- /// Add an `ATTDEF` (in-block attribute definition); returns the fresh `ObjectId`.
- fn add_attribute_definition(
- &mut self,
- spec: &crate::ops::AttributeDefinitionSpec,
- ) -> ApiResult;
-
- /// Add a `TABLE` (rows × columns grid); returns the fresh `ObjectId`.
- fn add_table(&mut self, spec: &crate::ops::TableSpec) -> ApiResult;
-
- /// Add a 2-line angular `DIMENSION`; returns the fresh `ObjectId`.
- fn add_dimension_angular2ln(
- &mut self,
- spec: &crate::ops::DimensionAngularSpec,
- ) -> ApiResult;
-
- /// A dimension's measured value (distance for linear/radius, degrees for angular).
- fn dimension_measurement(&self, id: ObjectId) -> ApiResult;
-
- /// Set an attribute `value` for `tag` on an insert (adds if absent). Insert-only.
- fn set_attribute(&mut self, id: ObjectId, tag: &str, value: &str) -> ApiResult<()>;
-
- /// An insert's attributes as (tag, value) pairs. Insert-only.
- fn attributes(&self, id: ObjectId) -> ApiResult>;
-
- /// The entities inside a block definition (read-only traversal), as views.
- fn block_entities(&self, block_name: &str) -> ApiResult>;
-
- /// Set a viewport's view target + zoom height in place. Viewport-only.
- fn set_viewport_view(
- &mut self,
- id: ObjectId,
- view_target: [f64; 3],
- view_height: f64,
- ) -> ApiResult<()>;
-
- /// A viewport's view (target WCS + zoom height). Viewport-only.
- fn viewport_view(&self, id: ObjectId) -> ApiResult<([f64; 3], f64)>;
-
- /// Add a `RASTER_IMAGE` (host auto-registers the ImageDefinition).
- fn add_raster_image(&mut self, spec: &crate::ops::RasterImageSpec) -> ApiResult;
-
- /// Loft a solid through >= 2 profile curve sets (each already resolved to
- /// `geom2d::Curve`s on the XY plane). Returns the fresh `ObjectId`.
- fn loft(
- &mut self,
- sections: &[(cadkernel::space::Plane, Vec)],
- ) -> ApiResult;
-
- /// Attach or replace an XDATA record for `application_name` on `id`.
- /// `None` removes any existing record for that application.
- fn set_xdata(
- &mut self,
- id: ObjectId,
- application_name: &str,
- record: Option<&crate::ops::XDataRecord>,
- ) -> ApiResult<()>;
-
- /// Read the XDATA record for `application_name` on `id` (`None` if absent).
- fn xdata(
- &self,
- id: ObjectId,
- application_name: &str,
- ) -> ApiResult>;
-
- /// Create a standalone `XRECORD` object from a spec; returns the fresh `ObjectId`.
- fn add_xrecord(&mut self, spec: &crate::ops::XRecordSpec) -> ApiResult;
-
- /// Replace an existing `XRECORD` object's payload in place.
- fn set_xrecord(&mut self, id: ObjectId, spec: &crate::ops::XRecordSpec) -> ApiResult<()>;
-
- /// Read an existing `XRECORD` object's payload (`None` if `id` is not an XRecord).
- fn xrecord(&self, id: ObjectId) -> ApiResult>;
-
- // ── layer CRUD ─────────────────────────────────────────────────────────
- /// Create a new layer. Fails with `Validation` if the name already exists or is reserved.
- fn create_layer(&mut self, info: &crate::ops::LayerInfo) -> ApiResult<()>;
-
- /// Update an existing layer's properties by name. Fails with `Validation` if absent.
- fn update_layer(&mut self, name: &str, info: &crate::ops::LayerInfo) -> ApiResult<()>;
-
- /// Delete a layer by name. Fails with `Validation` if the layer is "0",
- /// the current layer, does not exist, or has entities.
- fn delete_layer(&mut self, name: &str) -> ApiResult<()>;
-
- /// Look up a layer by raw name, normalizing it. Default implementation scans
- /// `layers()`; backends with O(1) lookup should override.
- fn lookup_layer(&self, name: &str) -> ApiResult {
- let norm = crate::layer::normalize_layer_name(name);
- if norm.is_empty() {
- return Err(ApiError::validation("LookupLayer", "empty layer name"));
- }
- self.layers()?
- .into_iter()
- .find(|l| l.normalized_name() == norm)
- .ok_or_else(|| {
- ApiError::validation(
- "LookupLayer",
- format!("layer '{name}' does not exist"),
- )
- })
- }
-
- /// Move an entity to a different layer. The target layer must exist.
- fn set_entity_layer(&mut self, id: ObjectId, layer: &str) -> ApiResult<()>;
-
- /// List all layers in the document.
- fn layers(&self) -> ApiResult>;
-
- /// The layer name of an entity.
- fn entity_layer(&self, id: ObjectId) -> ApiResult;
-
- /// Enumerate first-class entities, optionally filtered by kind and/or layer.
- /// `include_bounds` controls whether `EntityView::bounds` is populated; skip it
- /// for lightweight list views.
- fn enumerate_entities(
- &self,
- kind: Option<&str>,
- layer: Option<&str>,
- include_bounds: bool,
- ) -> ApiResult>;
-
- /// The WCS location of a Point entity.
- fn point_position(&self, id: ObjectId) -> ApiResult<[f64; 3]>;
-
- /// The start and end WCS points of a Line entity.
- fn line_geometry(&self, id: ObjectId) -> ApiResult<([f64; 3], [f64; 3])>;
-
- /// Can `id` be modified in place right now (exists, is the expected family,
- /// not on a locked layer)? Read-only pre-check used before mutations.
- /// Default: existence + not-locked (backends narrow the family check).
- fn can_modify(&self, id: ObjectId) -> ApiResult<()> {
- if self.entity_exists(id) {
- Ok(())
- } else {
- Err(ApiError::UnknownId(id))
- }
- }
-
- /// Remove any first-level entity by id. Returns `false` if absent; returns
- /// `Err` if the entity exists but cannot be removed (e.g. locked layer).
- fn remove_entity(&mut self, id: ObjectId) -> ApiResult;
-
- /// Can `id` be removed right now (exists and is not blocked, e.g. by a locked
- /// layer)? Read-only; used by the boolean-erase path to validate BEFORE any
- /// mutation so a mid-op failure cannot leave partial state. Default: existence-only.
- fn can_remove(&self, id: ObjectId) -> ApiResult<()> {
- if self.entity_exists(id) {
- Ok(())
- } else {
- Err(ApiError::UnknownId(id))
- }
- }
-
- /// Whether an object (named-object / XRecord / dictionary) exists. Distinct
- /// from `entity_exists`, which is for first-class entities only.
- fn object_exists(&self, id: ObjectId) -> bool;
-
- /// A generic, untyped view of any entity (id + kind + coarse bounds).
- fn get_entity(&mut self, id: ObjectId) -> ApiResult;
-
- /// The 2D curve geometry of a profile entity (polyline/closed curve) for
- /// sweep ops (`Extrude`/`Revolve`). `UnknownId`/`Unsupported` if not a profile.
- fn profile_curves(&self, id: ObjectId) -> ApiResult>;
-
- fn profile_plane(&self, _id: ObjectId) -> ApiResult {
- Ok(cadkernel::space::Plane::XY)
- }
-
- /// Apply a rigid similarity to any entity in place (same `ObjectId`).
- fn transform_entity(
- &mut self,
- id: ObjectId,
- placement: &crate::ops::PlacementSpec,
- ) -> ApiResult<()>;
-
- /// Validate that `id` exists and can be transformed, WITHOUT mutating.
- /// Used by `TransformMany` to pre-validate all ids before `push_undo` so the
- /// apply loop cannot fail part-way (all-or-nothing, the bulk contract). Default:
- /// existence-only (backends that restrict transform to a family override).
- fn ensure_transformable(&mut self, id: ObjectId) -> ApiResult<()> {
- if self.entity_exists(id) {
- Ok(())
- } else {
- Err(ApiError::UnknownId(id))
- }
- }
-
- /// Insert a vertex into a polyline at index `at` (polyline family only).
- fn add_vertex(&mut self, id: ObjectId, at: usize, point: [f64; 3]) -> ApiResult<()>;
-
- // ── queries (no undo, no bump; `&mut` because solid resolution may
- // populate the kernel body cache on miss) ─────────────────────────────
- fn bounds(&mut self, id: ObjectId) -> ApiResult;
- fn centroid(&mut self, id: ObjectId) -> ApiResult<[f64; 3]>;
- fn volume(&mut self, id: ObjectId) -> ApiResult;
- fn entity_exists(&self, id: ObjectId) -> bool;
- fn revision(&self) -> GeometryRevision;
-
- // ── per-op boundary ────────────────────────────────────────────────────
- /// Called BEFORE applying a write op (records the before-state undo snapshot).
- fn push_undo(&mut self, label: &str);
- /// Called AFTER a successful write op (one DeltaSnapshot + one geometry bump
- /// + one publish). NOT called on failure (a failed op records nothing).
- fn finalize_op(&mut self);
- /// Discard an undo capture after preparation or validation failed.
- fn cancel_op(&mut self) {}
-}
diff --git a/crates/ocs_doc_api/src/convert.rs b/crates/ocs_doc_api/src/convert.rs
deleted file mode 100644
index db1f0a22f..000000000
--- a/crates/ocs_doc_api/src/convert.rs
+++ /dev/null
@@ -1,271 +0,0 @@
-//! Entity conversions: map the crate's plain-data DTOs to acadrust
-//! `EntityType` and back. Host feature only (uses the real acadrust types). This
-//! module is host-side-capable but host-independent — it operates purely on
-//! acadrust entities and crate DTOs, so any host can reuse it.
-
-use acadrust::entities::{
- Arc, Circle, Ellipse, Line, LwPolyline, LwVertex, Point, Ray, Spline, XLine,
-};
-use acadrust::types::{Vector2, Vector3};
-use acadrust::EntityType;
-
-use crate::{Aabb, ApiError, ApiResult, Curve2Spec, GeometryErrorKind, ObjectId};
-
-/// Convert a profile entity (Line/Circle/Arc/LwPolyline) to `geom2d::Curve`s for
-/// sweep ops (`Extrude`/`Revolve`). Z is dropped (profiles lie on the XY plane).
-pub fn entity_to_profile_curves(entity: &EntityType) -> ApiResult> {
- use cadkernel::geom2d::{Arc as KArc, Circle as KCircle, Curve as KCurve, Line as KLine};
- let curves = match entity {
- EntityType::Line(l) => vec![KCurve::Line(KLine {
- start: [l.start.x, l.start.y],
- end: [l.end.x, l.end.y],
- })],
- EntityType::Circle(c) => vec![KCurve::Circle(KCircle {
- centre: [c.center.x, c.center.y],
- radius: c.radius,
- })],
- EntityType::Arc(a) => vec![KCurve::Arc(KArc {
- centre: [a.center.x, a.center.y],
- radius: a.radius,
- start_angle: a.start_angle,
- end_angle: a.end_angle,
- })],
- EntityType::LwPolyline(pl) => {
- if pl.vertices.len() < 2 {
- return Err(ApiError::validation(
- "profile",
- "polyline profile needs at least two vertices",
- ));
- }
- KCurve::Polyline(cadkernel::geom2d::Polyline {
- vertices: pl
- .vertices
- .iter()
- .map(|v| cadkernel::geom2d::PolylineVertex {
- position: [v.location.x, v.location.y],
- bulge: v.bulge,
- })
- .collect(),
- closed: pl.is_closed,
- })
- .segments()
- }
- _ => {
- return Err(ApiError::Unsupported(
- "profile conversion is supported for Line/Circle/Arc/LwPolyline only".into(),
- ))
- }
- };
- Ok(curves)
-}
-
-/// Apply a rigid similarity (rotation+translation+uniform scale) to a non-solid
-/// entity in place. Supports the common 2D families; `Solid3D` goes through the
-/// kernel path instead. Returns the transformed entity (same handle) for the
-/// caller to `update_entity`.
-pub fn transform_entity_geometry(
- entity: &EntityType,
- p: &crate::PlacementSpec,
-) -> ApiResult {
- crate::geom::validate_placement(p)?;
- let matrix = acadrust::types::Matrix4 {
- m: [
- [p.x_axis[0], p.y_axis[0], p.z_axis[0], p.origin[0]],
- [p.x_axis[1], p.y_axis[1], p.z_axis[1], p.origin[1]],
- [p.x_axis[2], p.y_axis[2], p.z_axis[2], p.origin[2]],
- [0.0, 0.0, 0.0, 1.0],
- ],
- };
- let mut moved = entity.clone();
- moved.apply_transform(&acadrust::types::Transform::from_matrix(matrix));
- Ok(moved)
-}
-
-fn v3(p: [f64; 3]) -> Vector3 {
- Vector3::new(p[0], p[1], p[2])
-}
-
-/// Convert a polyline bulge segment (start → end, bulge = tan(θ/4)) to a
-/// `geom2d::Curve::Arc`. Positive bulge = counter-clockwise arc; negative = clockwise.
-pub fn bulge_arc_segment(
- start: [f64; 2],
- end: [f64; 2],
- bulge: f64,
-) -> ApiResult {
- use cadkernel::geom2d::{Arc as KArc, Curve as KCurve};
- let arc = cadkernel::geom2d::BulgeArc::from_bulge(start, end, bulge)
- .ok_or_else(|| ApiError::validation("profile", "invalid bulge segment"))?;
- // The kernel's Arc is counter-clockwise; reverse clockwise endpoints.
- let (start_angle, end_angle) = if arc.sweep < 0.0 {
- (arc.end_angle, arc.start_angle)
- } else {
- (arc.start_angle, arc.end_angle)
- };
- Ok(KCurve::Arc(KArc {
- centre: arc.center,
- radius: arc.radius,
- start_angle,
- end_angle,
- }))
-}
-
-/// Build an acadrust entity for a 2D curve construction spec.
-pub fn curve_spec_to_entity(spec: &Curve2Spec) -> ApiResult {
- crate::validation::curve(spec)?;
- let entity = match spec {
- Curve2Spec::Line { start, end, .. } => {
- let mut e = Line::new();
- e.start = v3(*start);
- e.end = v3(*end);
- EntityType::Line(e)
- }
- Curve2Spec::Circle { centre, radius, .. } => {
- let mut e = Circle::new();
- e.center = v3(*centre);
- e.radius = *radius;
- EntityType::Circle(e)
- }
- Curve2Spec::Polyline { points, closed, .. } => {
- let mut e = LwPolyline::new();
- e.vertices = points
- .iter()
- .map(|p| LwVertex {
- location: Vector2::new(p[0], p[1]),
- bulge: 0.0,
- start_width: 0.0,
- end_width: 0.0,
- vertex_id: 0,
- })
- .collect();
- e.elevation = points.first().map_or(0.0, |p| p[2]);
- if points.iter().any(|p| p[2] != e.elevation) {
- return Err(ApiError::validation(
- "CreateCurve",
- "polyline points must share an elevation",
- ));
- }
- e.is_closed = *closed;
- EntityType::LwPolyline(e)
- }
- Curve2Spec::Point { position, .. } => {
- let mut e = Point::new();
- e.location = v3(*position);
- EntityType::Point(e)
- }
- Curve2Spec::Arc {
- centre,
- radius,
- start_angle,
- end_angle,
- ..
- } => {
- let mut e = Arc::new();
- e.center = v3(*centre);
- e.radius = *radius;
- e.start_angle = *start_angle;
- e.end_angle = *end_angle;
- EntityType::Arc(e)
- }
- Curve2Spec::Ellipse {
- centre,
- major_axis,
- ratio,
- start,
- end,
- ..
- } => {
- // Validate the minor/major ratio so the (major-axis) bounds never
- // under-bound: ratio must be in (0, 1].
- if !(*ratio > 0.0 && *ratio <= 1.0) {
- return Err(ApiError::validation(
- "CreateCurve",
- format!("ellipse minor_axis_ratio must be in (0, 1], got {ratio}"),
- ));
- }
- let mut e = Ellipse::new();
- e.center = v3(*centre);
- e.major_axis = v3(*major_axis);
- e.minor_axis_ratio = *ratio;
- e.start_parameter = *start;
- e.end_parameter = *end;
- EntityType::Ellipse(e)
- }
- Curve2Spec::Spline {
- degree,
- control_points,
- knots,
- weights,
- ..
- } => {
- let mut e = Spline::new();
- e.degree = *degree;
- e.control_points = control_points.iter().map(|p| v3(*p)).collect();
- e.knots = knots.clone();
- e.weights = weights.clone();
- EntityType::Spline(e)
- }
- Curve2Spec::Ray { origin, direction, .. } => {
- EntityType::Ray(Ray::new(v3(*origin), v3(*direction)))
- }
- Curve2Spec::XLine { origin, direction, .. } => {
- EntityType::XLine(XLine::new(v3(*origin), v3(*direction)))
- }
- };
- Ok(entity)
-}
-
-/// The acadrust `EntityType` variant name (for `EntityView::kind` / downcasts).
-pub fn entity_kind_name(entity: &EntityType) -> &'static str {
- match entity {
- EntityType::Solid3D(_) => "Solid3D",
- EntityType::Line(_) => "Line",
- EntityType::Circle(_) => "Circle",
- EntityType::LwPolyline(_) => "LwPolyline",
- EntityType::Polyline(_) => "Polyline",
- EntityType::Point(_) => "Point",
- EntityType::Arc(_) => "Arc",
- EntityType::Ellipse(_) => "Ellipse",
- EntityType::Spline(_) => "Spline",
- EntityType::Ray(_) => "Ray",
- EntityType::XLine(_) => "XLine",
- EntityType::Insert(_) => "Insert",
- EntityType::Viewport(_) => "Viewport",
- EntityType::Text(_) => "Text",
- EntityType::MText(_) => "MText",
- EntityType::AttributeDefinition(_) => "AttributeDefinition",
- EntityType::AttributeEntity(_) => "AttributeEntity",
- // Media & misc (phase 5, read-mostly): named so GetEntity reports a real kind.
- EntityType::RasterImage(_) => "RasterImage",
- EntityType::Table(_) => "Table",
- EntityType::Leader(_) => "Leader",
- EntityType::MultiLeader(_) => "MultiLeader",
- EntityType::MLine(_) => "MLine",
- EntityType::Mesh(_) => "Mesh",
- EntityType::Helix(_) => "Helix",
- EntityType::Region(_) => "Region",
- EntityType::Body(_) => "Body",
- EntityType::Surface(_) => "Surface",
- EntityType::Face3D(_) => "Face3D",
- EntityType::Dimension(_) => "Dimension",
- EntityType::Hatch(_) => "Hatch",
- _ => "Other",
- }
-}
-
-/// Existing entity bounds; unbounded or empty geometry returns an error.
-pub fn entity_bounds(entity: Option<&EntityType>, id: ObjectId) -> ApiResult {
- let entity = entity.ok_or(ApiError::UnknownId(id))?;
- if matches!(entity, EntityType::Ray(_) | EntityType::XLine(_)) {
- return Err(ApiError::Unsupported("unbounded entity".into()));
- }
- let bounds = entity.as_entity().bounding_box();
- let min = [bounds.min.x, bounds.min.y, bounds.min.z];
- let max = [bounds.max.x, bounds.max.y, bounds.max.z];
- if min.iter().chain(&max).any(|v| !v.is_finite()) {
- return Err(ApiError::geometry(
- GeometryErrorKind::Empty,
- "entity has no finite bounds",
- ));
- }
- Ok(Aabb { min, max })
-}
diff --git a/crates/ocs_doc_api/src/envelope.rs b/crates/ocs_doc_api/src/envelope.rs
deleted file mode 100644
index 0f847740f..000000000
--- a/crates/ocs_doc_api/src/envelope.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-//! The wire envelope. One request = ONE write op OR a query batch
-//! (read-only batching is safe: no mutation, no undo, no rollback).
-
-use serde::{Deserialize, Serialize};
-
-use crate::gen::{Operation, Query};
-use crate::id::ObjectId;
-use crate::query::QueryResult;
-use crate::revision::GeometryRevision;
-use crate::ENVELOPE_VERSION;
-
-/// The single request unit crossing the transport.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct DocApiEnvelope {
- /// Crate protocol version (`ENVELOPE_VERSION`). Bridges must check this.
- pub version: u16,
- pub body: EnvelopeBody,
-}
-
-impl DocApiEnvelope {
- pub fn validate_version(&self) -> crate::ApiResult<()> {
- if self.version != ENVELOPE_VERSION {
- return Err(crate::ApiError::Unsupported(format!(
- "envelope version {}",
- self.version
- )));
- }
- Ok(())
- }
-
- pub fn op(operation: Operation) -> Self {
- Self {
- version: ENVELOPE_VERSION,
- body: EnvelopeBody::Op(operation),
- }
- }
- pub fn queries(queries: Vec) -> Self {
- Self {
- version: ENVELOPE_VERSION,
- body: EnvelopeBody::Queries(queries),
- }
- }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub enum EnvelopeBody {
- /// Exactly ONE write op (write batching removed, plan §13). Atomic by itself.
- Op(Operation),
- /// One-or-more read-only queries answered together (safe: no mutation/undo).
- Queries(Vec),
-}
-
-/// The outcome of an applied write op.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub enum OpOutcome {
- /// A new entity was created; carries its fresh `ObjectId`.
- NewId(ObjectId),
- /// An existing entity was updated in place (same `ObjectId` preserved).
- Updated(ObjectId),
- /// Entities were deleted; carries the deleted ids (one for `Delete`, N for `DeleteMany`).
- Deleted(Vec),
- /// Many entities were created (bulk `CreateMany`); carries all fresh ids in order.
- NewIds(Vec),
-}
-
-impl OpOutcome {
- /// The single fresh id, for ops that create exactly one entity.
- pub fn new_id(&self) -> Option {
- match self {
- OpOutcome::NewId(id) => Some(*id),
- _ => None,
- }
- }
- /// All fresh ids, for bulk creates.
- pub fn new_ids(&self) -> &[ObjectId] {
- match self {
- OpOutcome::NewIds(ids) => ids,
- OpOutcome::NewId(id) => std::slice::from_ref(id),
- _ => &[],
- }
- }
-}
-
-/// The per-request result (and the query-batch answer carrier).
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct Receipt {
- /// Present for `EnvelopeBody::Op`; absent for pure queries.
- pub outcome: Option,
- /// One `QueryResult` per `Query` in a `Queries` batch (in order).
- pub query_results: Vec,
- /// The geometry revision after this request (== before, for pure queries).
- pub new_revision: GeometryRevision,
-}
diff --git a/crates/ocs_doc_api/src/error.rs b/crates/ocs_doc_api/src/error.rs
deleted file mode 100644
index 783ec1434..000000000
--- a/crates/ocs_doc_api/src/error.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-//! Structured error model. Serializable so IPC returns the
-//! same error the in-process executor produced.
-
-use serde::{Deserialize, Serialize};
-use thiserror::Error;
-
-use crate::id::ObjectId;
-
-/// Which kind of kernel failure occurred (a mapped `cadkernel` `Snag`).
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub enum GeometryErrorKind {
- /// The operation produced an empty / degenerate body.
- Empty,
- /// Boolean refused (coincident geometry, unsupported cut, …).
- BooleanFailed,
- /// Invalid input to a kernel constructor (e.g. non-positive radius).
- InvalidInput,
- /// ACIS lift/parse/lower failed.
- Acis,
- /// Any other kernel error (message carries detail).
- Other,
-}
-
-/// The single error type for the whole API. `commit`/ops return
-/// `Result<_, ApiError>`; on a failed op nothing is applied and no undo step is
-/// recorded (per-op atomicity).
-#[derive(Error, Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub enum ApiError {
- /// Input failed validation before any mutation (names the op + reason).
- #[error("validation failed on {op}: {reason}")]
- Validation { op: String, reason: String },
-
- /// The geometry kernel reported a failure (a mapped `Snag`).
- #[error("geometry kernel: {kind:?}: {msg}")]
- Geometry {
- kind: GeometryErrorKind,
- msg: String,
- },
-
- /// An `ObjectId` does not resolve to a live entity (stale/deleted/never existed).
- #[error("unknown ObjectId {0:?}")]
- UnknownId(ObjectId),
-
- /// The requested capability is not supported (e.g. over-cap bulk op, unimplemented family).
- #[error("unsupported capability: {0}")]
- Unsupported(String),
-
- /// The transport (IPC / channel) failed — disconnected, oversized, timeout.
- #[error("transport: {0}")]
- Transport(String),
-}
-
-pub type ApiResult = Result;
-
-impl ApiError {
- pub fn validation(op: &'static str, reason: impl Into) -> Self {
- ApiError::Validation {
- op: op.to_string(),
- reason: reason.into(),
- }
- }
- pub fn geometry(kind: GeometryErrorKind, msg: impl Into) -> Self {
- ApiError::Geometry {
- kind,
- msg: msg.into(),
- }
- }
-}
diff --git a/crates/ocs_doc_api/src/executor.rs b/crates/ocs_doc_api/src/executor.rs
deleted file mode 100644
index 423fc0658..000000000
--- a/crates/ocs_doc_api/src/executor.rs
+++ /dev/null
@@ -1,616 +0,0 @@
-//! The op executor: crate-owned logic mapping each
-//! `Operation`/`Query` to `DocApiBackend` calls. Both the in-process transport
-//! and the host's IPC executor use this — one implementation, versioned in the
-//! crate. Per-op atomicity: a write op validates its inputs and computes its
-//! geometry BEFORE calling `push_undo`, mutates, then `finalize_op` once.
-
-use crate::backend::DocApiBackend;
-use crate::envelope::{OpOutcome, Receipt};
-use crate::error::{ApiError, ApiResult};
-use crate::gen::{Operation, Query};
-use crate::id::ObjectId;
-use crate::ops::{BoolOp, EntitySpec, BULK_ITEM_CAP};
-use crate::query::QueryResult;
-
-/// Apply ONE write op atomically. On success: one undo step and an advanced revision.
-/// On failure: nothing applied, no undo, no bump (the op validates before mutating).
-pub fn apply_op(b: &mut B, op: Operation) -> ApiResult {
- let result = apply_op_inner(b, op);
- if result.is_err() {
- b.cancel_op();
- }
- result
-}
-
-fn apply_op_inner(b: &mut B, op: Operation) -> ApiResult {
- let name = op.op_name();
- crate::validation::operation(&op)?;
- match &op {
- Operation::TransformMany { ids, .. } | Operation::DeleteMany(ids) => {
- let unique: std::collections::HashSet<_> = ids.iter().collect();
- if ids.is_empty() || unique.len() != ids.len() {
- return Err(ApiError::validation(
- name,
- "batch ids must be nonempty and unique",
- ));
- }
- }
- Operation::SetXDataMany(records) => {
- if records.is_empty() {
- return Err(ApiError::validation(
- name,
- "SetXDataMany records must be nonempty",
- ));
- }
- if records.len() > BULK_ITEM_CAP {
- return Err(over_cap(name, records.len()));
- }
- let unique: std::collections::HashSet<_> = records.iter().map(|(id, _, _)| id).collect();
- if unique.len() != records.len() {
- return Err(ApiError::validation(
- name,
- "SetXDataMany records must have unique entity ids",
- ));
- }
- }
- _ => {}
- }
- if let Operation::Transform { placement, .. } | Operation::TransformMany { placement, .. } = &op
- {
- crate::geom::validate_placement(placement)?;
- }
- let outcome = match &op {
- Operation::CreateSolid(prim) => {
- let body = crate::geom::make_solid(prim)?;
- b.push_undo(name);
- let id = b.store_solid(&body)?;
- b.finalize_op();
- OpOutcome::NewId(id)
- }
- Operation::CreateCurve(spec) => {
- b.push_undo(name);
- let id = b.add_curve(spec)?;
- b.finalize_op();
- OpOutcome::NewId(id)
- }
- Operation::Extrude { profile, direction } => {
- let curves = profile_curves(b, *profile, name)?;
- let body = crate::geom::extrude(b.profile_plane(*profile)?, &curves, *direction)?;
- b.push_undo(name);
- let id = b.store_solid(&body)?;
- b.finalize_op();
- OpOutcome::NewId(id)
- }
- Operation::Revolve {
- profile,
- axis,
- angle,
- } => {
- let curves = profile_curves(b, *profile, name)?;
- let (pivot, axis_dir) = *axis;
- let body =
- crate::geom::revolve(b.profile_plane(*profile)?, &curves, pivot, axis_dir, *angle)?;
- b.push_undo(name);
- let id = b.store_solid(&body)?;
- b.finalize_op();
- OpOutcome::NewId(id)
- }
- Operation::Transform { id, placement } => {
- require_exists(b, *id, name)?;
- b.push_undo(name);
- b.transform_entity(*id, placement)?;
- b.finalize_op();
- OpOutcome::Updated(*id)
- }
- Operation::SolidBoolean {
- op: bop,
- a,
- b: bid,
- erase_sources,
- } => {
- // Resolve + combine BEFORE push_undo: pure computation, no mutation.
- let ba = b.resolve_body(*a).map_err(|_| ApiError::UnknownId(*a))?;
- let bb = b
- .resolve_body(*bid)
- .map_err(|_| ApiError::UnknownId(*bid))?;
- let result = crate::geom::boolean(&ba, &bb, *bop)?;
- // Validate the erase BEFORE mutating: if `b` cannot be removed (e.g.
- // locked layer), fail now rather than after `update_solid(a)` has
- // already committed a partial mutation.
- if *erase_sources {
- if a == bid {
- return Err(ApiError::validation(name, "boolean source ids must differ"));
- }
- b.can_modify(*a)?;
- b.can_remove(*bid)?;
- }
- b.push_undo(name);
- // `erase_sources`: the result lives at `a` (updated in place), `b` erased.
- // Otherwise store a fresh solid and leave both inputs untouched.
- let out_id = if *erase_sources {
- b.update_solid(*a, &result)?;
- b.remove_entity(*bid)?;
- *a
- } else {
- b.store_solid(&result)?
- };
- b.finalize_op();
- OpOutcome::NewId(out_id)
- }
- Operation::AddVertex { id, at, point } => {
- require_exists(b, *id, name)?;
- b.push_undo(name);
- b.add_vertex(*id, *at, *point)?;
- b.finalize_op();
- OpOutcome::Updated(*id)
- }
- Operation::Delete { id } => {
- // can_remove validates existence AND removability (locked layer) before
- // any mutation, so a locked entity errors cleanly instead of a no-op
- // reported as Deleted.
- b.can_remove(*id).map_err(|e| match e {
- ApiError::UnknownId(_) => {
- ApiError::validation(name, format!("unknown ObjectId {id:?}"))
- }
- other => other,
- })?;
- b.push_undo(name);
- b.remove_entity(*id)?;
- b.finalize_op();
- OpOutcome::Deleted(vec![*id])
- }
- Operation::CreateMany(specs) => {
- if specs.len() > BULK_ITEM_CAP {
- return Err(over_cap(name, specs.len()));
- }
- if specs.is_empty() {
- return Err(ApiError::validation(name, "batch must not be empty"));
- }
- for spec in specs {
- if let EntitySpec::Curve(curve) = spec {
- crate::validation::curve(curve)?;
- }
- }
- let ids = b.create_many(specs)?;
- OpOutcome::NewIds(ids)
- }
- Operation::TransformMany { ids, placement } => {
- if ids.len() > BULK_ITEM_CAP {
- return Err(over_cap(name, ids.len()));
- }
- // Pre-validate EVERYTHING fallible before push_undo (all-or-nothing,
- // the bulk contract): every id must exist AND be transformable, so the apply
- // loop below cannot fail part-way. `transform_entity` after this is
- // infallible-by-construction for the validated ids.
- for (i, id) in ids.iter().enumerate() {
- b.ensure_transformable(*id).map_err(|e| match e {
- ApiError::UnknownId(_) => stale_index(name, i, *id),
- other => match other {
- ApiError::Unsupported(msg) => ApiError::Validation {
- op: name.to_string(),
- reason: format!("index {i}: {msg}"),
- },
- o => o,
- },
- })?;
- }
- b.transform_many(ids, placement)?;
- OpOutcome::Updated(*ids.first().unwrap_or(&ObjectId::NULL))
- }
- Operation::DeleteMany(ids) => {
- if ids.len() > BULK_ITEM_CAP {
- return Err(over_cap(name, ids.len()));
- }
- // Pre-validate existence AND removability (locked layer) for every id
- // before push_undo, so the apply loop cannot fail part-way.
- for (i, id) in ids.iter().enumerate() {
- b.can_remove(*id).map_err(|e| match e {
- ApiError::UnknownId(_) => stale_index(name, i, *id),
- ApiError::Unsupported(msg) => ApiError::Validation {
- op: name.to_string(),
- reason: format!("index {i}: {msg}"),
- },
- other => other,
- })?;
- }
- b.push_undo(name);
- for id in ids {
- b.remove_entity(*id)?;
- }
- b.finalize_op();
- OpOutcome::Deleted(ids.clone())
- }
- Operation::CreateInsert(spec) => {
- // Validate the block name exists before committing (no rollback needed).
- b.push_undo(name);
- let id = b.add_insert(spec)?;
- b.finalize_op();
- OpOutcome::NewId(id)
- }
- Operation::CreateViewport(spec) => {
- b.push_undo(name);
- let id = b.add_viewport(spec)?;
- b.finalize_op();
- OpOutcome::NewId(id)
- }
- Operation::CreateText(spec) => {
- b.push_undo(name);
- let id = b.add_text(spec)?;
- b.finalize_op();
- OpOutcome::NewId(id)
- }
- Operation::CreateMText(spec) => {
- b.push_undo(name);
- let id = b.add_mtext(spec)?;
- b.finalize_op();
- OpOutcome::NewId(id)
- }
- Operation::SetTextContent { id, value } => {
- b.can_modify(*id).map_err(|e| match e {
- ApiError::UnknownId(_) => {
- ApiError::validation(name, format!("unknown ObjectId {id:?}"))
- }
- other => other,
- })?;
- b.push_undo(name);
- b.set_text_content(*id, value)?;
- b.finalize_op();
- OpOutcome::Updated(*id)
- }
- Operation::CreateHatch(spec) => {
- // Validate the boundary (>= 3 points) before committing.
- if spec.boundary.len() < 3 {
- return Err(ApiError::validation(
- name,
- "hatch boundary needs >= 3 points",
- ));
- }
- b.push_undo(name);
- let id = b.add_hatch(spec)?;
- b.finalize_op();
- OpOutcome::NewId(id)
- }
- Operation::CreateDimensionLinear(spec) => {
- b.push_undo(name);
- let id = b.add_dimension_linear(spec)?;
- b.finalize_op();
- OpOutcome::NewId(id)
- }
- Operation::SetAttribute { id, tag, value } => {
- b.can_modify(*id).map_err(|e| match e {
- ApiError::UnknownId(_) => {
- ApiError::validation(name, format!("unknown ObjectId {id:?}"))
- }
- other => other,
- })?;
- b.push_undo(name);
- b.set_attribute(*id, tag, value)?;
- b.finalize_op();
- OpOutcome::Updated(*id)
- }
- Operation::SetViewportView {
- id,
- view_target,
- view_height,
- } => {
- b.can_modify(*id).map_err(|e| match e {
- ApiError::UnknownId(_) => {
- ApiError::validation(name, format!("unknown ObjectId {id:?}"))
- }
- other => other,
- })?;
- b.push_undo(name);
- b.set_viewport_view(*id, *view_target, *view_height)?;
- b.finalize_op();
- OpOutcome::Updated(*id)
- }
- Operation::CreateRasterImage(spec) => {
- b.push_undo(name);
- let id = b.add_raster_image(spec)?;
- b.finalize_op();
- OpOutcome::NewId(id)
- }
- Operation::Loft { profiles } => {
- // Bound the section count like the bulk ops (one envelope can carry many
- // ids; an uncapped loft would be an unbounded kernel call on the UI thread).
- if profiles.len() > BULK_ITEM_CAP {
- return Err(over_cap(name, profiles.len()));
- }
- // Resolve every profile to its curve set BEFORE push_undo (all-or-nothing).
- if profiles.len() < 2 {
- return Err(ApiError::validation(name, "loft needs >= 2 profiles"));
- }
- let mut sections = Vec::with_capacity(profiles.len());
- for (i, p) in profiles.iter().enumerate() {
- let curves = profile_curves(b, *p, name).map_err(|e| at_index(name, i, e))?;
- sections.push((b.profile_plane(*p)?, curves));
- }
- b.push_undo(name);
- let id = b.loft(§ions)?;
- b.finalize_op();
- OpOutcome::NewId(id)
- }
- Operation::CreateDimensionRadius(spec) => {
- b.push_undo(name);
- let id = b.add_dimension_radius(spec)?;
- b.finalize_op();
- OpOutcome::NewId(id)
- }
- Operation::CreateDimensionDiameter(spec) => {
- b.push_undo(name);
- let id = b.add_dimension_diameter(spec)?;
- b.finalize_op();
- OpOutcome::NewId(id)
- }
- Operation::CreateDimensionAngular(spec) => {
- b.push_undo(name);
- let id = b.add_dimension_angular(spec)?;
- b.finalize_op();
- OpOutcome::NewId(id)
- }
- Operation::CreateAttributeDefinition(spec) => {
- b.push_undo(name);
- let id = b.add_attribute_definition(spec)?;
- b.finalize_op();
- OpOutcome::NewId(id)
- }
- Operation::CreateTable(spec) => {
- // Validate a non-empty, rectangular grid before committing.
- let cols = spec.data.first().map(|r| r.len()).unwrap_or(0);
- if spec.data.is_empty() || cols == 0 || spec.data.iter().any(|r| r.len() != cols) {
- return Err(ApiError::validation(
- name,
- "table needs a non-empty rectangular grid",
- ));
- }
- b.push_undo(name);
- let id = b.add_table(spec)?;
- b.finalize_op();
- OpOutcome::NewId(id)
- }
- Operation::CreateDimensionAngular2Ln(spec) => {
- b.push_undo(name);
- let id = b.add_dimension_angular2ln(spec)?;
- b.finalize_op();
- OpOutcome::NewId(id)
- }
- Operation::CreateLayer(info) => {
- b.push_undo(name);
- b.create_layer(info)?;
- b.finalize_op();
- OpOutcome::Updated(ObjectId::NULL)
- }
- Operation::UpdateLayer { name, info } => {
- b.push_undo(name);
- b.update_layer(name, info)?;
- b.finalize_op();
- OpOutcome::Updated(ObjectId::NULL)
- }
- Operation::DeleteLayer { name } => {
- b.push_undo(name);
- b.delete_layer(name)?;
- b.finalize_op();
- OpOutcome::Updated(ObjectId::NULL)
- }
- Operation::SetEntityLayer { id, layer } => {
- require_exists(b, *id, name)?;
- b.push_undo(name);
- b.set_entity_layer(*id, layer)?;
- b.finalize_op();
- OpOutcome::Updated(*id)
- }
- Operation::SetXData {
- id,
- application_name,
- record,
- } => {
- require_exists(b, *id, name)?;
- b.push_undo(name);
- b.set_xdata(*id, application_name, record.as_ref())?;
- b.finalize_op();
- OpOutcome::Updated(*id)
- }
- Operation::SetXDataMany(records) => {
- // A later locked entity must not leave earlier records changed.
- for (i, (id, _, _)) in records.iter().enumerate() {
- b.can_modify(*id).map_err(|e| match e {
- ApiError::UnknownId(_) => stale_index(name, i, *id),
- ApiError::Unsupported(reason) => {
- ApiError::validation(name, format!("index {i}: {reason}"))
- }
- other => other,
- })?;
- }
- b.push_undo(name);
- for (id, application_name, record) in records {
- b.set_xdata(*id, application_name, record.as_ref())?;
- }
- b.finalize_op();
- OpOutcome::Updated(ObjectId::NULL)
- }
- Operation::CreateXRecord(spec) => {
- b.push_undo(name);
- let id = b.add_xrecord(spec)?;
- b.finalize_op();
- OpOutcome::NewId(id)
- }
- Operation::SetXRecord { id, spec } => {
- require_object_exists(b, *id, name)?;
- b.push_undo(name);
- b.set_xrecord(*id, spec)?;
- b.finalize_op();
- OpOutcome::Updated(*id)
- }
- };
- Ok(Receipt {
- outcome: Some(outcome),
- query_results: Vec::new(),
- new_revision: b.revision(),
- })
-}
-
-/// Apply a batch of read-only queries (no undo, no bump; `&mut` because solid
-/// resolution may populate the kernel body cache on miss). Bounded like the bulk
-/// ops: a batch over `BULK_ITEM_CAP` is rejected before any work (the 64 MiB frame
-/// cap bounds message size, not count).
-pub fn apply_queries(b: &mut B, queries: Vec) -> ApiResult {
- if queries.len() > BULK_ITEM_CAP {
- return Err(ApiError::validation(
- "Queries",
- format!(
- "query batch over cap: {} > {}",
- queries.len(),
- BULK_ITEM_CAP
- ),
- ));
- }
- let mut results = Vec::with_capacity(queries.len());
- for q in &queries {
- let qname = q.query_name();
- let r = match q {
- Query::GetEntity { id } => {
- QueryResult::Entity(b.get_entity(*id).map_err(|e| label(qname, e))?)
- }
- Query::GetBounds { id } => {
- QueryResult::Bounds(b.bounds(*id).map_err(|e| label(qname, e))?)
- }
- Query::GetCentroid { id } => {
- QueryResult::Centroid(b.centroid(*id).map_err(|e| label(qname, e))?)
- }
- Query::GetVolume { id } => {
- QueryResult::Volume(b.volume(*id).map_err(|e| label(qname, e))?)
- }
- Query::GetIntersects { a, b: bid } => {
- let ba = b.bounds(*a).map_err(|e| label(qname, e))?;
- let bb = b.bounds(*bid).map_err(|e| label(qname, e))?;
- QueryResult::Intersects(ba.overlaps(&bb))
- }
- Query::GetGeometryRevision => QueryResult::Revision(b.revision()),
- Query::GetTextContent { id } => {
- QueryResult::TextContent(b.text_content(*id).map_err(|e| label(qname, e))?)
- }
- Query::GetHatchBoundary { id } => {
- QueryResult::HatchBoundary(b.hatch_boundary(*id).map_err(|e| label(qname, e))?)
- }
- Query::GetDimensionMeasurement { id } => QueryResult::DimensionMeasurement(
- b.dimension_measurement(*id).map_err(|e| label(qname, e))?,
- ),
- Query::GetAttributes { id } => {
- QueryResult::Attributes(b.attributes(*id).map_err(|e| label(qname, e))?)
- }
- Query::GetBlockEntities { block_name } => QueryResult::BlockEntities(
- b.block_entities(block_name).map_err(|e| label(qname, e))?,
- ),
- Query::GetViewportView { id } => {
- let (target, height) = b.viewport_view(*id).map_err(|e| label(qname, e))?;
- QueryResult::ViewportView { target, height }
- }
- Query::GetXData {
- id,
- application_name,
- } => QueryResult::XData(
- b.xdata(*id, application_name)
- .map_err(|e| label(qname, e))?
- .clone(),
- ),
- Query::GetXRecord { id } => {
- QueryResult::XRecord(b.xrecord(*id).map_err(|e| label(qname, e))?.ok_or_else(
- || ApiError::validation(qname, format!("ObjectId {id:?} is not an XRecord")),
- )?)
- }
- Query::ListLayers => QueryResult::Layers(b.layers().map_err(|e| label(qname, e))?),
- Query::GetEntityLayer { id } => {
- QueryResult::EntityLayer(b.entity_layer(*id).map_err(|e| label(qname, e))?)
- }
- Query::EnumerateEntities {
- kind,
- layer,
- include_bounds,
- } => QueryResult::Entities(
- b.enumerate_entities(kind.as_deref(), layer.as_deref(), *include_bounds)
- .map_err(|e| label(qname, e))?,
- ),
- Query::GetPointPosition { id } => QueryResult::PointPosition(
- b.point_position(*id).map_err(|e| label(qname, e))?,
- ),
- Query::GetLineGeometry { id } => {
- let (start, end) = b.line_geometry(*id).map_err(|e| label(qname, e))?;
- QueryResult::LineGeometry((start, end))
- }
- };
- results.push(r);
- }
- Ok(Receipt {
- outcome: None,
- query_results: results,
- new_revision: b.revision(),
- })
-}
-
-/// Attach the query name to an error for better diagnostics (uses `query_name`).
-fn label(query: &'static str, e: ApiError) -> ApiError {
- match e {
- ApiError::Validation { reason, .. } => ApiError::validation(query, reason),
- ApiError::UnknownId(id) => ApiError::validation(query, format!("unknown ObjectId {id:?}")),
- other => other,
- }
-}
-
-fn profile_curves(
- b: &B,
- profile: ObjectId,
- op: &'static str,
-) -> ApiResult> {
- if !b.entity_exists(profile) {
- return Err(ApiError::validation(
- op,
- format!("unknown ObjectId {profile:?}"),
- ));
- }
- b.profile_curves(profile)
-}
-
-/// Validate that an entity exists before performing an operation.
-fn require_exists(b: &B, id: ObjectId, op: &'static str) -> ApiResult<()> {
- if b.entity_exists(id) {
- Ok(())
- } else {
- Err(ApiError::validation(op, format!("unknown ObjectId {id:?}")))
- }
-}
-
-/// Validate that a named object exists before performing an operation.
-fn require_object_exists(b: &B, id: ObjectId, op: &'static str) -> ApiResult<()> {
- if b.object_exists(id) {
- Ok(())
- } else {
- Err(ApiError::validation(op, format!("unknown ObjectId {id:?}")))
- }
-}
-
-fn over_cap(op: &'static str, n: usize) -> ApiError {
- ApiError::validation(op, format!("bulk op over cap: {n} > {BULK_ITEM_CAP}"))
-}
-
-fn stale_index(op: &'static str, i: usize, id: ObjectId) -> ApiError {
- ApiError::validation(op, format!("stale ObjectId at index {i}: {id:?}"))
-}
-
-fn at_index(op: &'static str, i: usize, e: ApiError) -> ApiError {
- match e {
- ApiError::Validation { reason, .. } => {
- ApiError::validation(op, format!("index {i}: {reason}"))
- }
- other => other,
- }
-}
-
-/// Boolean op kind → kernel `Operation` (host feature only).
-#[cfg(feature = "host")]
-pub(crate) fn kernel_bool_op(op: BoolOp) -> cadkernel::brep::Operation {
- match op {
- BoolOp::Union => cadkernel::brep::Operation::Union,
- BoolOp::Intersection => cadkernel::brep::Operation::Intersection,
- BoolOp::Difference => cadkernel::brep::Operation::Difference,
- }
-}
diff --git a/crates/ocs_doc_api/src/facade.rs b/crates/ocs_doc_api/src/facade.rs
deleted file mode 100644
index ef6f2b13d..000000000
--- a/crates/ocs_doc_api/src/facade.rs
+++ /dev/null
@@ -1,1413 +0,0 @@
-//! The object-centric facade.
-//!
-//! Hierarchy: [`DocApi`] (root: session + transport) → [`Document`] →
-//! collections ([`SolidCollection`], [`CurveCollection`], [`EntityCollection`])
-//! → typed handles ([`Solid`], [`Line`], [`Circle`], [`Polyline`], [`Point`],
-//! [`Entity`]) carrying methods. Every handle = `{ ObjectId, Arc }` —
-//! `Clone`, `Send`, `Sync`; it never holds kernel geometry. Per-op autocommit:
-//! each method is ONE atomic host call = one undo step (no transactions).
-
-use std::sync::Arc;
-
-use crate::envelope::{DocApiEnvelope, Receipt};
-use crate::error::{ApiError, ApiResult};
-use crate::gen::{Operation, Query};
-use crate::id::ObjectId;
-use crate::ops::{BoolOp, Curve2Spec, PlacementSpec, SolidPrimitive, XDataRecord, XRecordSpec};
-use crate::query::{Aabb, EntityView, QueryResult};
-use crate::revision::GeometryRevision;
-use crate::transport::Transport;
-
-/// Shared session: the transport. Held by every handle. The transport already
-/// carries the tab binding (IPC) or the backend (in-process), so the session
-/// stores no per-tab field.
-#[derive(Clone)]
-pub struct Session {
- transport: Arc,
- valid_tab: bool,
-}
-
-impl Session {
- fn validate_tab(&self) -> ApiResult<()> {
- if !self.valid_tab {
- return Err(ApiError::validation(
- "document",
- "transport is bound to another tab",
- ));
- }
- Ok(())
- }
- fn same_transport(&self, other: &Session) -> ApiResult<()> {
- self.validate_tab()?;
- other.validate_tab()?;
- if !Arc::ptr_eq(&self.transport, &other.transport) {
- return Err(ApiError::validation(
- "document",
- "handles belong to different sessions",
- ));
- }
- Ok(())
- }
- fn apply_op(&self, op: Operation) -> ApiResult {
- self.validate_tab()?;
- self.transport.apply(DocApiEnvelope::op(op))
- }
- fn apply_queries(&self, queries: Vec) -> ApiResult {
- self.validate_tab()?;
- self.transport.apply(DocApiEnvelope::queries(queries))
- }
- fn one_query(&self, q: Query) -> ApiResult {
- let mut r = self.apply_queries(vec![q])?;
- let result = r.query_results.drain(..).next();
- result.ok_or_else(|| ApiError::Transport("empty query result".into()))
- }
-}
-
-/// The API root: owns the session (transport + active tab). Entry point.
-#[derive(Clone)]
-pub struct DocApi {
- transport: Arc,
- active_tab: u64,
-}
-
-impl DocApi {
- /// Connect over an existing transport (IPC or in-process) bound to `active_tab`.
- pub fn connect(transport: Arc, active_tab: u64) -> Self {
- Self {
- transport,
- active_tab,
- }
- }
- /// Connect in-process over a backend (host feature).
- #[cfg(feature = "host")]
- pub fn in_process(
- backend: B,
- active_tab: u64,
- ) -> Self {
- Self::connect(
- Arc::new(crate::transport::InProcess::new(backend)),
- active_tab,
- )
- }
-
- /// The active tab id this root is bound to.
- pub fn active_tab(&self) -> u64 {
- self.active_tab
- }
-
- /// Liveness probe of the host/transport.
- pub fn alive(&self) -> bool {
- self.transport.alive()
- }
-
- /// Bind a document to the transport's tab. Requests for another tab fail.
- pub fn document(&self, tab: u64) -> Document {
- Document {
- session: Session {
- transport: Arc::clone(&self.transport),
- valid_tab: tab == self.active_tab,
- },
- }
- }
-}
-
-/// One open document tab: factory + lookup + queries + read-guards.
-#[derive(Clone)]
-pub struct Document {
- session: Session,
-}
-
-impl Document {
- pub fn solids(&self) -> SolidCollection {
- SolidCollection {
- session: self.session.clone(),
- }
- }
- pub fn curves(&self) -> CurveCollection {
- CurveCollection {
- session: self.session.clone(),
- }
- }
- pub fn entities(&self) -> EntityCollection {
- EntityCollection {
- session: self.session.clone(),
- }
- }
-
- /// Current geometry revision (query, no bump).
- pub fn revision(&self) -> ApiResult {
- match self.session.one_query(Query::GetGeometryRevision)? {
- QueryResult::Revision(r) => Ok(r),
- _ => Err(ApiError::Transport("unexpected revision result".into())),
- }
- }
-
- /// Standalone read-guard: fail with `ApiError::Validation` if the document's
- /// revision moved past `expected` (read-modify-write guard; NOT a batch pre-condition).
- pub fn assert_revision(&self, expected: GeometryRevision) -> ApiResult<()> {
- let now = self.revision()?;
- if now == expected {
- Ok(())
- } else {
- Err(ApiError::Validation {
- op: "assert_revision".to_string(),
- reason: format!(
- "revision moved: expected {expected:?}, now {now:?}; re-read and retry"
- ),
- })
- }
- }
-
- /// Read-only traversal of a block definition's entities (ids + kinds + bounds).
- pub fn block_entities(&self, block_name: &str) -> ApiResult> {
- match self.session.one_query(Query::GetBlockEntities {
- block_name: block_name.to_string(),
- })? {
- QueryResult::BlockEntities(v) => Ok(v),
- _ => Err(ApiError::Transport(
- "unexpected block-entities result".into(),
- )),
- }
- }
-
- /// List all layers in the document.
- pub fn layers(&self) -> ApiResult> {
- match self.session.one_query(Query::ListLayers)? {
- QueryResult::Layers(v) => Ok(v),
- _ => Err(ApiError::Transport("unexpected layers result".into())),
- }
- }
-
- /// Create a new layer. One undo step; fails if the normalized name already
- /// exists or is empty.
- pub fn create_layer(&self, info: &crate::ops::LayerInfo) -> ApiResult<()> {
- if !crate::layer::is_valid_layer_name(&info.name) {
- return Err(ApiError::validation(
- "CreateLayer",
- "empty layer name",
- ));
- }
- self.session
- .apply_op(Operation::CreateLayer(info.clone()))?;
- Ok(())
- }
-
- /// Update an existing layer's properties by name. One undo step; `info.name`
- /// becomes the new display name (case-insensitive key unchanged).
- pub fn update_layer(&self, name: &str, info: &crate::ops::LayerInfo) -> ApiResult<()> {
- if !crate::layer::is_valid_layer_name(&info.name) {
- return Err(ApiError::validation(
- "UpdateLayer",
- "empty layer name",
- ));
- }
- self.session.apply_op(Operation::UpdateLayer {
- name: name.to_string(),
- info: info.clone(),
- })?;
- Ok(())
- }
-
- /// Delete a layer by name. One undo step; fails for layer "0", the current
- /// layer, or any layer still referenced by entities.
- pub fn delete_layer(&self, name: &str) -> ApiResult<()> {
- self.session.apply_op(Operation::DeleteLayer {
- name: name.to_string(),
- })?;
- Ok(())
- }
-
- /// Set XDATA on many entities in a single atomic operation.
- ///
- /// Each tuple is `(entity_id, application_name, record)`. Pass `None` for
- /// `record` to delete the application's data. Fails up-front if any id is
- /// invalid; the whole batch is one undo step.
- pub fn set_xdata_many(&self, items: I) -> ApiResult<()>
- where
- I: IntoIterator- )>,
- S: Into,
- {
- let updates: Vec<_> = items
- .into_iter()
- .map(|(id, app, record)| (id, app.into(), record))
- .collect();
- if updates.is_empty() {
- return Ok(());
- }
- self.session.apply_op(Operation::SetXDataMany(updates))?;
- Ok(())
- }
-
- /// Batch of read-only queries in ONE round-trip (safe: no mutation/undo).
- /// The closure records queries on a [`QueryBatch`]; the results are returned
- /// in the same order as a [`QueryResults`] view the caller destructures.
- pub fn query_batch(&self, f: F) -> ApiResult {
- let mut qb = QueryBatch {
- queries: Vec::new(),
- session: self.session.clone(),
- error: None,
- };
- f(&mut qb);
- if let Some(error) = qb.error {
- return Err(error);
- }
- let receipt = self.session.apply_queries(qb.queries)?;
- Ok(QueryResults {
- results: receipt.query_results,
- })
- }
-}
-
-/// Records queries for [`Document::query_batch`]. Each method appends one query.
-pub struct QueryBatch {
- queries: Vec,
- session: Session,
- error: Option,
-}
-
-impl QueryBatch {
- fn check(&mut self, e: &impl HasId) {
- if let Err(error) = e.validate_session(&self.session) {
- self.error = Some(error);
- }
- }
- pub fn bounds(&mut self, e: &impl HasId) {
- self.check(e);
- self.queries.push(Query::GetBounds { id: e.id() });
- }
- pub fn volume(&mut self, e: &impl HasId) {
- self.check(e);
- self.queries.push(Query::GetVolume { id: e.id() });
- }
- pub fn centroid(&mut self, e: &impl HasId) {
- self.check(e);
- self.queries.push(Query::GetCentroid { id: e.id() });
- }
- pub fn intersects(&mut self, a: &impl HasId, b: &impl HasId) {
- self.check(a);
- self.check(b);
- self.queries.push(Query::GetIntersects {
- a: a.id(),
- b: b.id(),
- });
- }
- pub fn revision(&mut self) {
- self.queries.push(Query::GetGeometryRevision);
- }
-}
-
-/// Ordered results of a [`Document::query_batch`], one per recorded query.
-pub struct QueryResults {
- results: Vec,
-}
-
-impl QueryResults {
- fn at(&self, i: usize) -> ApiResult<&QueryResult> {
- self.results
- .get(i)
- .ok_or_else(|| ApiError::Transport("query result missing".into()))
- }
- pub fn bounds(&self, i: usize) -> ApiResult {
- match self.at(i)? {
- QueryResult::Bounds(b) => Ok(*b),
- _ => Err(ApiError::Transport("result is not bounds".into())),
- }
- }
- pub fn volume(&self, i: usize) -> ApiResult {
- match self.at(i)? {
- QueryResult::Volume(v) => Ok(*v),
- _ => Err(ApiError::Transport("result is not volume".into())),
- }
- }
- pub fn centroid(&self, i: usize) -> ApiResult<[f64; 3]> {
- match self.at(i)? {
- QueryResult::Centroid(c) => Ok(*c),
- _ => Err(ApiError::Transport("result is not centroid".into())),
- }
- }
- pub fn intersects(&self, i: usize) -> ApiResult {
- match self.at(i)? {
- QueryResult::Intersects(x) => Ok(*x),
- _ => Err(ApiError::Transport("result is not intersects".into())),
- }
- }
- pub fn revision(&self, i: usize) -> ApiResult {
- match self.at(i)? {
- QueryResult::Revision(r) => Ok(*r),
- _ => Err(ApiError::Transport("result is not revision".into())),
- }
- }
-}
-
-/// Something with an `ObjectId` (all handles + raw ids).
-pub trait HasId {
- fn id(&self) -> ObjectId;
- /// Typed handles retain their session; raw ids are relative to the receiver.
- fn session(&self) -> Option<&Session> {
- None
- }
- fn validate_session(&self, target: &Session) -> ApiResult<()> {
- if let Some(session) = self.session() {
- session.same_transport(target)?;
- }
- Ok(())
- }
-}
-impl HasId for ObjectId {
- fn id(&self) -> ObjectId {
- *self
- }
-}
-
-// ── Typed handles ────────────────────────────────────────────────────────────
-
-macro_rules! handle {
- ($name:ident) => {
- #[derive(Clone)]
- pub struct $name {
- session: Session,
- id: ObjectId,
- }
- impl std::fmt::Debug for $name {
- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- write!(f, concat!(stringify!($name), "({:?})"), self.id)
- }
- }
- impl $name {
- fn new(session: Session, id: ObjectId) -> Self {
- Self { session, id }
- }
- }
- impl HasId for $name {
- fn session(&self) -> Option<&Session> {
- Some(&self.session)
- }
- fn id(&self) -> ObjectId {
- self.id
- }
- }
- };
-}
-
-macro_rules! entity_handle {
- ($name:ident) => {
- handle!($name);
- impl $name {
- pub fn bounds(&self) -> ApiResult {
- match self.session.one_query(Query::GetBounds { id: self.id })? {
- QueryResult::Bounds(b) => Ok(b),
- _ => Err(ApiError::Transport("unexpected bounds result".into())),
- }
- }
- pub fn delete(&self) -> ApiResult<()> {
- self.session.apply_op(Operation::Delete { id: self.id })?;
- Ok(())
- }
- pub fn transform(&self, placement: PlacementSpec) -> ApiResult<()> {
- self.session.apply_op(Operation::Transform {
- id: self.id,
- placement,
- })?;
- Ok(())
- }
- /// Return the entity's current layer name (normalized uppercase).
- pub fn layer(&self) -> ApiResult {
- match self
- .session
- .one_query(Query::GetEntityLayer { id: self.id })?
- {
- QueryResult::EntityLayer(name) => Ok(name),
- _ => Err(ApiError::Transport("unexpected entity layer result".into())),
- }
- }
- /// Move the entity to a different layer. One undo step; fails if the
- /// target layer does not exist or is locked.
- pub fn set_layer(&self, layer: &str) -> ApiResult<()> {
- self.session.apply_op(Operation::SetEntityLayer {
- id: self.id,
- layer: layer.to_string(),
- })?;
- Ok(())
- }
- }
- };
-}
-
-entity_handle!(Entity);
-entity_handle!(Solid);
-entity_handle!(Line);
-entity_handle!(Circle);
-entity_handle!(Polyline);
-entity_handle!(Point);
-entity_handle!(ArcCurve);
-entity_handle!(Ellipse);
-entity_handle!(Spline);
-entity_handle!(Ray);
-entity_handle!(XLine);
-entity_handle!(Text);
-entity_handle!(MText);
-entity_handle!(Dimension);
-handle!(XRecord);
-
-impl XRecord {
- /// Read the XRECORD payload.
- pub fn payload(&self) -> ApiResult {
- match self.session.one_query(Query::GetXRecord { id: self.id })? {
- QueryResult::XRecord(spec) => Ok(spec),
- _ => Err(ApiError::Transport("unexpected xrecord result".into())),
- }
- }
- /// Replace the XRECORD payload in place (one undo step).
- pub fn set_payload(&self, spec: &XRecordSpec) -> ApiResult<()> {
- self.session.apply_op(Operation::SetXRecord {
- id: self.id,
- spec: spec.clone(),
- })?;
- Ok(())
- }
-}
-
-impl Dimension {
- /// The measured value of this dimension (distance for linear/radius, degrees
- /// for angular).
- pub fn measurement(&self) -> ApiResult {
- match self
- .session
- .one_query(Query::GetDimensionMeasurement { id: self.id })?
- {
- QueryResult::DimensionMeasurement(v) => Ok(v),
- _ => Err(ApiError::Transport("unexpected measurement result".into())),
- }
- }
-}
-
-impl Entity {
- pub fn view(&self) -> ApiResult {
- match self.session.one_query(Query::GetEntity { id: self.id })? {
- QueryResult::Entity(v) => Ok(v),
- _ => Err(ApiError::Transport("unexpected entity result".into())),
- }
- }
- /// This insert's attributes as (tag, value) pairs. Insert-only.
- pub fn attributes(&self) -> ApiResult> {
- match self
- .session
- .one_query(Query::GetAttributes { id: self.id })?
- {
- QueryResult::Attributes(v) => Ok(v),
- _ => Err(ApiError::Transport("unexpected attributes result".into())),
- }
- }
- /// Set an attribute `value` for `tag` on this insert (adds if absent). One undo step.
- pub fn set_attribute(&self, tag: &str, value: &str) -> ApiResult<()> {
- self.session.apply_op(Operation::SetAttribute {
- id: self.id,
- tag: tag.to_string(),
- value: value.to_string(),
- })?;
- Ok(())
- }
- /// This viewport's view (target WCS + zoom height). Viewport-only.
- pub fn viewport_view(&self) -> ApiResult<([f64; 3], f64)> {
- match self
- .session
- .one_query(Query::GetViewportView { id: self.id })?
- {
- QueryResult::ViewportView { target, height } => Ok((target, height)),
- _ => Err(ApiError::Transport(
- "unexpected viewport-view result".into(),
- )),
- }
- }
- /// Retarget / re-zoom this viewport (one undo step). Viewport-only.
- pub fn set_view(&self, view_target: [f64; 3], view_height: f64) -> ApiResult<()> {
- self.session.apply_op(Operation::SetViewportView {
- id: self.id,
- view_target,
- view_height,
- })?;
- Ok(())
- }
- /// The XDATA record for `application_name` on this entity (`None` if absent).
- pub fn xdata(&self, application_name: &str) -> ApiResult> {
- match self.session.one_query(Query::GetXData {
- id: self.id,
- application_name: application_name.to_string(),
- })? {
- QueryResult::XData(v) => Ok(v),
- _ => Err(ApiError::Transport("unexpected xdata result".into())),
- }
- }
- /// Attach or replace an XDATA record for `application_name` on this entity.
- /// Pass `None` to remove the record (one undo step).
- pub fn set_xdata(&self, application_name: &str, record: Option) -> ApiResult<()> {
- self.session.apply_op(Operation::SetXData {
- id: self.id,
- application_name: application_name.to_string(),
- record,
- })?;
- Ok(())
- }
- pub fn as_solid(&self) -> Option {
- // Typed downcast is validated by the view's kind.
- matches!(self.view().ok()?.kind.as_str(), "Solid3D")
- .then(|| Solid::new(self.session.clone(), self.id))
- }
-}
-
-impl Solid {
- fn boolean(&self, op: BoolOp, other: &Solid) -> ApiResult {
- self.session.same_transport(&other.session)?;
- let receipt = self.session.apply_op(Operation::SolidBoolean {
- op,
- a: self.id,
- b: other.id,
- erase_sources: true,
- })?;
- let id = receipt
- .outcome
- .and_then(|o| o.new_id())
- .ok_or_else(|| ApiError::Transport("boolean returned no id".into()))?;
- Ok(Solid::new(self.session.clone(), id))
- }
- pub fn intersect(&self, other: &Solid) -> ApiResult {
- self.boolean(BoolOp::Intersection, other)
- }
- pub fn union(&self, other: &Solid) -> ApiResult {
- self.boolean(BoolOp::Union, other)
- }
- pub fn subtract(&self, other: &Solid) -> ApiResult {
- self.boolean(BoolOp::Difference, other)
- }
- pub fn volume(&self) -> ApiResult {
- match self.session.one_query(Query::GetVolume { id: self.id })? {
- QueryResult::Volume(v) => Ok(v),
- _ => Err(ApiError::Transport("unexpected volume result".into())),
- }
- }
- pub fn centroid(&self) -> ApiResult<[f64; 3]> {
- match self.session.one_query(Query::GetCentroid { id: self.id })? {
- QueryResult::Centroid(c) => Ok(c),
- _ => Err(ApiError::Transport("unexpected centroid result".into())),
- }
- }
- pub fn intersects(&self, other: &Solid) -> ApiResult {
- self.session.same_transport(&other.session)?;
- match self.session.one_query(Query::GetIntersects {
- a: self.id,
- b: other.id,
- })? {
- QueryResult::Intersects(x) => Ok(x),
- _ => Err(ApiError::Transport("unexpected intersects result".into())),
- }
- }
-}
-
-impl Polyline {
- pub fn add_vertex(&self, at: usize, point: [f64; 3]) -> ApiResult<()> {
- self.session.apply_op(Operation::AddVertex {
- id: self.id,
- at,
- point,
- })?;
- Ok(())
- }
-}
-
-macro_rules! text_handle {
- ($name:ident) => {
- impl $name {
- /// The text content of this annotation.
- pub fn content(&self) -> ApiResult {
- match self
- .session
- .one_query(Query::GetTextContent { id: self.id })?
- {
- QueryResult::TextContent(s) => Ok(s),
- _ => Err(ApiError::Transport("unexpected content result".into())),
- }
- }
- /// Replace the text content (one undo step).
- pub fn set_content(&self, value: &str) -> ApiResult<()> {
- self.session.apply_op(Operation::SetTextContent {
- id: self.id,
- value: value.to_string(),
- })?;
- Ok(())
- }
- }
- };
-}
-text_handle!(Text);
-text_handle!(MText);
-
-// ── Collections (construction / lookup) ─────────────────────────────────────
-
-#[derive(Clone)]
-pub struct SolidCollection {
- session: Session,
-}
-
-impl SolidCollection {
- fn create(&self, prim: SolidPrimitive) -> ApiResult {
- let receipt = self.session.apply_op(Operation::CreateSolid(prim))?;
- let id = receipt
- .outcome
- .and_then(|o| o.new_id())
- .ok_or_else(|| ApiError::Transport("create_solid returned no id".into()))?;
- Ok(Solid::new(self.session.clone(), id))
- }
- pub fn create_cuboid(&self, origin: [f64; 3], size: [f64; 3]) -> ApiResult {
- self.create(SolidPrimitive::Cuboid { origin, size })
- }
- pub fn create_sphere(&self, centre: [f64; 3], radius: f64) -> ApiResult {
- self.create(SolidPrimitive::Sphere { centre, radius })
- }
- pub fn create_cylinder(&self, base: [f64; 3], radius: f64, height: f64) -> ApiResult {
- self.create(SolidPrimitive::Cylinder {
- base,
- radius,
- height,
- })
- }
- pub fn create_cone(&self, base: [f64; 3], radius: f64, height: f64) -> ApiResult {
- self.create(SolidPrimitive::Cone {
- base,
- radius,
- height,
- })
- }
- pub fn create_torus(
- &self,
- centre: [f64; 3],
- major_radius: f64,
- minor_radius: f64,
- ) -> ApiResult {
- self.create(SolidPrimitive::Torus {
- centre,
- major_radius,
- minor_radius,
- })
- }
- pub fn create_wedge(&self, origin: [f64; 3], size: [f64; 3]) -> ApiResult {
- self.create(SolidPrimitive::Wedge { origin, size })
- }
- pub fn extrude(&self, profile: &impl HasId, direction: [f64; 3]) -> ApiResult {
- profile.validate_session(&self.session)?;
- let receipt = self.session.apply_op(Operation::Extrude {
- profile: profile.id(),
- direction,
- })?;
- let id = receipt
- .outcome
- .and_then(|o| o.new_id())
- .ok_or_else(|| ApiError::Transport("extrude returned no id".into()))?;
- Ok(Solid::new(self.session.clone(), id))
- }
- pub fn revolve(
- &self,
- profile: &impl HasId,
- pivot: [f64; 3],
- axis: [f64; 3],
- angle: f64,
- ) -> ApiResult {
- profile.validate_session(&self.session)?;
- let receipt = self.session.apply_op(Operation::Revolve {
- profile: profile.id(),
- axis: (pivot, axis),
- angle,
- })?;
- let id = receipt
- .outcome
- .and_then(|o| o.new_id())
- .ok_or_else(|| ApiError::Transport("revolve returned no id".into()))?;
- Ok(Solid::new(self.session.clone(), id))
- }
- /// Loft a solid through >= 2 profile entities (polylines/circles/arcs).
- pub fn loft(&self, profiles: &[impl HasId]) -> ApiResult {
- for profile in profiles {
- profile.validate_session(&self.session)?;
- }
- let ids: Vec = profiles.iter().map(|p| p.id()).collect();
- let receipt = self.session.apply_op(Operation::Loft { profiles: ids })?;
- let id = receipt
- .outcome
- .and_then(|o| o.new_id())
- .ok_or_else(|| ApiError::Transport("loft returned no id".into()))?;
- Ok(Solid::new(self.session.clone(), id))
- }
-}
-
-#[derive(Clone)]
-pub struct CurveCollection {
- session: Session,
-}
-
-impl CurveCollection {
- fn create_curve(&self, spec: Curve2Spec) -> ApiResult<(Session, ObjectId)> {
- let receipt = self.session.apply_op(Operation::CreateCurve(spec))?;
- let id = receipt
- .outcome
- .and_then(|o| o.new_id())
- .ok_or_else(|| ApiError::Transport("create_curve returned no id".into()))?;
- Ok((self.session.clone(), id))
- }
- pub fn create_line(&self, start: [f64; 3], end: [f64; 3]) -> ApiResult {
- let (s, id) = self.create_curve(Curve2Spec::Line {
- start,
- end,
- layer: None,
- })?;
- Ok(Line::new(s, id))
- }
- pub fn create_line_on_layer(
- &self,
- start: [f64; 3],
- end: [f64; 3],
- layer: &str,
- ) -> ApiResult {
- let (s, id) = self.create_curve(Curve2Spec::Line {
- start,
- end,
- layer: Some(layer.to_string()),
- })?;
- Ok(Line::new(s, id))
- }
- pub fn create_circle(&self, centre: [f64; 3], radius: f64) -> ApiResult {
- let (s, id) = self.create_curve(Curve2Spec::Circle {
- centre,
- radius,
- layer: None,
- })?;
- Ok(Circle::new(s, id))
- }
- pub fn create_circle_on_layer(
- &self,
- centre: [f64; 3],
- radius: f64,
- layer: &str,
- ) -> ApiResult {
- let (s, id) = self.create_curve(Curve2Spec::Circle {
- centre,
- radius,
- layer: Some(layer.to_string()),
- })?;
- Ok(Circle::new(s, id))
- }
- pub fn create_polyline(&self, points: &[[f64; 3]], closed: bool) -> ApiResult {
- let (s, id) = self.create_curve(Curve2Spec::Polyline {
- points: points.to_vec(),
- closed,
- layer: None,
- })?;
- Ok(Polyline::new(s, id))
- }
- pub fn create_polyline_on_layer(
- &self,
- points: &[[f64; 3]],
- closed: bool,
- layer: &str,
- ) -> ApiResult {
- let (s, id) = self.create_curve(Curve2Spec::Polyline {
- points: points.to_vec(),
- closed,
- layer: Some(layer.to_string()),
- })?;
- Ok(Polyline::new(s, id))
- }
- pub fn create_point(&self, position: [f64; 3]) -> ApiResult {
- let (s, id) = self.create_curve(Curve2Spec::Point {
- position,
- layer: None,
- })?;
- Ok(Point::new(s, id))
- }
- pub fn create_point_on_layer(&self, position: [f64; 3], layer: &str) -> ApiResult {
- let (s, id) = self.create_curve(Curve2Spec::Point {
- position,
- layer: Some(layer.to_string()),
- })?;
- Ok(Point::new(s, id))
- }
- pub fn create_arc(
- &self,
- centre: [f64; 3],
- radius: f64,
- start_angle: f64,
- end_angle: f64,
- ) -> ApiResult {
- let (s, id) = self.create_curve(Curve2Spec::Arc {
- centre,
- radius,
- start_angle,
- end_angle,
- layer: None,
- })?;
- Ok(ArcCurve::new(s, id))
- }
- pub fn create_arc_on_layer(
- &self,
- centre: [f64; 3],
- radius: f64,
- start_angle: f64,
- end_angle: f64,
- layer: &str,
- ) -> ApiResult {
- let (s, id) = self.create_curve(Curve2Spec::Arc {
- centre,
- radius,
- start_angle,
- end_angle,
- layer: Some(layer.to_string()),
- })?;
- Ok(ArcCurve::new(s, id))
- }
- pub fn create_ellipse(
- &self,
- centre: [f64; 3],
- major_axis: [f64; 3],
- ratio: f64,
- start: f64,
- end: f64,
- ) -> ApiResult {
- let (s, id) = self.create_curve(Curve2Spec::Ellipse {
- centre,
- major_axis,
- ratio,
- start,
- end,
- layer: None,
- })?;
- Ok(Ellipse::new(s, id))
- }
- pub fn create_ellipse_on_layer(
- &self,
- centre: [f64; 3],
- major_axis: [f64; 3],
- ratio: f64,
- start: f64,
- end: f64,
- layer: &str,
- ) -> ApiResult {
- let (s, id) = self.create_curve(Curve2Spec::Ellipse {
- centre,
- major_axis,
- ratio,
- start,
- end,
- layer: Some(layer.to_string()),
- })?;
- Ok(Ellipse::new(s, id))
- }
- pub fn create_spline(
- &self,
- degree: i32,
- control_points: &[[f64; 3]],
- knots: &[f64],
- weights: &[f64],
- ) -> ApiResult {
- let (s, id) = self.create_curve(Curve2Spec::Spline {
- degree,
- control_points: control_points.to_vec(),
- knots: knots.to_vec(),
- weights: weights.to_vec(),
- layer: None,
- })?;
- Ok(Spline::new(s, id))
- }
- pub fn create_spline_on_layer(
- &self,
- degree: i32,
- control_points: &[[f64; 3]],
- knots: &[f64],
- weights: &[f64],
- layer: &str,
- ) -> ApiResult {
- let (s, id) = self.create_curve(Curve2Spec::Spline {
- degree,
- control_points: control_points.to_vec(),
- knots: knots.to_vec(),
- weights: weights.to_vec(),
- layer: Some(layer.to_string()),
- })?;
- Ok(Spline::new(s, id))
- }
- pub fn create_ray(&self, origin: [f64; 3], direction: [f64; 3]) -> ApiResult {
- let (s, id) = self.create_curve(Curve2Spec::Ray {
- origin,
- direction,
- layer: None,
- })?;
- Ok(Ray::new(s, id))
- }
- pub fn create_ray_on_layer(
- &self,
- origin: [f64; 3],
- direction: [f64; 3],
- layer: &str,
- ) -> ApiResult {
- let (s, id) = self.create_curve(Curve2Spec::Ray {
- origin,
- direction,
- layer: Some(layer.to_string()),
- })?;
- Ok(Ray::new(s, id))
- }
- pub fn create_xline(&self, origin: [f64; 3], direction: [f64; 3]) -> ApiResult {
- let (s, id) = self.create_curve(Curve2Spec::XLine {
- origin,
- direction,
- layer: None,
- })?;
- Ok(XLine::new(s, id))
- }
- pub fn create_xline_on_layer(
- &self,
- origin: [f64; 3],
- direction: [f64; 3],
- layer: &str,
- ) -> ApiResult {
- let (s, id) = self.create_curve(Curve2Spec::XLine {
- origin,
- direction,
- layer: Some(layer.to_string()),
- })?;
- Ok(XLine::new(s, id))
- }
- /// A RASTER_IMAGE placed at `insertion_point` (host auto-registers the image definition).
- pub fn create_raster_image(
- &self,
- file_path: &str,
- insertion_point: [f64; 3],
- u_vector: [f64; 3],
- v_vector: [f64; 3],
- size: [f64; 2],
- ) -> ApiResult {
- let receipt =
- self.session
- .apply_op(Operation::CreateRasterImage(crate::ops::RasterImageSpec {
- file_path: file_path.to_string(),
- insertion_point,
- u_vector,
- v_vector,
- size,
- }))?;
- let id = receipt
- .outcome
- .and_then(|o| o.new_id())
- .ok_or_else(|| ApiError::Transport("create_raster_image returned no id".into()))?;
- Ok(Entity::new(self.session.clone(), id))
- }
-
- /// A solid (or pattern) HATCH over a single closed polyline boundary.
- pub fn create_hatch(&self, boundary: &[[f64; 2]], solid: bool) -> ApiResult {
- let receipt = self
- .session
- .apply_op(Operation::CreateHatch(crate::ops::HatchSpec {
- boundary: boundary.to_vec(),
- solid,
- }))?;
- let id = receipt
- .outcome
- .and_then(|o| o.new_id())
- .ok_or_else(|| ApiError::Transport("create_hatch returned no id".into()))?;
- Ok(Entity::new(self.session.clone(), id))
- }
-
- /// A 2-line angular DIMENSION: angle between lines (vertex→first) and (vertex→second).
- pub fn create_dimension_angular2ln(
- &self,
- vertex: [f64; 3],
- first_point: [f64; 3],
- second_point: [f64; 3],
- arc_location: [f64; 3],
- ) -> ApiResult {
- let receipt = self.session.apply_op(Operation::CreateDimensionAngular2Ln(
- crate::ops::DimensionAngularSpec {
- vertex,
- first_point,
- second_point,
- arc_location,
- },
- ))?;
- let id = receipt
- .outcome
- .and_then(|o| o.new_id())
- .ok_or_else(|| ApiError::Transport("create_dimension returned no id".into()))?;
- Ok(Dimension::new(self.session.clone(), id))
- }
- /// A radial DIMENSION for the circle centered at `center` through `point`.
- pub fn create_dimension_radius(
- &self,
- center: [f64; 3],
- point: [f64; 3],
- ) -> ApiResult {
- self.create_dim_radial(Operation::CreateDimensionRadius, center, point)
- }
- /// A diameter DIMENSION for the circle with chord points `center`/`point`.
- pub fn create_dimension_diameter(
- &self,
- center: [f64; 3],
- point: [f64; 3],
- ) -> ApiResult {
- self.create_dim_radial(Operation::CreateDimensionDiameter, center, point)
- }
- fn create_dim_radial(
- &self,
- op: impl Fn(crate::ops::DimensionRadialSpec) -> Operation,
- center: [f64; 3],
- point: [f64; 3],
- ) -> ApiResult {
- let receipt = self
- .session
- .apply_op(op(crate::ops::DimensionRadialSpec { center, point }))?;
- let id = receipt
- .outcome
- .and_then(|o| o.new_id())
- .ok_or_else(|| ApiError::Transport("create_dimension returned no id".into()))?;
- Ok(Dimension::new(self.session.clone(), id))
- }
- /// A 3-point angular DIMENSION (vertex + one point on each leg).
- pub fn create_dimension_angular(
- &self,
- vertex: [f64; 3],
- first_point: [f64; 3],
- second_point: [f64; 3],
- arc_location: [f64; 3],
- ) -> ApiResult {
- let receipt = self.session.apply_op(Operation::CreateDimensionAngular(
- crate::ops::DimensionAngularSpec {
- vertex,
- first_point,
- second_point,
- arc_location,
- },
- ))?;
- let id = receipt
- .outcome
- .and_then(|o| o.new_id())
- .ok_or_else(|| ApiError::Transport("create_dimension returned no id".into()))?;
- Ok(Dimension::new(self.session.clone(), id))
- }
- /// A linear DIMENSION between `first_point` and `second_point`, with the
- /// dimension line placed at `definition_point`. `measurement()` reads the value.
- pub fn create_dimension_linear(
- &self,
- first_point: [f64; 3],
- second_point: [f64; 3],
- definition_point: [f64; 3],
- ) -> ApiResult {
- let receipt = self.session.apply_op(Operation::CreateDimensionLinear(
- crate::ops::DimensionSpec {
- first_point,
- second_point,
- definition_point,
- },
- ))?;
- let id = receipt
- .outcome
- .and_then(|o| o.new_id())
- .ok_or_else(|| ApiError::Transport("create_dimension returned no id".into()))?;
- Ok(Dimension::new(self.session.clone(), id))
- }
-
- /// Single-line TEXT annotation.
- pub fn create_text(
- &self,
- value: &str,
- insertion_point: [f64; 3],
- height: f64,
- rotation: f64,
- ) -> ApiResult {
- let receipt = self
- .session
- .apply_op(Operation::CreateText(crate::ops::TextSpec {
- value: value.to_string(),
- insertion_point,
- height,
- rotation,
- }))?;
- let id = receipt
- .outcome
- .and_then(|o| o.new_id())
- .ok_or_else(|| ApiError::Transport("create_text returned no id".into()))?;
- Ok(Text::new(self.session.clone(), id))
- }
- /// Multi-line MTEXT annotation.
- pub fn create_mtext(
- &self,
- value: &str,
- insertion_point: [f64; 3],
- height: f64,
- ) -> ApiResult {
- let receipt = self
- .session
- .apply_op(Operation::CreateMText(crate::ops::MTextSpec {
- value: value.to_string(),
- insertion_point,
- height,
- }))?;
- let id = receipt
- .outcome
- .and_then(|o| o.new_id())
- .ok_or_else(|| ApiError::Transport("create_mtext returned no id".into()))?;
- Ok(MText::new(self.session.clone(), id))
- }
- /// Bulk-create many points in ONE op: all-or-nothing, one undo step.
- /// Places points on the current layer (`layer: None`).
- pub fn create_points(&self, positions: &[[f64; 3]]) -> ApiResult> {
- let specs: Vec = positions
- .iter()
- .map(|&p| {
- crate::ops::EntitySpec::Curve(crate::ops::Curve2Spec::Point {
- position: p,
- layer: None,
- })
- })
- .collect();
- let receipt = self.session.apply_op(Operation::CreateMany(specs))?;
- let outcome = receipt
- .outcome
- .ok_or_else(|| ApiError::Transport("create_many returned no outcome".into()))?;
- Ok(outcome
- .new_ids()
- .iter()
- .map(|&id| Point::new(self.session.clone(), id))
- .collect())
- }
-
- /// Bulk-create many points on a specific layer in ONE op.
- pub fn create_points_on_layer(
- &self,
- positions: &[[f64; 3]],
- layer: &str,
- ) -> ApiResult> {
- let specs: Vec = positions
- .iter()
- .map(|&p| {
- crate::ops::EntitySpec::Curve(crate::ops::Curve2Spec::Point {
- position: p,
- layer: Some(layer.to_string()),
- })
- })
- .collect();
- let receipt = self.session.apply_op(Operation::CreateMany(specs))?;
- let outcome = receipt
- .outcome
- .ok_or_else(|| ApiError::Transport("create_many returned no outcome".into()))?;
- Ok(outcome
- .new_ids()
- .iter()
- .map(|&id| Point::new(self.session.clone(), id))
- .collect())
- }
-}
-
-#[derive(Clone)]
-pub struct EntityCollection {
- session: Session,
-}
-
-impl EntityCollection {
- /// Create a paper-space `VIEWPORT` (a `width`×`height` viewport at `center`
- /// looking at `view_target` with `view_height` zoom).
- pub fn create_viewport(
- &self,
- center: [f64; 3],
- width: f64,
- height: f64,
- view_target: [f64; 3],
- view_height: f64,
- ) -> ApiResult {
- let receipt =
- self.session
- .apply_op(Operation::CreateViewport(crate::ops::ViewportSpec {
- center,
- width,
- height,
- view_target,
- view_height,
- }))?;
- let id = receipt
- .outcome
- .and_then(|o| o.new_id())
- .ok_or_else(|| ApiError::Transport("create_viewport returned no id".into()))?;
- Ok(Entity::new(self.session.clone(), id))
- }
-
- /// Create a TABLE from a grid of cell strings (`data[row][column]`), at a point.
- pub fn create_table(
- &self,
- insertion_point: [f64; 3],
- data: &[Vec],
- ) -> ApiResult {
- let receipt = self
- .session
- .apply_op(Operation::CreateTable(crate::ops::TableSpec {
- insertion_point,
- data: data.to_vec(),
- }))?;
- let id = receipt
- .outcome
- .and_then(|o| o.new_id())
- .ok_or_else(|| ApiError::Transport("create_table returned no id".into()))?;
- Ok(Entity::new(self.session.clone(), id))
- }
-
- /// Create an ATTDEF (in-block attribute definition): tag/prompt/default at a point.
- pub fn create_attribute_definition(
- &self,
- tag: &str,
- prompt: &str,
- default_value: &str,
- insertion_point: [f64; 3],
- height: f64,
- rotation: f64,
- ) -> ApiResult {
- let receipt = self.session.apply_op(Operation::CreateAttributeDefinition(
- crate::ops::AttributeDefinitionSpec {
- tag: tag.to_string(),
- prompt: prompt.to_string(),
- default_value: default_value.to_string(),
- insertion_point,
- height,
- rotation,
- },
- ))?;
- let id = receipt.outcome.and_then(|o| o.new_id()).ok_or_else(|| {
- ApiError::Transport("create_attribute_definition returned no id".into())
- })?;
- Ok(Entity::new(self.session.clone(), id))
- }
-
- /// Place a block reference (`INSERT`) for `block_name` (must exist).
- pub fn create_insert(
- &self,
- block_name: &str,
- insert_point: [f64; 3],
- scale: f64,
- rotation: f64,
- ) -> ApiResult {
- let receipt = self
- .session
- .apply_op(Operation::CreateInsert(crate::ops::InsertSpec {
- block_name: block_name.to_string(),
- insert_point,
- scale,
- rotation,
- }))?;
- let id = receipt
- .outcome
- .and_then(|o| o.new_id())
- .ok_or_else(|| ApiError::Transport("create_insert returned no id".into()))?;
- Ok(Entity::new(self.session.clone(), id))
- }
-
- /// Generic lookup by id (any family) → `Entity` (downcast via `as_solid()`, …).
- pub fn get(&self, id: ObjectId) -> ApiResult {
- // Validate existence eagerly so `get` errors surface as `UnknownId`.
- self.session.one_query(Query::GetEntity { id })?;
- Ok(Entity::new(self.session.clone(), id))
- }
- pub fn delete(&self, id: ObjectId) -> ApiResult<()> {
- self.session.apply_op(Operation::Delete { id })?;
- Ok(())
- }
-
- /// Create a standalone `XRECORD` object.
- pub fn create_xrecord(&self, spec: &XRecordSpec) -> ApiResult {
- let receipt = self
- .session
- .apply_op(Operation::CreateXRecord(spec.clone()))?;
- let id = receipt
- .outcome
- .and_then(|o| o.new_id())
- .ok_or_else(|| ApiError::Transport("create_xrecord returned no id".into()))?;
- Ok(XRecord::new(self.session.clone(), id))
- }
-
- /// Lookup an `XRECORD` object by id and return a typed accessor handle.
- pub fn get_xrecord(&self, id: ObjectId) -> ApiResult {
- // Validate existence + that the payload is readable as an XRecord.
- match self.session.one_query(Query::GetXRecord { id })? {
- QueryResult::XRecord(_) => Ok(XRecord::new(self.session.clone(), id)),
- _ => Err(ApiError::Transport("unexpected xrecord result".into())),
- }
- }
-
- /// Bulk-create many entities in ONE op (all-or-nothing, one undo step).
- pub fn create_many(&self, specs: &[crate::ops::EntitySpec]) -> ApiResult> {
- let receipt = self.session.apply_op(Operation::CreateMany(specs.to_vec()))?;
- let outcome = receipt
- .outcome
- .ok_or_else(|| ApiError::Transport("create_many returned no outcome".into()))?;
- Ok(outcome
- .new_ids()
- .iter()
- .map(|&id| Entity::new(self.session.clone(), id))
- .collect())
- }
-
- /// Bulk transform (one op, all-or-nothing).
- pub fn transform_many(&self, ids: &[ObjectId], placement: PlacementSpec) -> ApiResult<()> {
- self.session.apply_op(Operation::TransformMany {
- ids: ids.to_vec(),
- placement,
- })?;
- Ok(())
- }
- /// Bulk delete (one op, all-or-nothing). Used by `OpGroup::compensate`.
- pub fn delete_many(&self, ids: &[ObjectId]) -> ApiResult<()> {
- self.session.apply_op(Operation::DeleteMany(ids.to_vec()))?;
- Ok(())
- }
-}
-
-// ── OpGroup: client-side failure-cleanup (NOT a transaction) ────────────────
-
-/// Tracks handles created during a logical operation so a later failure can be
-/// cleaned up with a bulk delete. Separate writes remain committed;
-/// no host involvement, no rollback.
-#[derive(Default)]
-pub struct OpGroup {
- created: Vec,
- session: Option,
-}
-
-impl OpGroup {
- pub fn new() -> Self {
- Self {
- created: Vec::new(),
- session: None,
- }
- }
- /// Record a created handle (propagating any construction error); returns it
- /// for fluent `grp.track(doc.solids().create_cuboid(..)?)?` use.
- pub fn track(&mut self, handle: ApiResult) -> ApiResult {
- let handle = handle?;
- if let Some(session) = handle.session() {
- if let Some(previous) = &self.session {
- previous.same_transport(session)?;
- } else {
- self.session = Some(session.clone());
- }
- }
- if !self.created.contains(&handle.id()) {
- self.created.push(handle.id());
- }
- Ok(handle)
- }
- /// Keep everything: drop the tracking without deleting.
- pub fn commit(self) {}
- /// Best-effort cleanup: delete every tracked entity (one `DeleteMany` op).
- /// Does not resurrect already-consumed/deleted entities.
- pub fn compensate(self, doc: &Document) -> ApiResult<()> {
- if let Some(session) = &self.session {
- session.same_transport(&doc.session)?;
- }
- if self.created.is_empty() {
- return Ok(());
- }
- doc.entities().delete_many(&self.created)
- }
-}
diff --git a/crates/ocs_doc_api/src/gen/api_reference.md b/crates/ocs_doc_api/src/gen/api_reference.md
deleted file mode 100644
index a0396caa1..000000000
--- a/crates/ocs_doc_api/src/gen/api_reference.md
+++ /dev/null
@@ -1,382 +0,0 @@
-# ocs_doc_api — API reference (auto-generated)
-
-Envelope version: `1`
-
-Do NOT edit: regenerated by `build.rs` from `spec/entities.toml`.
-
-## `Solid` (acadrust `Solid3D`, collection `solids`)
-
-B-rep solid. Host resolves bodies via the solid_models cache (lift-on-miss from ACIS SAT).
-
-### Constructors (`doc.solids()`)
-
-- **create_cuboid**(origin: [f64; 3], size: [f64; 3]) -> `Solid` — `CreateSolid`; fixed primitive="Cuboid"
-- **create_sphere**(centre: [f64; 3], radius: f64) -> `Solid` — `CreateSolid`; fixed primitive="Sphere"
-- **create_cylinder**(base: [f64; 3], radius: f64, height: f64) -> `Solid` — `CreateSolid`; fixed primitive="Cylinder"
-- **create_cone**(base: [f64; 3], radius: f64, height: f64) -> `Solid` — `CreateSolid`; fixed primitive="Cone"
-- **create_torus**(centre: [f64; 3], major_radius: f64, minor_radius: f64) -> `Solid` — `CreateSolid`; fixed primitive="Torus"
-- **create_wedge**(origin: [f64; 3], size: [f64; 3]) -> `Solid` — `CreateSolid`; fixed primitive="Wedge"
-- **extrude**(profile: EntityRef, direction: [f64; 3]) -> `Solid` — `Extrude`
-- **revolve**(profile: EntityRef, pivot: [f64; 3], axis: [f64; 3], angle: f64) -> `Solid` — `Revolve`
-- **loft**(profiles: &[EntityRef]) -> `Solid` — `Loft`
-
-### Methods
-
-- **intersect**(other: Solid) -> `Solid` — op `SolidBoolean`; fixed erase_sources=true, op="Intersection"
-- **union**(other: Solid) -> `Solid` — op `SolidBoolean`; fixed erase_sources=true, op="Union"
-- **subtract**(other: Solid) -> `Solid` — op `SolidBoolean`; fixed erase_sources=true, op="Difference"
-- **volume**() -> `f64` — query `GetVolume`
-- **centroid**() -> `[f64; 3]` — query `GetCentroid`
-- **intersects**(other: Solid) -> `bool` — query `GetIntersects`
-
-## `Line` (acadrust `Line`, collection `curves`)
-
-### Constructors (`doc.curves()`)
-
-- **create_line**(start: [f64; 3], end: [f64; 3]) -> `Line` — `CreateCurve`; fixed curve="Line"
-
-## `Circle` (acadrust `Circle`, collection `curves`)
-
-### Constructors (`doc.curves()`)
-
-- **create_circle**(centre: [f64; 3], radius: f64) -> `Circle` — `CreateCurve`; fixed curve="Circle"
-
-## `Polyline` (acadrust `LwPolyline`, collection `curves`)
-
-### Constructors (`doc.curves()`)
-
-- **create_polyline**(points: &[[f64; 3]], closed: bool) -> `Polyline` — `CreateCurve`; fixed curve="Polyline"
-
-### Methods
-
-- **add_vertex**(at: usize, point: [f64; 3]) -> `()` — op `AddVertex`
-
-## `Point` (acadrust `Point`, collection `curves`)
-
-### Constructors (`doc.curves()`)
-
-- **create_point**(position: [f64; 3]) -> `Point` — `CreateCurve`; fixed curve="Point"
-- **create_points**(positions: &[[f64; 3]]) -> `Vec