@faicad/faijs 0.13.0

package/dist/vendored/brepjs/core/types.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Core type definitions for brepjs.
+ * Vec3 tuples replace the old Vector class.
+ * All operations on vectors are pure functions in vecOps.ts.
+ */
+/** 3D vector/point as a readonly tuple */
+export type Vec3 = readonly [number, number, number];
+/** 2D point as a readonly tuple */
+export type Vec2 = readonly [number, number];
+/**
+ * Flexible point input — accepts various formats for convenience.
+ * Use `toVec3()` to normalize to Vec3.
+ */
+export type PointInput = Vec3 | Vec2 | readonly [number, number, number] | readonly [number, number];
+/** Normalize any point input to Vec3 */
+export declare function toVec3(p: PointInput): Vec3;
+/** Normalize to Vec2 (drops z) */
+export declare function toVec2(p: PointInput): Vec2;
+/** Direction shorthand — a named axis (`'X'`, `'Y'`, `'Z'`) or an explicit {@link Vec3}. */
+export type Direction = Vec3 | 'X' | 'Y' | 'Z';
+/**
+ * Resolve a {@link Direction} shorthand to a unit {@link Vec3}.
+ *
+ * @throws If the string is not a recognised axis name.
+ */
+export declare function resolveDirection(d: Direction): Vec3;
+/** A row of a 4x4 matrix. */
+type Row4 = [number, number, number, number];
+/** 4x4 affine transformation matrix in row-major order. Bottom row must be [0,0,0,1]. */
+export type Matrix4x4 = [Row4, Row4, Row4, Row4];
+/** Structured matrix input: 3x3 linear part + translation vector. */
+export interface MatrixTransform {
+    /** 3x3 linear part in row-major order: [r00, r01, r02, r10, r11, r12, r20, r21, r22]. */
+    readonly linear: readonly [
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number
+    ];
+    /** Translation vector [tx, ty, tz]. */
+    readonly translation: Vec3;
+}
+/** Input accepted by `applyMatrix`: either a raw 4x4 array or a structured object. */
+export type MatrixInput = Matrix4x4 | MatrixTransform;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/vendored/brepjs/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/vendored/brepjs/core/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,0CAA0C;AAC1C,MAAM,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAErD,mCAAmC;AACnC,MAAM,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE7C;;;GAGG;AACH,MAAM,MAAM,UAAU,GACpB,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE9E,wCAAwC;AACxC,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,IAAI,CAG1C;AAED,kCAAkC;AAClC,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,IAAI,CAE1C;AAED,4FAA4F;AAC5F,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAQ/C;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI,CAOnD;AAMD,6BAA6B;AAC7B,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAE7C,yFAAyF;AACzF,MAAM,MAAM,SAAS,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AAEjD,qEAAqE;AACrE,MAAM,WAAW,eAAe;IAC9B,yFAAyF;IACzF,QAAQ,CAAC,MAAM,EAAE,SAAS;QACxB,MAAM;QACN,MAAM;QACN,MAAM;QACN,MAAM;QACN,MAAM;QACN,MAAM;QACN,MAAM;QACN,MAAM;QACN,MAAM;KACP,CAAC;IACF,uCAAuC;IACvC,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC;CAC5B;AAED,sFAAsF;AACtF,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,eAAe,CAAC"}

package/dist/vendored/brepjs/core/types.js

@@ -0,0 +1,35 @@
+/**
+ * Core type definitions for brepjs.
+ * Vec3 tuples replace the old Vector class.
+ * All operations on vectors are pure functions in vecOps.ts.
+ */
+/** Normalize any point input to Vec3 */
+export function toVec3(p) {
+    if (p.length === 2)
+        return [p[0], p[1], 0];
+    return [p[0], p[1], p[2]];
+}
+/** Normalize to Vec2 (drops z) */
+export function toVec2(p) {
+    return [p[0], p[1]];
+}
+const DIRECTIONS = {
+    X: [1, 0, 0],
+    Y: [0, 1, 0],
+    Z: [0, 0, 1],
+};
+/**
+ * Resolve a {@link Direction} shorthand to a unit {@link Vec3}.
+ *
+ * @throws If the string is not a recognised axis name.
+ */
+export function resolveDirection(d) {
+    if (typeof d === 'string') {
+        const dir = DIRECTIONS[d];
+        if (!dir)
+            throw new Error(`Unknown direction: ${d}`);
+        return dir;
+    }
+    return d;
+}
+//# sourceMappingURL=types.js.map

package/dist/vendored/brepjs/core/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/vendored/brepjs/core/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAeH,wCAAwC;AACxC,MAAM,UAAU,MAAM,CAAC,CAAa;IAClC,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3C,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC5B,CAAC;AAED,kCAAkC;AAClC,MAAM,UAAU,MAAM,CAAC,CAAa;IAClC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACtB,CAAC;AAKD,MAAM,UAAU,GAAyB;IACvC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACZ,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACZ,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;CACb,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,CAAY;IAC3C,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;QAC1B,MAAM,GAAG,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;QAC1B,IAAI,CAAC,GAAG;YAAE,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,EAAE,CAAC,CAAC;QACrD,OAAO,GAAG,CAAC;IACb,CAAC;IACD,OAAO,CAAC,CAAC;AACX,CAAC","sourcesContent":["/**\n * Core type definitions for brepjs.\n * Vec3 tuples replace the old Vector class.\n * All operations on vectors are pure functions in vecOps.ts.\n */\n\n/** 3D vector/point as a readonly tuple */\nexport type Vec3 = readonly [number, number, number];\n\n/** 2D point as a readonly tuple */\nexport type Vec2 = readonly [number, number];\n\n/**\n * Flexible point input — accepts various formats for convenience.\n * Use `toVec3()` to normalize to Vec3.\n */\nexport type PointInput =\n  Vec3 | Vec2 | readonly [number, number, number] | readonly [number, number];\n\n/** Normalize any point input to Vec3 */\nexport function toVec3(p: PointInput): Vec3 {\n  if (p.length === 2) return [p[0], p[1], 0];\n  return [p[0], p[1], p[2]];\n}\n\n/** Normalize to Vec2 (drops z) */\nexport function toVec2(p: PointInput): Vec2 {\n  return [p[0], p[1]];\n}\n\n/** Direction shorthand — a named axis (`'X'`, `'Y'`, `'Z'`) or an explicit {@link Vec3}. */\nexport type Direction = Vec3 | 'X' | 'Y' | 'Z';\n\nconst DIRECTIONS: Record<string, Vec3> = {\n  X: [1, 0, 0],\n  Y: [0, 1, 0],\n  Z: [0, 0, 1],\n};\n\n/**\n * Resolve a {@link Direction} shorthand to a unit {@link Vec3}.\n *\n * @throws If the string is not a recognised axis name.\n */\nexport function resolveDirection(d: Direction): Vec3 {\n  if (typeof d === 'string') {\n    const dir = DIRECTIONS[d];\n    if (!dir) throw new Error(`Unknown direction: ${d}`);\n    return dir;\n  }\n  return d;\n}\n\n// ---------------------------------------------------------------------------\n// Matrix types for applyMatrix (OpenSCAD multmatrix equivalent)\n// ---------------------------------------------------------------------------\n\n/** A row of a 4x4 matrix. */\ntype Row4 = [number, number, number, number];\n\n/** 4x4 affine transformation matrix in row-major order. Bottom row must be [0,0,0,1]. */\nexport type Matrix4x4 = [Row4, Row4, Row4, Row4];\n\n/** Structured matrix input: 3x3 linear part + translation vector. */\nexport interface MatrixTransform {\n  /** 3x3 linear part in row-major order: [r00, r01, r02, r10, r11, r12, r20, r21, r22]. */\n  readonly linear: readonly [\n    number,\n    number,\n    number,\n    number,\n    number,\n    number,\n    number,\n    number,\n    number,\n  ];\n  /** Translation vector [tx, ty, tz]. */\n  readonly translation: Vec3;\n}\n\n/** Input accepted by `applyMatrix`: either a raw 4x4 array or a structured object. */\nexport type MatrixInput = Matrix4x4 | MatrixTransform;\n"]}

package/dist/vendored/brepjs/core/validityTypes.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Topological validity phantom brands (ADR-0005).
+ *
+ * Phantom types that encode topological invariants as type-level brands.
+ * Smart constructors prove validity at runtime; type guards narrow in-place.
+ *
+ * - ClosedWire<D> — wire forms a closed loop
+ * - OrientedFace<D> — face has consistent normal orientation
+ * - ManifoldShell — shell is watertight
+ * - ValidSolid — solid passes BRepCheck validation
+ */
+import type { Dimension } from './dimensionTypes.js';
+import type { Wire, Face, Shell, Solid } from './shapeTypes.js';
+import type { Result } from './result.js';
+/** Phantom brand: wire forms a closed loop. */
+declare const __closed: unique symbol;
+/** Phantom brand: face has consistent normal orientation. */
+declare const __oriented: unique symbol;
+/** Phantom brand: shell is manifold (watertight, no dangling faces). */
+declare const __manifold: unique symbol;
+/** Phantom brand: solid passes BRepCheck validation. */
+declare const __valid: unique symbol;
+/**
+ * A wire proven to form a closed loop.
+ * The only way to obtain a `ClosedWire` is through smart constructors
+ * (`closedWire()`, `rectangleWire()`, etc.) or type guards (`isClosedWire()`).
+ * Assignable to `Wire<D>` — a subtype, not a separate type.
+ */
+export type ClosedWire<D extends Dimension = '3D'> = Wire<D> & {
+    readonly [__closed]: true;
+};
+/**
+ * A face with proven consistent normal orientation.
+ * Obtained via `orientedFace()` or `isOrientedFace()`.
+ * Assignable to `Face<D>`.
+ */
+export type OrientedFace<D extends Dimension = '3D'> = Face<D> & {
+    readonly [__oriented]: true;
+};
+/**
+ * A shell proven to be manifold (watertight, no dangling faces).
+ * Obtained via `manifoldShell()` or `isManifoldShell()`.
+ * Assignable to `Shell`.
+ */
+export type ManifoldShell = Shell & {
+    readonly [__manifold]: true;
+};
+/**
+ * A solid proven to pass BRepCheck validation.
+ * Obtained via `validSolid()` or `isValidSolid()`.
+ * Assignable to `Solid`.
+ */
+export type ValidSolid = Solid & {
+    readonly [__valid]: true;
+};
+/**
+ * Type guard — check if a wire is closed (forms a loop).
+ * Uses the kernel's `curveIsClosed` to verify at runtime.
+ */
+export declare function isClosedWire<D extends Dimension>(wire: Wire<D>): wire is ClosedWire<D>;
+/**
+ * Type guard — check if a face is valid and thus safe to use in operations.
+ *
+ * Uses kernel validity (BRepCheck_Analyzer) which verifies geometric and
+ * topological correctness. Faces produced by kernel operations (makeFace,
+ * extrude, revolve, boolean ops) are oriented by construction. For faces
+ * from STEP/IGES imports or external sources, validity does not guarantee
+ * consistent normal orientation — use with caution or re-orient first.
+ */
+export declare function isOrientedFace<D extends Dimension>(face: Face<D>): face is OrientedFace<D>;
+/**
+ * Type guard — check if a shell is manifold (watertight, no dangling faces).
+ * Checks kernel validity, then attempts `solidFromShell` — if the shell
+ * can form a valid solid, it is manifold by definition.
+ *
+ * The temporary solid created for the proof is disposed immediately to avoid
+ * WASM memory leaks.
+ */
+export declare function isManifoldShell(shell: Shell): shell is ManifoldShell;
+/**
+ * Type guard — check if a solid passes BRepCheck validation.
+ */
+export declare function isValidSolid(solid: Solid): solid is ValidSolid;
+/**
+ * Prove that a wire is closed, returning a branded `ClosedWire` on success.
+ * This is the primary smart constructor for `ClosedWire`.
+ *
+ * @example
+ * ```ts
+ * const w = wire([e1, e2, e3]);
+ * const closed = closedWire(unwrap(w));
+ * if (isOk(closed)) {
+ *   const f = face(closed.value); // ClosedWire accepted
+ * }
+ * ```
+ */
+export declare function closedWire<D extends Dimension>(wire: Wire<D>): Result<ClosedWire<D>, string>;
+/**
+ * Prove that a face is oriented, returning a branded `OrientedFace` on success.
+ */
+export declare function orientedFace<D extends Dimension>(face: Face<D>): Result<OrientedFace<D>, string>;
+/**
+ * Prove that a shell is manifold, returning a branded `ManifoldShell` on success.
+ */
+export declare function manifoldShell(shell: Shell): Result<ManifoldShell, string>;
+/**
+ * Prove that a solid is valid, returning a branded `ValidSolid` on success.
+ */
+export declare function validSolid(solid: Solid): Result<ValidSolid, string>;
+/** Phantom brand: underlying surface / edges lie in a geometric plane. */
+declare const __planar: unique symbol;
+/**
+ * A face whose underlying surface is a geometric plane.
+ * Obtained via `planarFace()` or `isPlanarFace()`.
+ * Assignable to `Face<D>`.
+ */
+export type PlanarFace<D extends Dimension = '3D'> = Face<D> & {
+    readonly [__planar]: true;
+};
+/**
+ * A wire whose edges all lie in a common plane.
+ * Obtained via `planarWire()` or `isPlanarWire()`.
+ * Assignable to `Wire<D>`.
+ */
+export type PlanarWire<D extends Dimension = '3D'> = Wire<D> & {
+    readonly [__planar]: true;
+};
+/** Type guard — check if a face is planar (underlying surface is a plane). */
+export declare function isPlanarFace<D extends Dimension>(face: Face<D>): face is PlanarFace<D>;
+/**
+ * Type guard — check if a wire is planar (all edges lie in a common plane).
+ * Strategy: try planar-only face construction first (fast path on OCCT — throws
+ * for non-planar wires). If that succeeds, verify the surface type. If it
+ * fails, fall back to general mode and check whether the resulting surface is
+ * a plane. This handles kernel-specific differences in the planar flag.
+ */
+export declare function isPlanarWire<D extends Dimension>(wire: Wire<D>): wire is PlanarWire<D>;
+/** Prove that a face is planar, returning a branded `PlanarFace` on success. */
+export declare function planarFace<D extends Dimension>(face: Face<D>): Result<PlanarFace<D>, string>;
+/** Prove that a wire is planar, returning a branded `PlanarWire` on success. */
+export declare function planarWire<D extends Dimension>(wire: Wire<D>): Result<PlanarWire<D>, string>;
+export {};
+//# sourceMappingURL=validityTypes.d.ts.map

package/dist/vendored/brepjs/core/validityTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validityTypes.d.ts","sourceRoot":"","sources":["../../../../src/vendored/brepjs/core/validityTypes.ts"],"names":[],"mappings":"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"}

package/dist/vendored/brepjs/core/validityTypes.js

@@ -0,0 +1,174 @@
+/**
+ * Topological validity phantom brands (ADR-0005).
+ *
+ * Phantom types that encode topological invariants as type-level brands.
+ * Smart constructors prove validity at runtime; type guards narrow in-place.
+ *
+ * - ClosedWire<D> — wire forms a closed loop
+ * - OrientedFace<D> — face has consistent normal orientation
+ * - ManifoldShell — shell is watertight
+ * - ValidSolid — solid passes BRepCheck validation
+ */
+import { ok, err } from './result.js';
+import { getKernel } from '../kernel/index.js';
+// ---------------------------------------------------------------------------
+// Type guards (runtime checks via kernel)
+// ---------------------------------------------------------------------------
+/**
+ * Type guard — check if a wire is closed (forms a loop).
+ * Uses the kernel's `curveIsClosed` to verify at runtime.
+ */
+export function isClosedWire(wire) {
+    return getKernel().curveIsClosed(wire.wrapped);
+}
+/**
+ * Type guard — check if a face is valid and thus safe to use in operations.
+ *
+ * Uses kernel validity (BRepCheck_Analyzer) which verifies geometric and
+ * topological correctness. Faces produced by kernel operations (makeFace,
+ * extrude, revolve, boolean ops) are oriented by construction. For faces
+ * from STEP/IGES imports or external sources, validity does not guarantee
+ * consistent normal orientation — use with caution or re-orient first.
+ */
+export function isOrientedFace(face) {
+    return getKernel().isValid(face.wrapped);
+}
+/**
+ * Type guard — check if a shell is manifold (watertight, no dangling faces).
+ * Checks kernel validity, then attempts `solidFromShell` — if the shell
+ * can form a valid solid, it is manifold by definition.
+ *
+ * The temporary solid created for the proof is disposed immediately to avoid
+ * WASM memory leaks.
+ */
+export function isManifoldShell(shell) {
+    const kernel = getKernel();
+    if (!kernel.isValid(shell.wrapped))
+        return false;
+    // Use strict validation for the manifold proof — relaxed validation
+    // may accept open shells sewn into a "solid" that aren't truly watertight.
+    const validate = kernel.isValidStrict?.bind(kernel) ?? kernel.isValid.bind(kernel);
+    // A manifold shell can be converted to a solid — try it as a proof
+    try {
+        const solid = kernel.solidFromShell(shell.wrapped);
+        const valid = validate(solid);
+        // Dispose the temporary solid to prevent WASM memory leaks
+        try {
+            kernel.dispose(solid);
+        }
+        catch {
+            /* best-effort cleanup */
+        }
+        return valid;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Type guard — check if a solid passes BRepCheck validation.
+ */
+export function isValidSolid(solid) {
+    return getKernel().isValid(solid.wrapped);
+}
+// ---------------------------------------------------------------------------
+// Smart constructors — return Result<T, string> for consistency with core Result type
+// ---------------------------------------------------------------------------
+/**
+ * Prove that a wire is closed, returning a branded `ClosedWire` on success.
+ * This is the primary smart constructor for `ClosedWire`.
+ *
+ * @example
+ * ```ts
+ * const w = wire([e1, e2, e3]);
+ * const closed = closedWire(unwrap(w));
+ * if (isOk(closed)) {
+ *   const f = face(closed.value); // ClosedWire accepted
+ * }
+ * ```
+ */
+export function closedWire(wire) {
+    if (isClosedWire(wire))
+        return ok(wire);
+    return err('Wire is not closed: start and end points do not coincide');
+}
+/**
+ * Prove that a face is oriented, returning a branded `OrientedFace` on success.
+ */
+export function orientedFace(face) {
+    if (isOrientedFace(face))
+        return ok(face);
+    return err('Face orientation is inconsistent or face is invalid');
+}
+/**
+ * Prove that a shell is manifold, returning a branded `ManifoldShell` on success.
+ */
+export function manifoldShell(shell) {
+    if (isManifoldShell(shell))
+        return ok(shell);
+    return err('Shell is not manifold: has free edges or is invalid');
+}
+/**
+ * Prove that a solid is valid, returning a branded `ValidSolid` on success.
+ */
+export function validSolid(solid) {
+    if (isValidSolid(solid))
+        return ok(solid);
+    return err('Solid failed BRepCheck validation');
+}
+// ---------------------------------------------------------------------------
+// Geometric validity type guards
+// ---------------------------------------------------------------------------
+/** Type guard — check if a face is planar (underlying surface is a plane). */
+export function isPlanarFace(face) {
+    return getKernel().surfaceType(face.wrapped) === 'plane';
+}
+/**
+ * Type guard — check if a wire is planar (all edges lie in a common plane).
+ * Strategy: try planar-only face construction first (fast path on OCCT — throws
+ * for non-planar wires). If that succeeds, verify the surface type. If it
+ * fails, fall back to general mode and check whether the resulting surface is
+ * a plane. This handles kernel-specific differences in the planar flag.
+ */
+export function isPlanarWire(wire) {
+    const kernel = getKernel();
+    // Helper: build face, check surface type, dispose
+    const checkFace = (onlyPlane) => {
+        try {
+            const tempFace = kernel.makeFace(wire.wrapped, onlyPlane);
+            const stype = kernel.surfaceType(tempFace);
+            try {
+                kernel.dispose(tempFace);
+            }
+            catch {
+                /* best-effort cleanup */
+            }
+            return stype === 'plane';
+        }
+        catch {
+            return false;
+        }
+    };
+    // Planar-only mode: OCCT throws for non-planar, brepkit may not
+    const planarResult = checkFace(true);
+    if (planarResult)
+        return true;
+    // General mode fallback: build any surface and inspect its type
+    return checkFace(false);
+}
+// ---------------------------------------------------------------------------
+// Geometric validity smart constructors
+// ---------------------------------------------------------------------------
+/** Prove that a face is planar, returning a branded `PlanarFace` on success. */
+export function planarFace(face) {
+    if (isPlanarFace(face))
+        return ok(face);
+    return err('Face is not planar: underlying surface is not a geometric plane');
+}
+/** Prove that a wire is planar, returning a branded `PlanarWire` on success. */
+export function planarWire(wire) {
+    if (isPlanarWire(wire))
+        return ok(wire);
+    return err('Wire is not planar: edges do not lie in a common plane');
+}
+//# sourceMappingURL=validityTypes.js.map

package/dist/vendored/brepjs/core/validityTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validityTypes.js","sourceRoot":"","sources":["../../../../src/vendored/brepjs/core/validityTypes.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Topological validity phantom brands (ADR-0005).\n *\n * Phantom types that encode topological invariants as type-level brands.\n * Smart constructors prove validity at runtime; type guards narrow in-place.\n *\n * - ClosedWire<D> — wire forms a closed loop\n * - OrientedFace<D> — face has consistent normal orientation\n * - ManifoldShell — shell is watertight\n * - ValidSolid — solid passes BRepCheck validation\n */\n\n// Type-only imports — erased at runtime, no circular dependency\nimport type { Dimension } from './dimensionTypes.js';\nimport type { Wire, Face, Shell, Solid } from './shapeTypes.js';\nimport type { Result } from './result.js';\n\nimport { ok, err } from './result.js';\nimport { getKernel } from '../kernel/index.js';\n\n// ---------------------------------------------------------------------------\n// Phantom brand symbols\n// ---------------------------------------------------------------------------\n\n/** Phantom brand: wire forms a closed loop. */\ndeclare const __closed: unique symbol;\n/** Phantom brand: face has consistent normal orientation. */\ndeclare const __oriented: unique symbol;\n/** Phantom brand: shell is manifold (watertight, no dangling faces). */\ndeclare const __manifold: unique symbol;\n/** Phantom brand: solid passes BRepCheck validation. */\ndeclare const __valid: unique symbol;\n\n// ---------------------------------------------------------------------------\n// Topological validity types\n// ---------------------------------------------------------------------------\n\n/**\n * A wire proven to form a closed loop.\n * The only way to obtain a `ClosedWire` is through smart constructors\n * (`closedWire()`, `rectangleWire()`, etc.) or type guards (`isClosedWire()`).\n * Assignable to `Wire<D>` — a subtype, not a separate type.\n */\nexport type ClosedWire<D extends Dimension = '3D'> = Wire<D> & { readonly [__closed]: true };\n\n/**\n * A face with proven consistent normal orientation.\n * Obtained via `orientedFace()` or `isOrientedFace()`.\n * Assignable to `Face<D>`.\n */\nexport type OrientedFace<D extends Dimension = '3D'> = Face<D> & { readonly [__oriented]: true };\n\n/**\n * A shell proven to be manifold (watertight, no dangling faces).\n * Obtained via `manifoldShell()` or `isManifoldShell()`.\n * Assignable to `Shell`.\n */\nexport type ManifoldShell = Shell & { readonly [__manifold]: true };\n\n/**\n * A solid proven to pass BRepCheck validation.\n * Obtained via `validSolid()` or `isValidSolid()`.\n * Assignable to `Solid`.\n */\nexport type ValidSolid = Solid & { readonly [__valid]: true };\n\n// ---------------------------------------------------------------------------\n// Type guards (runtime checks via kernel)\n// ---------------------------------------------------------------------------\n\n/**\n * Type guard — check if a wire is closed (forms a loop).\n * Uses the kernel's `curveIsClosed` to verify at runtime.\n */\nexport function isClosedWire<D extends Dimension>(wire: Wire<D>): wire is ClosedWire<D> {\n  return getKernel().curveIsClosed(wire.wrapped);\n}\n\n/**\n * Type guard — check if a face is valid and thus safe to use in operations.\n *\n * Uses kernel validity (BRepCheck_Analyzer) which verifies geometric and\n * topological correctness. Faces produced by kernel operations (makeFace,\n * extrude, revolve, boolean ops) are oriented by construction. For faces\n * from STEP/IGES imports or external sources, validity does not guarantee\n * consistent normal orientation — use with caution or re-orient first.\n */\nexport function isOrientedFace<D extends Dimension>(face: Face<D>): face is OrientedFace<D> {\n  return getKernel().isValid(face.wrapped);\n}\n\n/**\n * Type guard — check if a shell is manifold (watertight, no dangling faces).\n * Checks kernel validity, then attempts `solidFromShell` — if the shell\n * can form a valid solid, it is manifold by definition.\n *\n * The temporary solid created for the proof is disposed immediately to avoid\n * WASM memory leaks.\n */\nexport function isManifoldShell(shell: Shell): shell is ManifoldShell {\n  const kernel = getKernel();\n  if (!kernel.isValid(shell.wrapped)) return false;\n  // Use strict validation for the manifold proof — relaxed validation\n  // may accept open shells sewn into a \"solid\" that aren't truly watertight.\n  const validate = kernel.isValidStrict?.bind(kernel) ?? kernel.isValid.bind(kernel);\n  // A manifold shell can be converted to a solid — try it as a proof\n  try {\n    const solid = kernel.solidFromShell(shell.wrapped);\n    const valid = validate(solid);\n    // Dispose the temporary solid to prevent WASM memory leaks\n    try {\n      kernel.dispose(solid);\n    } catch {\n      /* best-effort cleanup */\n    }\n    return valid;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Type guard — check if a solid passes BRepCheck validation.\n */\nexport function isValidSolid(solid: Solid): solid is ValidSolid {\n  return getKernel().isValid(solid.wrapped);\n}\n\n// ---------------------------------------------------------------------------\n// Smart constructors — return Result<T, string> for consistency with core Result type\n// ---------------------------------------------------------------------------\n\n/**\n * Prove that a wire is closed, returning a branded `ClosedWire` on success.\n * This is the primary smart constructor for `ClosedWire`.\n *\n * @example\n * ```ts\n * const w = wire([e1, e2, e3]);\n * const closed = closedWire(unwrap(w));\n * if (isOk(closed)) {\n *   const f = face(closed.value); // ClosedWire accepted\n * }\n * ```\n */\nexport function closedWire<D extends Dimension>(wire: Wire<D>): Result<ClosedWire<D>, string> {\n  if (isClosedWire(wire)) return ok(wire);\n  return err('Wire is not closed: start and end points do not coincide');\n}\n\n/**\n * Prove that a face is oriented, returning a branded `OrientedFace` on success.\n */\nexport function orientedFace<D extends Dimension>(face: Face<D>): Result<OrientedFace<D>, string> {\n  if (isOrientedFace(face)) return ok(face);\n  return err('Face orientation is inconsistent or face is invalid');\n}\n\n/**\n * Prove that a shell is manifold, returning a branded `ManifoldShell` on success.\n */\nexport function manifoldShell(shell: Shell): Result<ManifoldShell, string> {\n  if (isManifoldShell(shell)) return ok(shell);\n  return err('Shell is not manifold: has free edges or is invalid');\n}\n\n/**\n * Prove that a solid is valid, returning a branded `ValidSolid` on success.\n */\nexport function validSolid(solid: Solid): Result<ValidSolid, string> {\n  if (isValidSolid(solid)) return ok(solid);\n  return err('Solid failed BRepCheck validation');\n}\n\n// ---------------------------------------------------------------------------\n// Geometric validity brands (ADR-0011)\n// ---------------------------------------------------------------------------\n\n/** Phantom brand: underlying surface / edges lie in a geometric plane. */\ndeclare const __planar: unique symbol;\n\n/**\n * A face whose underlying surface is a geometric plane.\n * Obtained via `planarFace()` or `isPlanarFace()`.\n * Assignable to `Face<D>`.\n */\nexport type PlanarFace<D extends Dimension = '3D'> = Face<D> & { readonly [__planar]: true };\n\n/**\n * A wire whose edges all lie in a common plane.\n * Obtained via `planarWire()` or `isPlanarWire()`.\n * Assignable to `Wire<D>`.\n */\nexport type PlanarWire<D extends Dimension = '3D'> = Wire<D> & { readonly [__planar]: true };\n\n// ---------------------------------------------------------------------------\n// Geometric validity type guards\n// ---------------------------------------------------------------------------\n\n/** Type guard — check if a face is planar (underlying surface is a plane). */\nexport function isPlanarFace<D extends Dimension>(face: Face<D>): face is PlanarFace<D> {\n  return getKernel().surfaceType(face.wrapped) === 'plane';\n}\n\n/**\n * Type guard — check if a wire is planar (all edges lie in a common plane).\n * Strategy: try planar-only face construction first (fast path on OCCT — throws\n * for non-planar wires). If that succeeds, verify the surface type. If it\n * fails, fall back to general mode and check whether the resulting surface is\n * a plane. This handles kernel-specific differences in the planar flag.\n */\nexport function isPlanarWire<D extends Dimension>(wire: Wire<D>): wire is PlanarWire<D> {\n  const kernel = getKernel();\n  // Helper: build face, check surface type, dispose\n  const checkFace = (onlyPlane: boolean): boolean => {\n    try {\n      const tempFace = kernel.makeFace(wire.wrapped, onlyPlane);\n      const stype = kernel.surfaceType(tempFace);\n      try {\n        kernel.dispose(tempFace);\n      } catch {\n        /* best-effort cleanup */\n      }\n      return stype === 'plane';\n    } catch {\n      return false;\n    }\n  };\n  // Planar-only mode: OCCT throws for non-planar, brepkit may not\n  const planarResult = checkFace(true);\n  if (planarResult) return true;\n  // General mode fallback: build any surface and inspect its type\n  return checkFace(false);\n}\n\n// ---------------------------------------------------------------------------\n// Geometric validity smart constructors\n// ---------------------------------------------------------------------------\n\n/** Prove that a face is planar, returning a branded `PlanarFace` on success. */\nexport function planarFace<D extends Dimension>(face: Face<D>): Result<PlanarFace<D>, string> {\n  if (isPlanarFace(face)) return ok(face);\n  return err('Face is not planar: underlying surface is not a geometric plane');\n}\n\n/** Prove that a wire is planar, returning a branded `PlanarWire` on success. */\nexport function planarWire<D extends Dimension>(wire: Wire<D>): Result<PlanarWire<D>, string> {\n  if (isPlanarWire(wire)) return ok(wire);\n  return err('Wire is not planar: edges do not lie in a common plane');\n}\n"]}

package/dist/vendored/brepjs/core/vecOps.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Pure vector operations on Vec3 tuples.
+ * Replaces the old Vector class methods.
+ * Zero dependencies — pure math functions.
+ */
+import type { Vec3 } from './types.js';
+/** Add two 3D vectors component-wise. */
+export declare function vecAdd(a: Vec3, b: Vec3): Vec3;
+/** Subtract vector `b` from vector `a` component-wise. */
+export declare function vecSub(a: Vec3, b: Vec3): Vec3;
+/** Multiply each component of a 3D vector by a scalar. */
+export declare function vecScale(v: Vec3, s: number): Vec3;
+/** Negate all components of a 3D vector. */
+export declare function vecNegate(v: Vec3): Vec3;
+/** Compute the dot product of two 3D vectors. */
+export declare function vecDot(a: Vec3, b: Vec3): number;
+/** Compute the cross product of two 3D vectors. */
+export declare function vecCross(a: Vec3, b: Vec3): Vec3;
+/** Compute the Euclidean length of a 3D vector. */
+export declare function vecLength(v: Vec3): number;
+/** Compute the squared length of a 3D vector (avoids a sqrt). */
+export declare function vecLengthSq(v: Vec3): number;
+/** Compute the Euclidean distance between two 3D points. */
+export declare function vecDistance(a: Vec3, b: Vec3): number;
+/** Return a unit-length vector in the same direction, or `[0,0,0]` for near-zero input. */
+export declare function vecNormalize(v: Vec3): Vec3;
+/**
+ * Test whether two 3D vectors are approximately equal.
+ *
+ * @param tolerance - Per-component absolute tolerance.
+ * @default tolerance `1e-5`
+ */
+export declare function vecEquals(a: Vec3, b: Vec3, tolerance?: number): boolean;
+/**
+ * Test whether a 3D vector is approximately zero-length.
+ *
+ * @param tolerance - Length threshold below which the vector is considered zero.
+ * @default tolerance `1e-10`
+ */
+export declare function vecIsZero(v: Vec3, tolerance?: number): boolean;
+/**
+ * Compute the unsigned angle between two 3D vectors in **radians**.
+ *
+ * @returns Angle in `[0, PI]`, or `0` if either vector is zero-length.
+ */
+export declare function vecAngle(a: Vec3, b: Vec3): number;
+/** Project vector onto plane defined by its normal */
+export declare function vecProjectToPlane(v: Vec3, planeOrigin: Vec3, planeNormal: Vec3): Vec3;
+/** Rotate vector around an axis by angle (radians) */
+export declare function vecRotate(v: Vec3, axis: Vec3, angleRad: number): Vec3;
+/** Format a Vec3 as a human-readable string rounded to 3 decimal places. */
+export declare function vecRepr(v: Vec3): string;
+//# sourceMappingURL=vecOps.d.ts.map

package/dist/vendored/brepjs/core/vecOps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vecOps.d.ts","sourceRoot":"","sources":["../../../../src/vendored/brepjs/core/vecOps.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAMvC,yCAAyC;AACzC,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAE7C;AAED,0DAA0D;AAC1D,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAE7C;AAED,0DAA0D;AAC1D,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAEjD;AAED,4CAA4C;AAC5C,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAEvC;AAMD,iDAAiD;AACjD,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM,CAE/C;AAED,mDAAmD;AACnD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAE/C;AAMD,mDAAmD;AACnD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAEzC;AAED,iEAAiE;AACjE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAE3C;AAED,4DAA4D;AAC5D,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM,CAEpD;AAMD,2FAA2F;AAC3F,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAI1C;AAMD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,SAAO,GAAG,OAAO,CAMrE;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,SAAQ,GAAG,OAAO,CAE7D;AAMD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM,CAOjD;AAED,sDAAsD;AACtD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,GAAG,IAAI,CAMrF;AAED,sDAAsD;AACtD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAYrE;AAQD,4EAA4E;AAC5E,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAEvC"}

package/dist/vendored/brepjs/core/vecOps.js

@@ -0,0 +1,131 @@
+/**
+ * Pure vector operations on Vec3 tuples.
+ * Replaces the old Vector class methods.
+ * Zero dependencies — pure math functions.
+ */
+// ---------------------------------------------------------------------------
+// Arithmetic
+// ---------------------------------------------------------------------------
+/** Add two 3D vectors component-wise. */
+export function vecAdd(a, b) {
+    return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
+/** Subtract vector `b` from vector `a` component-wise. */
+export function vecSub(a, b) {
+    return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+/** Multiply each component of a 3D vector by a scalar. */
+export function vecScale(v, s) {
+    return [v[0] * s, v[1] * s, v[2] * s];
+}
+/** Negate all components of a 3D vector. */
+export function vecNegate(v) {
+    return [-v[0], -v[1], -v[2]];
+}
+// ---------------------------------------------------------------------------
+// Products
+// ---------------------------------------------------------------------------
+/** Compute the dot product of two 3D vectors. */
+export function vecDot(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+/** Compute the cross product of two 3D vectors. */
+export function vecCross(a, b) {
+    return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+// ---------------------------------------------------------------------------
+// Length / distance
+// ---------------------------------------------------------------------------
+/** Compute the Euclidean length of a 3D vector. */
+export function vecLength(v) {
+    return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+}
+/** Compute the squared length of a 3D vector (avoids a sqrt). */
+export function vecLengthSq(v) {
+    return v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
+}
+/** Compute the Euclidean distance between two 3D points. */
+export function vecDistance(a, b) {
+    return vecLength(vecSub(a, b));
+}
+// ---------------------------------------------------------------------------
+// Normalization
+// ---------------------------------------------------------------------------
+/** Return a unit-length vector in the same direction, or `[0,0,0]` for near-zero input. */
+export function vecNormalize(v) {
+    const len = vecLength(v);
+    if (len < 1e-10)
+        return [0, 0, 0];
+    return [v[0] / len, v[1] / len, v[2] / len];
+}
+// ---------------------------------------------------------------------------
+// Comparison
+// ---------------------------------------------------------------------------
+/**
+ * Test whether two 3D vectors are approximately equal.
+ *
+ * @param tolerance - Per-component absolute tolerance.
+ * @default tolerance `1e-5`
+ */
+export function vecEquals(a, b, tolerance = 1e-5) {
+    return (Math.abs(a[0] - b[0]) < tolerance &&
+        Math.abs(a[1] - b[1]) < tolerance &&
+        Math.abs(a[2] - b[2]) < tolerance);
+}
+/**
+ * Test whether a 3D vector is approximately zero-length.
+ *
+ * @param tolerance - Length threshold below which the vector is considered zero.
+ * @default tolerance `1e-10`
+ */
+export function vecIsZero(v, tolerance = 1e-10) {
+    return vecLengthSq(v) < tolerance * tolerance;
+}
+// ---------------------------------------------------------------------------
+// Geometry
+// ---------------------------------------------------------------------------
+/**
+ * Compute the unsigned angle between two 3D vectors in **radians**.
+ *
+ * @returns Angle in `[0, PI]`, or `0` if either vector is zero-length.
+ */
+export function vecAngle(a, b) {
+    const dot = vecDot(a, b);
+    const lenA = vecLength(a);
+    const lenB = vecLength(b);
+    if (lenA < 1e-10 || lenB < 1e-10)
+        return 0;
+    const cosAngle = Math.max(-1, Math.min(1, dot / (lenA * lenB)));
+    return Math.acos(cosAngle);
+}
+/** Project vector onto plane defined by its normal */
+export function vecProjectToPlane(v, planeOrigin, planeNormal) {
+    const relative = vecSub(v, planeOrigin);
+    const normalLen = vecLengthSq(planeNormal);
+    if (normalLen < 1e-20)
+        return v;
+    const projection = vecScale(planeNormal, vecDot(relative, planeNormal) / normalLen);
+    return vecSub(v, projection);
+}
+/** Rotate vector around an axis by angle (radians) */
+export function vecRotate(v, axis, angleRad) {
+    const n = vecNormalize(axis);
+    const cos = Math.cos(angleRad);
+    const sin = Math.sin(angleRad);
+    const dot = vecDot(v, n);
+    const cross = vecCross(n, v);
+    return [
+        v[0] * cos + cross[0] * sin + n[0] * dot * (1 - cos),
+        v[1] * cos + cross[1] * sin + n[1] * dot * (1 - cos),
+        v[2] * cos + cross[2] * sin + n[2] * dot * (1 - cos),
+    ];
+}
+// ---------------------------------------------------------------------------
+// Formatting
+// ---------------------------------------------------------------------------
+const round3 = (v) => Math.round(v * 1000) / 1000;
+/** Format a Vec3 as a human-readable string rounded to 3 decimal places. */
+export function vecRepr(v) {
+    return `x: ${round3(v[0])}, y: ${round3(v[1])}, z: ${round3(v[2])}`;
+}
+//# sourceMappingURL=vecOps.js.map