@richardmcquiston01/more-open-scad 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,37 @@
+# CHANGELOG
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+
+## [0.2.0] - 2026-09-23
+
+The first version actually published to npm.
+
+### Added
+
+- CSG plane/polygon splitting (`src/csg/split-polygon.ts`): `splitPolygon`, the geometric core of the BSP-tree boolean operations below. Classifies a polygon against a plane (coplanar/front/back/spanning) and clips spanning polygons into front/back pieces, preserving winding. Not part of the public API.
+- CSG BSP tree (`src/csg/bsp-tree.ts`): the classic Naylor/Thibault BSP-CSG tree (as popularized by csg.js), built on `splitPolygon` and adapted to this codebase's immutable conventions — `build`, `clipPolygons`, `clipTo`, `invert`, and `allPolygons` all return new trees rather than mutating one. Not part of the public API; `src/csg/boolean.ts` is the only consumer.
+- CSG boolean operations: `union`, `difference`, and `intersect`, matching OpenSCAD's `union()`/`difference()`/`intersection()`. Each takes two `Solid`s and returns a new one; chain calls to combine more than two (`union(union(a, b), c)`).
+- A tag-triggered npm publish workflow (`.github/workflows/publish.yml`): pushing a `v*.*.*` tag on `main` re-verifies typecheck/lint/test/build, then publishes.
+- The standard "Buy Me a Coffee" donate section in the README.
+
+## [0.1.0] - 2026-07-24
+
+Primitives, transforms, and STL export. Never published to npm — superseded by 0.2.0 before a release was cut.
+
+### Added
+
+- Primitives: `cube`, `sphere`, `cylinder`, and `polyhedron` (the arbitrary-mesh escape hatch), matching OpenSCAD's semantics — see each function's docs for its options.
+- Chainable transforms on `Solid`: `translate`, `rotate` (Euler angles), `rotateAxisAngle`, `scale` (uniform or per-axis), `mirror`, and `multmatrix` (arbitrary 4x4 transform). Normals transform correctly under non-uniform scale, and winding is automatically corrected for any handedness-flipping transform (e.g. `mirror`).
+- STL export: `toBinarySTL` and `toASCIISTL`, plus `isManifold` for checking a solid is watertight before exporting, and `triangulateSolid` for consumers who want raw per-facet triangle data directly (e.g. to feed a WebGL renderer).
+- The full `Vec3`/`Mat4` math toolkit and the underlying `Vertex`/`Polygon`/`Plane`/`Solid` geometry types, for consumers who want to inspect or hand-build geometry beyond what the primitives above cover.
+- Project scaffolding: TypeScript build/typecheck/lint/test pipeline (`bun`-based) and GitHub Actions CI.
+
+### Fixed
+
+- Removed `"sideEffects": false` from `package.json` — it was causing `bun build` to silently tree-shake away the entire bundled implementation behind the public barrel export (`src/index.ts`), shipping an empty package. Caught before publishing via an end-to-end smoke test against the actual built `dist/index.js`.
+
+### Changed
+
+- Pinned `prettier` to the exact installed version (`3.9.6`, was `^3.4.2`) so `bun run format` no longer produces unrelated diffs from version drift.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Richard McQuiston
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# MoreOpenSCAD
+
+## Overview
+
+Framework agnostic TypeScript based package for generating STL files using commands similar to OpenSCAD. Distributable via NPM for inclusion in TypeScript projects.
+
+## Prerequisites
+
+- [Node.js](https://nodejs.org/) 18+ or [Bun](https://bun.sh/) 1.0+
+- TypeScript 5+ (for consuming projects that want type checking)
+
+## Installation
+
+```sh
+bun add @richardmcquiston01/more-open-scad
+# or
+npm install @richardmcquiston01/more-open-scad
+```
+
+## Usage
+
+Build a shape with a primitive, chain transforms onto it, then export it to STL.
+
+```ts
+import { cube, Vec3, toBinarySTL } from '@richardmcquiston01/more-open-scad';
+
+const shape = cube(20, { center: true })
+  .translate(Vec3.vec3(0, 0, 10))
+  .rotateAxisAngle(Vec3.vec3(0, 0, 1), Math.PI / 4);
+
+const stl = toBinarySTL(shape); // Uint8Array
+```
+
+### Primitives
+
+`cube(size, options?)`, `sphere(r, options?)`, `cylinder(h, options?)`, and `polyhedron(points, faces)` (the arbitrary-mesh escape hatch) each build a `Solid`, matching OpenSCAD's semantics for the same primitive. See each function's JSDoc for its options (`center`, `fn`, `r`/`r1`/`r2`, etc.).
+
+### Transforms
+
+Every `Solid` has chainable, immutable transform methods: `translate`, `rotate` (Euler angles), `rotateAxisAngle`, `scale` (uniform or per-axis), `mirror`, and `multmatrix` (an arbitrary 4x4 transform, for anything the named methods don't cover). Each call returns a new `Solid` — none of them mutate the original.
+
+### Boolean operations
+
+`union(a, b)`, `difference(a, b)`, and `intersect(a, b)` combine two solids into a new one, matching OpenSCAD's `union()`/`difference()`/`intersection()`:
+
+```ts
+import { cube, difference, Vec3 } from '@richardmcquiston01/more-open-scad';
+
+const block = cube(20, { center: true });
+const hole = cube(8, { center: true }).translate(Vec3.vec3(0, 0, 6));
+
+const blockWithHole = difference(block, hole);
+```
+
+Neither input `Solid` is mutated; each call returns a new one. Combine more than two solids by chaining calls, e.g. `union(union(a, b), c)`.
+
+### Exporting to STL
+
+`toBinarySTL(solid)` returns a `Uint8Array` (the binary STL format); `toASCIISTL(solid, name?)` returns a `string` (the ASCII STL format). Neither writes to disk — this package stays framework-agnostic by handing back bytes/text and leaving file I/O to you:
+
+**Node.js:**
+
+```ts
+import { writeFileSync } from 'node:fs';
+import { cube, toBinarySTL } from '@richardmcquiston01/more-open-scad';
+
+writeFileSync('cube.stl', toBinarySTL(cube(20, { center: true })));
+```
+
+**Browser (trigger a download):**
+
+```ts
+import { cube, toBinarySTL } from '@richardmcquiston01/more-open-scad';
+
+const stl = toBinarySTL(cube(20, { center: true }));
+const url = URL.createObjectURL(new Blob([stl], { type: 'model/stl' }));
+
+const link = document.createElement('a');
+link.href = url;
+link.download = 'cube.stl';
+link.click();
+URL.revokeObjectURL(url);
+```
+
+Before exporting, `isManifold(solid)` checks whether a `Solid` is watertight (every edge shared by exactly two triangles wound in opposite directions) — useful as a sanity check that geometry is 3D-print-ready.
+
+## License
+
+[MIT](LICENSE)
+
+## Copyright
+
+(c) 2026 Richard McQuiston.
+
+## Buy Me a Coffee
+
+If this app, code, or repository has helped you or someone you know, please consider donating. I appreciate any help to offset the costs of development and/or AI Credits.
+
+[**Donate via Stripe**](https://donate.stripe.com/00w5kD3Gj1Xo9v7gVOcs800), or scan:
+
+[![Donate via Stripe](./donate.svg)](https://donate.stripe.com/00w5kD3Gj1Xo9v7gVOcs800)

package/dist/csg/boolean.d.ts

@@ -0,0 +1,22 @@
+import { Solid } from '../geometry/solid';
+/**
+ * The three boolean operations below are the classic BSP-CSG algorithm
+ * (Naylor/Thibault, as popularized by csg.js), expressed with this
+ * codebase's immutable `Bsp` functions in place of the original's
+ * in-place `Node` mutations. Each op builds a tree per input solid, uses
+ * `clipTo`/`invert` to cut away the region that should not survive, then
+ * merges what's left of one tree into the other with `build` and reads
+ * the result back out with `allPolygons`.
+ *
+ * `difference`/`intersect` reduce to the same shape as `union` by
+ * inverting one or both solids first — inside-out, "the part of A not in
+ * B" is "the union of (inside-out A) and B, inside-out" — which is why
+ * every op ends by inverting back if it inverted going in.
+ */
+/** The union of `a` and `b`: every point inside either solid. */
+export declare function union(a: Solid, b: Solid): Solid;
+/** `a` with the part it shares with `b` removed. */
+export declare function difference(a: Solid, b: Solid): Solid;
+/** The intersection of `a` and `b`: only the region inside both solids. */
+export declare function intersect(a: Solid, b: Solid): Solid;
+//# sourceMappingURL=boolean.d.ts.map

package/dist/csg/boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../src/csg/boolean.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAI1C;;;;;;;;;;;;;GAaG;AAEH,iEAAiE;AACjE,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAY/C;AAED,oDAAoD;AACpD,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAcpD;AAED,2EAA2E;AAC3E,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAanD"}

package/dist/csg/bsp-tree.d.ts

@@ -0,0 +1,70 @@
+import type { Plane as PlaneType } from '../geometry/plane';
+import type { Polygon as PolygonType } from '../geometry/polygon';
+/**
+ * A node in a BSP (binary space partitioning) tree, à la the classic
+ * BSP-CSG algorithm (Naylor/Thibault, as popularized by csg.js), adapted
+ * to this codebase's immutable value-type conventions: every function
+ * below returns a new tree rather than mutating an existing one.
+ *
+ * `polygons` holds every polygon found to be exactly coplanar with `plane`
+ * while building the tree — both those facing the same direction as
+ * `plane.normal` and those facing the opposite way (the classic algorithm
+ * keeps both in one list; nothing downstream needs them told apart).
+ * Everything else lives in `front`/`back`, which partition the remaining
+ * space on either side of `plane`. `null` (used for `front`/`back`, and as
+ * the whole-tree result of building from zero polygons) represents an
+ * empty subtree — "no polygons, no constraint on this side of the plane".
+ */
+export interface BspNode {
+    readonly plane: PlaneType;
+    readonly polygons: readonly PolygonType[];
+    readonly front: BspNode | null;
+    readonly back: BspNode | null;
+}
+/**
+ * Builds a BSP tree from `polygons`, optionally inserting them into an
+ * already-built `node` instead of starting fresh (the classic algorithm's
+ * `Node.build` serves both roles too: the first call establishes each
+ * node's splitting plane from its first polygon, and later calls partition
+ * new polygons through the existing planes, recursing into — or lazily
+ * creating — the `front`/`back` subtrees as needed).
+ *
+ * The splitting plane for a fresh node is `polygons[0]`'s own plane, so
+ * that polygon always lands in the returned node's `polygons` (as a
+ * `coplanarFront`, since a plane never disagrees with itself) rather than
+ * being recursed into a subtree.
+ */
+export declare function build(polygons: readonly PolygonType[], node?: BspNode | null): BspNode | null;
+/**
+ * Clips `polygons` against the solid volume `node` represents: every part
+ * of every polygon that lies in front of `node`'s planes survives (kept
+ * whole where possible, split where a polygon straddles a plane), and
+ * every part behind all of them — i.e. inside the volume — is discarded.
+ * A `null` node clips nothing away (there is no volume to be in front of),
+ * so every polygon survives unchanged.
+ *
+ * A polygon exactly coplanar with a node's plane is treated as `front` or
+ * `back` according to which way it's coplanar (matching `splitPolygon`'s
+ * `coplanarFront`/`coplanarBack` split), rather than being kept at that
+ * node the way `build` does — clipping only ever keeps or discards, it
+ * never needs to *store* a polygon at a particular node.
+ */
+export declare function clipPolygons(node: BspNode | null, polygons: readonly PolygonType[]): PolygonType[];
+/**
+ * Clips every polygon stored in `node` (at every level of the tree)
+ * against the solid volume `other` represents, returning the resulting
+ * tree. Used to remove the part of one solid that lies inside another,
+ * without discarding `node`'s own plane structure.
+ */
+export declare function clipTo(node: BspNode | null, other: BspNode | null): BspNode | null;
+/**
+ * Turns `node`'s solid inside-out: every plane and polygon is flipped
+ * (`Plane.flip`/`Polygon.flip`), and `front`/`back` are swapped, so the
+ * region the tree used to consider "inside" is now "outside" and vice
+ * versa. Boolean ops use this to re-express subtraction/intersection in
+ * terms of union (see `../csg/boolean.ts`).
+ */
+export declare function invert(node: BspNode | null): BspNode | null;
+/** Collects every polygon stored anywhere in `node`'s tree. */
+export declare function allPolygons(node: BspNode | null): PolygonType[];
+//# sourceMappingURL=bsp-tree.d.ts.map

package/dist/csg/bsp-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bsp-tree.d.ts","sourceRoot":"","sources":["../../src/csg/bsp-tree.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,IAAI,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE5D,OAAO,KAAK,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGlE;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;CAC/B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CACnB,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,IAAI,GAAE,OAAO,GAAG,IAAW,GAC1B,OAAO,GAAG,IAAI,CAqBhB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,OAAO,GAAG,IAAI,EACpB,QAAQ,EAAE,SAAS,WAAW,EAAE,GAC/B,WAAW,EAAE,CAiBf;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CACpB,IAAI,EAAE,OAAO,GAAG,IAAI,EACpB,KAAK,EAAE,OAAO,GAAG,IAAI,GACpB,OAAO,GAAG,IAAI,CAQhB;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,GAAG,OAAO,GAAG,IAAI,CAQ3D;AAED,+DAA+D;AAC/D,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,GAAG,WAAW,EAAE,CAO/D"}

package/dist/csg/split-polygon.d.ts

@@ -0,0 +1,62 @@
+import type { Plane as PlaneType } from '../geometry/plane';
+import type { Polygon as PolygonType } from '../geometry/polygon';
+/** Exactly on the plane, within `EPSILON`. */
+export declare const COPLANAR = 0;
+/** Strictly on the side the plane's normal points toward. */
+export declare const FRONT = 1;
+/** Strictly on the opposite side from the plane's normal. */
+export declare const BACK = 2;
+/** Both `Front` and `Back` — the polygon crosses the plane. */
+export declare const SPANNING = 3;
+/**
+ * How a vertex (or, bitwise-OR'd together, a whole polygon) sits relative
+ * to a splitting plane. `Spanning` is `Front | Back`: a polygon spans the
+ * plane exactly when it has at least one strictly-front and one
+ * strictly-back vertex.
+ */
+export type Classification = typeof COPLANAR | typeof FRONT | typeof BACK | typeof SPANNING;
+/**
+ * The result of splitting one polygon against one plane. A polygon lands
+ * in exactly one of the four buckets, except a `Spanning` polygon, which
+ * contributes one clipped piece to both `front` and `back` (or is dropped
+ * from a side entirely if clipping leaves fewer than 3 vertices on that
+ * side — see `splitPolygon`). Every field is an array purely for uniform,
+ * concatenation-friendly call sites (the BSP tree in later stages will
+ * accumulate many of these); for this library's always-convex `Polygon`,
+ * each field holds at most one polygon per call.
+ */
+export interface SplitResult {
+    /** Coplanar with the plane, facing the same direction as its normal. */
+    readonly coplanarFront: readonly PolygonType[];
+    /** Coplanar with the plane, facing the opposite direction. */
+    readonly coplanarBack: readonly PolygonType[];
+    /** Strictly in front of the plane (or the front piece of a split). */
+    readonly front: readonly PolygonType[];
+    /** Strictly behind the plane (or the back piece of a split). */
+    readonly back: readonly PolygonType[];
+}
+/**
+ * Classifies `polygon` against `plane` and splits it if it spans the
+ * plane, à la the classic BSP-CSG algorithm (Naylor/Thibault, as
+ * popularized by csg.js).
+ *
+ * Each vertex is classified `Front`/`Back`/`Coplanar` by its signed
+ * distance to the plane (within `EPSILON`); the polygon's overall
+ * classification is the bitwise OR of its vertices' classifications.
+ * `Coplanar` polygons are further split into `coplanarFront`/
+ * `coplanarBack` by comparing their own plane's normal to the splitting
+ * plane's normal. A `Spanning` polygon is walked edge by edge: each
+ * vertex joins the front chain (if not strictly `Back`), the back chain
+ * (if not strictly `Front`) — so a `Coplanar` vertex joins both, forming
+ * the shared boundary — and any edge that strictly crosses the plane
+ * contributes one new vertex, interpolated at the crossing point, to
+ * both chains. A resulting chain becomes an output polygon only if it
+ * has at least 3 vertices (matching `Polygon`'s minimum).
+ *
+ * Because interpolated points are affine combinations of two points on
+ * the source polygon's plane, they remain exactly on that same plane, so
+ * each output polygon's freshly-derived plane matches the source
+ * polygon's orientation.
+ */
+export declare function splitPolygon(plane: PlaneType, polygon: PolygonType): SplitResult;
+//# sourceMappingURL=split-polygon.d.ts.map

package/dist/csg/split-polygon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-polygon.d.ts","sourceRoot":"","sources":["../../src/csg/split-polygon.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,IAAI,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE5D,OAAO,KAAK,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAIlE,8CAA8C;AAC9C,eAAO,MAAM,QAAQ,IAAI,CAAC;AAC1B,6DAA6D;AAC7D,eAAO,MAAM,KAAK,IAAI,CAAC;AACvB,6DAA6D;AAC7D,eAAO,MAAM,IAAI,IAAI,CAAC;AACtB,+DAA+D;AAC/D,eAAO,MAAM,QAAQ,IAAI,CAAC;AAE1B;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GACtB,OAAO,QAAQ,GACf,OAAO,KAAK,GACZ,OAAO,IAAI,GACX,OAAO,QAAQ,CAAC;AAEpB;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IAC1B,wEAAwE;IACxE,QAAQ,CAAC,aAAa,EAAE,SAAS,WAAW,EAAE,CAAC;IAC/C,8DAA8D;IAC9D,QAAQ,CAAC,YAAY,EAAE,SAAS,WAAW,EAAE,CAAC;IAC9C,sEAAsE;IACtE,QAAQ,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,CAAC;IACvC,gEAAgE;IAChE,QAAQ,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,CAAC;CACvC;AASD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,WAAW,GAAG,WAAW,CAyDhF"}

package/dist/geometry/plane.d.ts

@@ -0,0 +1,31 @@
+import type { Vec3 as Vec3Type } from '../math/vec3';
+/**
+ * An infinite plane, represented in Hessian normal form: a unit `normal`
+ * and the offset `w` such that a point `p` lies on the plane when
+ * `dot(normal, p) === w`.
+ */
+export interface Plane {
+    readonly normal: Vec3Type;
+    readonly w: number;
+}
+/**
+ * Builds the plane through `a`, `b`, `c`. The three points must be ordered
+ * counter-clockwise when viewed from the side the resulting normal points
+ * toward (right-hand rule) — this matches the outward-facing winding
+ * convention used by primitives and STL export.
+ *
+ * If `a`, `b`, `c` are collinear or coincident, the cross product degenerates
+ * to the zero vector; per `Vec3.normalize`, this yields a plane with a zero
+ * normal rather than throwing or producing `NaN`.
+ */
+export declare function fromPoints(a: Vec3Type, b: Vec3Type, c: Vec3Type): Plane;
+/**
+ * The signed distance from `point` to `plane`: positive on the side the
+ * normal points toward, negative on the opposite side, zero on the plane.
+ */
+export declare function signedDistance(plane: Plane, point: Vec3Type): number;
+/** The plane with its normal (and therefore orientation) reversed. */
+export declare function flip(plane: Plane): Plane;
+/** Whether `a` and `b` represent the same plane within `tolerance`. */
+export declare function equals(a: Plane, b: Plane, tolerance?: number): boolean;
+//# sourceMappingURL=plane.d.ts.map

package/dist/geometry/plane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plane.d.ts","sourceRoot":"","sources":["../../src/geometry/plane.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAC;AAErD;;;;GAIG;AACH,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,KAAK,CAGvE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,GAAG,MAAM,CAEpE;AAED,sEAAsE;AACtE,wBAAgB,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAExC;AAED,uEAAuE;AACvE,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,SAAU,GAAG,OAAO,CAKvE"}

package/dist/geometry/polygon.d.ts

@@ -0,0 +1,24 @@
+import type { Plane as PlaneType } from './plane';
+import type { Vertex as VertexType } from './vertex';
+/**
+ * A planar, convex polygon with an arbitrary number of vertices (3+),
+ * wound counter-clockwise when viewed from the side its plane's normal
+ * points toward. Polygons are kept as-is (not pre-triangulated) so they
+ * can be split cleanly by the future BSP-tree CSG engine; triangulation
+ * happens only at STL-export time via `triangulate`.
+ */
+export interface Polygon {
+    readonly vertices: readonly VertexType[];
+    readonly plane: PlaneType;
+}
+/**
+ * Creates a `Polygon` from `vertices`, deriving its plane from the first
+ * three. Throws if fewer than 3 vertices are given.
+ */
+export declare function polygon(vertices: readonly VertexType[]): Polygon;
+/**
+ * The polygon with its winding order reversed and its plane/vertex
+ * normals flipped to match — turns an outward-facing polygon inside out.
+ */
+export declare function flip(p: Polygon): Polygon;
+//# sourceMappingURL=polygon.d.ts.map

package/dist/geometry/polygon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon.d.ts","sourceRoot":"","sources":["../../src/geometry/polygon.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,IAAI,SAAS,EAAE,MAAM,SAAS,CAAC;AAElD,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,UAAU,CAAC;AAErD;;;;;;GAMG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,GAAG,OAAO,CAQhE;AAED;;;GAGG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAKxC"}

package/dist/geometry/solid.d.ts

@@ -0,0 +1,41 @@
+import type { Mat4 as Mat4Type } from '../math/mat4';
+import type { Vec3 as Vec3Type } from '../math/vec3';
+import type { Polygon as PolygonType } from './polygon';
+/**
+ * A solid 3D shape: an immutable collection of polygons.
+ *
+ * `Solid` is the primary value type primitives (Stage 3) produce and
+ * transforms (Stage 4) operate on. Unlike the rest of the geometry kernel
+ * (which favors plain interfaces + free functions), `Solid` is a class so
+ * that transforms can be chained as instance methods, e.g.
+ * `cube(10).translate(vec3(5, 0, 0)).rotate(vec3(0, 0, Math.PI / 4))`.
+ * Every transform method returns a new `Solid`; none mutate `this`.
+ */
+export declare class Solid {
+    readonly polygons: readonly PolygonType[];
+    constructor(polygons: readonly PolygonType[]);
+    /** Translates every point of the solid by `offset`. */
+    translate(offset: Vec3Type): Solid;
+    /**
+     * Rotates the solid by Euler angles (in radians), applied in OpenSCAD's
+     * order: first around X, then Y, then Z.
+     */
+    rotate(radians: Vec3Type): Solid;
+    /** Rotates the solid by `radians` around `axis` (right-hand rule). */
+    rotateAxisAngle(axis: Vec3Type, radians: number): Solid;
+    /**
+     * Scales the solid. A single `number` scales all three axes uniformly;
+     * a `Vec3` scales each axis independently. A negative or zero factor on
+     * an odd number of axes flips handedness/degenerates the shape — winding
+     * is corrected automatically for the flip case, per `applyMatrix`.
+     */
+    scale(factor: number | Vec3Type): Solid;
+    /**
+     * Reflects the solid across the plane through the origin with normal
+     * `normal` (need not be pre-normalized).
+     */
+    mirror(normal: Vec3Type): Solid;
+    /** Applies an arbitrary 4x4 transform matrix to the solid. */
+    multmatrix(matrix: Mat4Type): Solid;
+}
+//# sourceMappingURL=solid.d.ts.map

package/dist/geometry/solid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solid.d.ts","sourceRoot":"","sources":["../../src/geometry/solid.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAC;AAErD,OAAO,KAAK,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAC;AAErD,OAAO,KAAK,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,WAAW,CAAC;AA4CxD;;;;;;;;;GASG;AACH,qBAAa,KAAK;IAChB,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;gBAE9B,QAAQ,EAAE,SAAS,WAAW,EAAE;IAI5C,uDAAuD;IACvD,SAAS,CAAC,MAAM,EAAE,QAAQ,GAAG,KAAK;IAIlC;;;OAGG;IACH,MAAM,CAAC,OAAO,EAAE,QAAQ,GAAG,KAAK;IAIhC,sEAAsE;IACtE,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK;IAIvD;;;;;OAKG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK;IAMvC;;;OAGG;IACH,MAAM,CAAC,MAAM,EAAE,QAAQ,GAAG,KAAK;IAI/B,8DAA8D;IAC9D,UAAU,CAAC,MAAM,EAAE,QAAQ,GAAG,KAAK;CAGpC"}

package/dist/geometry/triangulate.d.ts

@@ -0,0 +1,16 @@
+import type { Polygon } from './polygon';
+import type { Vertex } from './vertex';
+/** Three vertices forming a triangle, wound the same way as their source. */
+export type Triangle = readonly [Vertex, Vertex, Vertex];
+/**
+ * Fan-triangulates a convex `Polygon` into `n - 2` triangles (for an
+ * `n`-vertex polygon), all sharing the first vertex. Winding is preserved:
+ * each triangle keeps the same vertex order as the source polygon, so its
+ * implied normal matches the polygon's plane.
+ *
+ * Triangulation happens only at STL-export time — `Polygon`/`Solid` keep
+ * their original (non-triangulated) vertices so the future CSG engine can
+ * split them cleanly.
+ */
+export declare function triangulate(polygon: Polygon): Triangle[];
+//# sourceMappingURL=triangulate.d.ts.map

package/dist/geometry/triangulate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triangulate.d.ts","sourceRoot":"","sources":["../../src/geometry/triangulate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC,6EAA6E;AAC7E,MAAM,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAEzD;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,QAAQ,EAAE,CAQxD"}

package/dist/geometry/vertex.d.ts

@@ -0,0 +1,20 @@
+import type { Vec3 as Vec3Type } from '../math/vec3';
+/** A polygon vertex: a position plus its shading normal. */
+export interface Vertex {
+    readonly pos: Vec3Type;
+    readonly normal: Vec3Type;
+}
+/** Creates a `Vertex` from a position and normal. */
+export declare function vertex(pos: Vec3Type, normal: Vec3Type): Vertex;
+/**
+ * Linearly interpolates from `a` to `b` by `t` (0 = `a`, 1 = `b`),
+ * interpolating both position and normal. The interpolated normal is
+ * re-normalized, since a linear blend of two unit vectors is not itself
+ * unit length in general.
+ */
+export declare function lerp(a: Vertex, b: Vertex, t: number): Vertex;
+/** The vertex with its normal reversed, position unchanged. */
+export declare function flip(v: Vertex): Vertex;
+/** Whether `a` and `b` are equal within `tolerance` on both fields. */
+export declare function equals(a: Vertex, b: Vertex, tolerance?: number): boolean;
+//# sourceMappingURL=vertex.d.ts.map

package/dist/geometry/vertex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vertex.d.ts","sourceRoot":"","sources":["../../src/geometry/vertex.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAC;AAErD,4DAA4D;AAC5D,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;CAC3B;AAED,qDAAqD;AACrD,wBAAgB,MAAM,CAAC,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAG,MAAM,CAE9D;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAK5D;AAED,+DAA+D;AAC/D,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEtC;AAED,uEAAuE;AACvE,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAKxE"}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+export { cube } from './primitives/cube';
+export type { CubeOptions } from './primitives/cube';
+export { sphere } from './primitives/sphere';
+export type { SphereOptions } from './primitives/sphere';
+export { cylinder } from './primitives/cylinder';
+export type { CylinderOptions } from './primitives/cylinder';
+export { polyhedron } from './primitives/polyhedron';
+export { Solid } from './geometry/solid';
+export * as Vertex from './geometry/vertex';
+export * as Polygon from './geometry/polygon';
+export * as Plane from './geometry/plane';
+export { union, difference, intersect } from './csg/boolean';
+export * as Vec3 from './math/vec3';
+export * as Mat4 from './math/mat4';
+export { toBinarySTL } from './io/stl-binary';
+export { toASCIISTL } from './io/stl-ascii';
+export { isManifold } from './io/manifold-check';
+export { triangulateSolid } from './io/triangulate-solid';
+export type { StlTriangle } from './io/triangulate-solid';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACzC,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,YAAY,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAKrD,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAC5C,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAC;AAC9C,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAI1C,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAI7D,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;AACpC,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;AAGpC,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,YAAY,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC"}