feat(wasm): route wire offsets through join-aware builder (offsetWire2DWithJoin)

[andymai]

Summary

Adds a wire-based offset entry point, `offsetWire2DWithJoin(wire, distance, joinType)`, so consumers that hold only a wire can route a corner join type (`intersection` / `arc` / `chamfer`) into the join-aware offset builder.

Previously only the face-based `offsetWireWithJoinType` honored the join type. A wire-only caller (e.g. a 2D sketch offset that starts from a wire, not a face) had no equivalent entry point and fell back to a sharp-corner polygon offset that silently ignored the requested join. This is a developer-API parity gap: `arc` and `intersection`/`chamfer` collapsed to the same sharp result.

What changed

• New binding `offsetWire2DWithJoin` in `crates/wasm/src/bindings/operations.rs`. It resolves the wire, builds a planar face from it internally, then delegates to `offset_wire_with_join` with the parsed join type. This reuses the existing topology-based join builder (real arcs/chamfers), not a polyline approximation.
• Matching `executeBatch` dispatch op in `crates/wasm/src/bindings/batch.rs`.
• Contract tests (driven through `executeBatch`) asserting:
  • the `arc` join produces a perimeter distinct from `chamfer` (proving the join type is actually threaded through), and
  • an unknown join-type string is rejected.

Validation

• `cargo test -p brepkit-wasm` (new tests pass)
• `cargo fmt --all`, `cargo clippy --all-targets -- -D warnings`
• `./scripts/check-boundaries.sh`
• pre-commit + pre-push hooks passed

Downstream

Unblocks the developer-API library from honoring its `arc`/`intersection`/`chamfer` wire-offset join kinds (the adapter currently ignores the join type for wire inputs). A follow-up consumer PR (kept in draft, blocked on the next published wasm release containing this change) removes the corresponding cross-kernel skip.

[github-actions]

WASM Binary Size

File	main	PR	Delta
brepkit_wasm.wasm	4.69 MB	4.69 MB	+3.0 KB (+0%)

⚠️ Size increased slightly.

[greptile-apps]

Greptile Summary

Adds offsetWire2DWithJoin, a new wire-based entry point that internally constructs a planar face and delegates to the existing join-aware offset builder, closing the API parity gap where wire-only callers could not route a join type into the topology-based offset path.

• New #[wasm_bindgen(js_name = \"offsetWire2DWithJoin\")] binding in operations.rs follows the existing offsetWireWithJoinType pattern; parse_join_type_str rejects unknown join strings with a clean error.
• Matching dispatch_op arm in batch.rs is consistent with existing offsetWire/offsetWireWithJoinType arms.
• Two contract tests (via executeBatch) verify that arc and chamfer joins produce distinct perimeters and that unknown join-type strings are rejected.

Confidence Score: 4/5

Safe to merge; the change is additive, tests pass, and the only gap is a missing early-validation guard on the distance parameter.

The new binding follows the established pattern for wire offset operations and the logic is correct. The one gap is that distance is not checked with validate_finite before being forwarded into the geometry kernel, unlike most other numeric-taking bindings in the file. A NaN or infinity distance would reach the offset algorithm rather than being caught at the binding boundary.

crates/wasm/src/bindings/operations.rs — the missing validate_finite(distance, "distance") call before the wire resolve.

Important Files Changed

Filename	Overview
crates/wasm/src/bindings/operations.rs	Adds offset_wire_2d_with_join WASM binding with correct js_name, error mapping, and doc-comments; distance is not validated with validate_finite before use (binding-rule gap).
crates/wasm/src/bindings/batch.rs	Adds offsetWire2DWithJoin arm to dispatch_op; logic mirrors the direct binding and is consistent with existing offsetWire/offsetWireWithJoinType dispatch arms.

Prompt To Fix All With AI

Fix the following 1 code review issue. Work through them one at a time, proposing concise fixes.

---

### Issue 1 of 1
crates/wasm/src/bindings/operations.rs:1208-1214
Missing `validate_finite` on `distance`. The binding rules require every public `#[wasm_bindgen]` method to validate numeric inputs via helpers from `error.rs`. Passing `NaN` or `±Inf` here will propagate silently into `offset_wire_with_join`, which can produce garbage geometry or a panic inside the kernel instead of a clean JS error.

```suggestion
    pub fn offset_wire_2d_with_join(
        &mut self,
        wire: u32,
        distance: f64,
        join_type: &str,
    ) -> Result<u32, JsError> {
        validate_finite(distance, "distance")?;
        let wire_id = self.resolve_wire(wire)?;
```

_{Reviews (1): Last reviewed commit: "feat(wasm): add wire-based offsetWire2DW..." | Re-trigger Greptile}

[greptile-apps]

Missing validate_finite on distance. The binding rules require every public #[wasm_bindgen] method to validate numeric inputs via helpers from error.rs. Passing NaN or ±Inf here will propagate silently into offset_wire_with_join, which can produce garbage geometry or a panic inside the kernel instead of a clean JS error.

Suggested change

	pub fn offset_wire_2d_with_join(
	&mut self,
	wire: u32,
	distance: f64,
	join_type: &str,
	) -> Result<u32, JsError> {
	let wire_id = self.resolve_wire(wire)?;
	pub fn offset_wire_2d_with_join(
	&mut self,
	wire: u32,
	distance: f64,
	join_type: &str,
	) -> Result<u32, JsError> {
	validate_finite(distance, "distance")?;
	let wire_id = self.resolve_wire(wire)?;

Prompt To Fix With AI

This is a comment left during a code review.
Path: crates/wasm/src/bindings/operations.rs
Line: 1208-1214

Comment:
Missing `validate_finite` on `distance`. The binding rules require every public `#[wasm_bindgen]` method to validate numeric inputs via helpers from `error.rs`. Passing `NaN` or `±Inf` here will propagate silently into `offset_wire_with_join`, which can produce garbage geometry or a panic inside the kernel instead of a clean JS error.

```suggestion
    pub fn offset_wire_2d_with_join(
        &mut self,
        wire: u32,
        distance: f64,
        join_type: &str,
    ) -> Result<u32, JsError> {
        validate_finite(distance, "distance")?;
        let wire_id = self.resolve_wire(wire)?;
```

How can I resolve this? If you propose a fix, please make it concise.

[Copilot]

Pull request overview

Adds a wire-only WASM entry point that preserves corner join semantics (intersection/arc/chamfer) by internally constructing a planar face from a wire and delegating to the existing join-aware offset builder. This closes an API parity gap where wire-only consumers could not select join style and effectively got sharp corners regardless of request.

Changes:

• Added offsetWire2DWithJoin(wire, distance, joinType) binding that routes join type through offset_wire_with_join.
• Added matching executeBatch dispatcher op ("offsetWire2DWithJoin").
• Added contract tests (via executeBatch) to verify join-type threading and rejection of unknown join types.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated no comments.

File	Description
crates/wasm/src/bindings/operations.rs	Introduces offsetWire2DWithJoin binding and adds tests validating join behavior and error handling.
crates/wasm/src/bindings/batch.rs	Adds batch dispatcher support for "offsetWire2DWithJoin" with consistent argument parsing and error mapping.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.