@faicad/faijs 0.13.0

package/dist/vendored/brepjs/topology/meshCache.d.ts

@@ -0,0 +1,68 @@
+/**
+ * LRU cache for mesh results.
+ *
+ * Uses WeakMap keyed by the actual kernel shape object to avoid hash collisions.
+ * HashCode() can return identical values for different shapes, which would cause
+ * the cache to return incorrect mesh data. WeakMap ensures identity-based lookup.
+ *
+ * The tolerance parameters are encoded as a string key in an inner Map.
+ */
+import type { ShapeMesh, EdgeMesh } from './meshFns.js';
+type KernelShape = any;
+/**
+ * Build a parameter key for the inner cache map (excludes shape identity).
+ * Shape identity is handled by the WeakMap outer layer.
+ */
+export declare function buildMeshCacheKey(tolerance: number, angularTolerance: number, skipNormals: boolean, includeUVs?: boolean): string;
+/**
+ * Build a parameter key for edge mesh cache lookup (excludes shape identity).
+ * Shape identity is handled by the WeakMap outer layer.
+ */
+export declare function buildEdgeMeshCacheKey(tolerance: number, angularTolerance: number): string;
+/**
+ * Get a cached mesh for a shape with the given parameters.
+ * @param shape The kernel shape object (not the wrapper)
+ * @param key The parameter key from buildMeshCacheKey
+ */
+export declare function getMeshForShape(shape: KernelShape, key: string): ShapeMesh | undefined;
+/**
+ * Store a mesh in the cache.
+ * @param shape The kernel shape object (not the wrapper)
+ * @param key The parameter key from buildMeshCacheKey
+ * @param value The mesh data
+ */
+export declare function setMeshForShape(shape: KernelShape, key: string, value: ShapeMesh): void;
+/**
+ * Get a cached edge mesh for a shape with the given parameters.
+ * @param shape The kernel shape object (not the wrapper)
+ * @param key The parameter key from buildEdgeMeshCacheKey
+ */
+export declare function getEdgeMeshForShape(shape: KernelShape, key: string): EdgeMesh | undefined;
+/**
+ * Store an edge mesh in the cache.
+ * @param shape The kernel shape object (not the wrapper)
+ * @param key The parameter key from buildEdgeMeshCacheKey
+ * @param value The edge mesh data
+ */
+export declare function setEdgeMeshForShape(shape: KernelShape, key: string, value: EdgeMesh): void;
+/**
+ * Clear all mesh caches. Call this after modifying shapes to avoid stale results.
+ */
+export declare function clearMeshCache(): void;
+/**
+ * An isolated mesh cache context for per-viewer or per-worker use.
+ *
+ * Provides the same get/set interface as the global cache but with
+ * independent state, so multiple viewers can cache independently.
+ */
+export interface MeshCacheContext {
+    getMesh(shape: KernelShape, key: string): ShapeMesh | undefined;
+    setMesh(shape: KernelShape, key: string, value: ShapeMesh): void;
+    getEdgeMesh(shape: KernelShape, key: string): EdgeMesh | undefined;
+    setEdgeMesh(shape: KernelShape, key: string, value: EdgeMesh): void;
+    clear(): void;
+}
+/** Create an isolated mesh cache that doesn't share state with the global cache. */
+export declare function createMeshCache(): MeshCacheContext;
+export {};
+//# sourceMappingURL=meshCache.d.ts.map

package/dist/vendored/brepjs/topology/meshCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meshCache.d.ts","sourceRoot":"","sources":["../../../../src/vendored/brepjs/topology/meshCache.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAGxD,KAAK,WAAW,GAAG,GAAG,CAAC;AAEvB;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,gBAAgB,EAAE,MAAM,EACxB,WAAW,EAAE,OAAO,EACpB,UAAU,UAAQ,GACjB,MAAM,CAER;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAEzF;AAMD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAItF;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CAOvF;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAIzF;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI,CAO1F;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAGrC;AAMD;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAAC;IAChE,OAAO,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IACjE,WAAW,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;IACnE,WAAW,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAC;IACpE,KAAK,IAAI,IAAI,CAAC;CACf;AAED,oFAAoF;AACpF,wBAAgB,eAAe,IAAI,gBAAgB,CAgClD"}

package/dist/vendored/brepjs/topology/meshCache.js

@@ -0,0 +1,117 @@
+/**
+ * LRU cache for mesh results.
+ *
+ * Uses WeakMap keyed by the actual kernel shape object to avoid hash collisions.
+ * HashCode() can return identical values for different shapes, which would cause
+ * the cache to return incorrect mesh data. WeakMap ensures identity-based lookup.
+ *
+ * The tolerance parameters are encoded as a string key in an inner Map.
+ */
+/**
+ * Build a parameter key for the inner cache map (excludes shape identity).
+ * Shape identity is handled by the WeakMap outer layer.
+ */
+export function buildMeshCacheKey(tolerance, angularTolerance, skipNormals, includeUVs = false) {
+    return `${tolerance}:${angularTolerance}:${skipNormals}:${includeUVs}`;
+}
+/**
+ * Build a parameter key for edge mesh cache lookup (excludes shape identity).
+ * Shape identity is handled by the WeakMap outer layer.
+ */
+export function buildEdgeMeshCacheKey(tolerance, angularTolerance) {
+    return `edge:${tolerance}:${angularTolerance}`;
+}
+// WeakMap keyed by kernel shape object -> Map of paramKey -> mesh
+let meshCache = new WeakMap();
+let edgeMeshCache = new WeakMap();
+/**
+ * Get a cached mesh for a shape with the given parameters.
+ * @param shape The kernel shape object (not the wrapper)
+ * @param key The parameter key from buildMeshCacheKey
+ */
+export function getMeshForShape(shape, key) {
+    const shapeCache = meshCache.get(shape);
+    if (!shapeCache)
+        return undefined;
+    return shapeCache.get(key);
+}
+/**
+ * Store a mesh in the cache.
+ * @param shape The kernel shape object (not the wrapper)
+ * @param key The parameter key from buildMeshCacheKey
+ * @param value The mesh data
+ */
+export function setMeshForShape(shape, key, value) {
+    let shapeCache = meshCache.get(shape);
+    if (!shapeCache) {
+        shapeCache = new Map();
+        meshCache.set(shape, shapeCache);
+    }
+    shapeCache.set(key, value);
+}
+/**
+ * Get a cached edge mesh for a shape with the given parameters.
+ * @param shape The kernel shape object (not the wrapper)
+ * @param key The parameter key from buildEdgeMeshCacheKey
+ */
+export function getEdgeMeshForShape(shape, key) {
+    const shapeCache = edgeMeshCache.get(shape);
+    if (!shapeCache)
+        return undefined;
+    return shapeCache.get(key);
+}
+/**
+ * Store an edge mesh in the cache.
+ * @param shape The kernel shape object (not the wrapper)
+ * @param key The parameter key from buildEdgeMeshCacheKey
+ * @param value The edge mesh data
+ */
+export function setEdgeMeshForShape(shape, key, value) {
+    let shapeCache = edgeMeshCache.get(shape);
+    if (!shapeCache) {
+        shapeCache = new Map();
+        edgeMeshCache.set(shape, shapeCache);
+    }
+    shapeCache.set(key, value);
+}
+/**
+ * Clear all mesh caches. Call this after modifying shapes to avoid stale results.
+ */
+export function clearMeshCache() {
+    meshCache = new WeakMap();
+    edgeMeshCache = new WeakMap();
+}
+/** Create an isolated mesh cache that doesn't share state with the global cache. */
+export function createMeshCache() {
+    let shapeMap = new WeakMap();
+    let edgeMap = new WeakMap();
+    return {
+        getMesh(shape, key) {
+            return shapeMap.get(shape)?.get(key);
+        },
+        setMesh(shape, key, value) {
+            let inner = shapeMap.get(shape);
+            if (!inner) {
+                inner = new Map();
+                shapeMap.set(shape, inner);
+            }
+            inner.set(key, value);
+        },
+        getEdgeMesh(shape, key) {
+            return edgeMap.get(shape)?.get(key);
+        },
+        setEdgeMesh(shape, key, value) {
+            let inner = edgeMap.get(shape);
+            if (!inner) {
+                inner = new Map();
+                edgeMap.set(shape, inner);
+            }
+            inner.set(key, value);
+        },
+        clear() {
+            shapeMap = new WeakMap();
+            edgeMap = new WeakMap();
+        },
+    };
+}
+//# sourceMappingURL=meshCache.js.map

package/dist/vendored/brepjs/topology/meshCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"meshCache.js","sourceRoot":"","sources":["../../../../src/vendored/brepjs/topology/meshCache.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * LRU cache for mesh results.\n *\n * Uses WeakMap keyed by the actual kernel shape object to avoid hash collisions.\n * HashCode() can return identical values for different shapes, which would cause\n * the cache to return incorrect mesh data. WeakMap ensures identity-based lookup.\n *\n * The tolerance parameters are encoded as a string key in an inner Map.\n */\n\nimport type { ShapeMesh, EdgeMesh } from './meshFns.js';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any -- kernel shape type\ntype KernelShape = any;\n\n/**\n * Build a parameter key for the inner cache map (excludes shape identity).\n * Shape identity is handled by the WeakMap outer layer.\n */\nexport function buildMeshCacheKey(\n  tolerance: number,\n  angularTolerance: number,\n  skipNormals: boolean,\n  includeUVs = false\n): string {\n  return `${tolerance}:${angularTolerance}:${skipNormals}:${includeUVs}`;\n}\n\n/**\n * Build a parameter key for edge mesh cache lookup (excludes shape identity).\n * Shape identity is handled by the WeakMap outer layer.\n */\nexport function buildEdgeMeshCacheKey(tolerance: number, angularTolerance: number): string {\n  return `edge:${tolerance}:${angularTolerance}`;\n}\n\n// WeakMap keyed by kernel shape object -> Map of paramKey -> mesh\nlet meshCache: WeakMap<KernelShape, Map<string, ShapeMesh>> = new WeakMap();\nlet edgeMeshCache: WeakMap<KernelShape, Map<string, EdgeMesh>> = new WeakMap();\n\n/**\n * Get a cached mesh for a shape with the given parameters.\n * @param shape The kernel shape object (not the wrapper)\n * @param key The parameter key from buildMeshCacheKey\n */\nexport function getMeshForShape(shape: KernelShape, key: string): ShapeMesh | undefined {\n  const shapeCache = meshCache.get(shape);\n  if (!shapeCache) return undefined;\n  return shapeCache.get(key);\n}\n\n/**\n * Store a mesh in the cache.\n * @param shape The kernel shape object (not the wrapper)\n * @param key The parameter key from buildMeshCacheKey\n * @param value The mesh data\n */\nexport function setMeshForShape(shape: KernelShape, key: string, value: ShapeMesh): void {\n  let shapeCache = meshCache.get(shape);\n  if (!shapeCache) {\n    shapeCache = new Map();\n    meshCache.set(shape, shapeCache);\n  }\n  shapeCache.set(key, value);\n}\n\n/**\n * Get a cached edge mesh for a shape with the given parameters.\n * @param shape The kernel shape object (not the wrapper)\n * @param key The parameter key from buildEdgeMeshCacheKey\n */\nexport function getEdgeMeshForShape(shape: KernelShape, key: string): EdgeMesh | undefined {\n  const shapeCache = edgeMeshCache.get(shape);\n  if (!shapeCache) return undefined;\n  return shapeCache.get(key);\n}\n\n/**\n * Store an edge mesh in the cache.\n * @param shape The kernel shape object (not the wrapper)\n * @param key The parameter key from buildEdgeMeshCacheKey\n * @param value The edge mesh data\n */\nexport function setEdgeMeshForShape(shape: KernelShape, key: string, value: EdgeMesh): void {\n  let shapeCache = edgeMeshCache.get(shape);\n  if (!shapeCache) {\n    shapeCache = new Map();\n    edgeMeshCache.set(shape, shapeCache);\n  }\n  shapeCache.set(key, value);\n}\n\n/**\n * Clear all mesh caches. Call this after modifying shapes to avoid stale results.\n */\nexport function clearMeshCache(): void {\n  meshCache = new WeakMap();\n  edgeMeshCache = new WeakMap();\n}\n\n// ---------------------------------------------------------------------------\n// Isolated mesh cache context\n// ---------------------------------------------------------------------------\n\n/**\n * An isolated mesh cache context for per-viewer or per-worker use.\n *\n * Provides the same get/set interface as the global cache but with\n * independent state, so multiple viewers can cache independently.\n */\nexport interface MeshCacheContext {\n  getMesh(shape: KernelShape, key: string): ShapeMesh | undefined;\n  setMesh(shape: KernelShape, key: string, value: ShapeMesh): void;\n  getEdgeMesh(shape: KernelShape, key: string): EdgeMesh | undefined;\n  setEdgeMesh(shape: KernelShape, key: string, value: EdgeMesh): void;\n  clear(): void;\n}\n\n/** Create an isolated mesh cache that doesn't share state with the global cache. */\nexport function createMeshCache(): MeshCacheContext {\n  let shapeMap: WeakMap<KernelShape, Map<string, ShapeMesh>> = new WeakMap();\n  let edgeMap: WeakMap<KernelShape, Map<string, EdgeMesh>> = new WeakMap();\n\n  return {\n    getMesh(shape: KernelShape, key: string): ShapeMesh | undefined {\n      return shapeMap.get(shape)?.get(key);\n    },\n    setMesh(shape: KernelShape, key: string, value: ShapeMesh): void {\n      let inner = shapeMap.get(shape);\n      if (!inner) {\n        inner = new Map();\n        shapeMap.set(shape, inner);\n      }\n      inner.set(key, value);\n    },\n    getEdgeMesh(shape: KernelShape, key: string): EdgeMesh | undefined {\n      return edgeMap.get(shape)?.get(key);\n    },\n    setEdgeMesh(shape: KernelShape, key: string, value: EdgeMesh): void {\n      let inner = edgeMap.get(shape);\n      if (!inner) {\n        inner = new Map();\n        edgeMap.set(shape, inner);\n      }\n      inner.set(key, value);\n    },\n    clear(): void {\n      shapeMap = new WeakMap();\n      edgeMap = new WeakMap();\n    },\n  };\n}\n"]}

package/dist/vendored/brepjs/topology/meshFns.d.ts

@@ -0,0 +1,179 @@
+/**
+ * Meshing and export functions — functional replacements for Shape mesh/export methods.
+ */
+import type { AnyShape, Dimension } from '../core/shapeTypes.js';
+import { type Result } from '../core/result.js';
+/** Triangle mesh data extracted from a shape, ready for GPU rendering. */
+export interface ShapeMesh {
+    /** Triangle vertex indices (3 per triangle). */
+    triangles: Uint32Array;
+    /** Flat array of vertex positions (x,y,z interleaved). */
+    vertices: Float32Array;
+    /** Flat array of vertex normals (x,y,z interleaved). */
+    normals: Float32Array;
+    /** Flat array of UV coordinates (u,v interleaved), empty if not requested. */
+    uvs: Float32Array;
+    /** Per-face triangle index ranges for multi-material rendering. */
+    faceGroups: {
+        start: number;
+        count: number;
+        faceId: number;
+        origin: number;
+    }[];
+}
+/** Line segment mesh data for edge rendering (wireframe). */
+export interface EdgeMesh {
+    /** Flat array of line vertex positions (x,y,z interleaved, 2 vertices per segment). */
+    lines: Float32Array;
+    /** Per-edge line segment index ranges for highlighting individual edges. */
+    edgeGroups: {
+        start: number;
+        count: number;
+        edgeId: number;
+    }[];
+}
+/** Shared options for meshing operations. */
+export interface MeshOptions {
+    /** Linear deflection tolerance. Smaller = finer mesh. Defaults to the active
+     *  quality level, scaled with the shape's bounding-box diagonal beyond 10
+     *  model units so default meshes stay scale-invariant. */
+    tolerance?: number;
+    /** Angular deflection tolerance in radians. Smaller = finer mesh on curved surfaces. Defaults to the active quality level. */
+    angularTolerance?: number;
+    /** Abort signal to cancel mesh generation between face iterations. */
+    signal?: AbortSignal;
+}
+export declare function scaleDefaultTolerance(base: number, shape: AnyShape<Dimension>): number;
+/**
+ * Mesh a shape as a set of triangles for rendering.
+ *
+ * Results are cached by default (keyed by shape identity + tolerance parameters).
+ * Delegates to the kernel adapter's bulk C++ mesh extraction for performance.
+ *
+ * @returns A ShapeMesh containing typed arrays ready for GPU upload.
+ * @see toBufferGeometryData — convert to Three.js BufferGeometry format
+ */
+export declare function mesh(shape: AnyShape<Dimension>, opts?: MeshOptions & {
+    skipNormals?: boolean;
+    includeUVs?: boolean;
+    cache?: boolean;
+}): ShapeMesh;
+/**
+ * Mesh the edges of a shape as line segments for wireframe rendering.
+ *
+ * Results are cached by default (keyed by shape identity + tolerance parameters).
+ *
+ * @returns An EdgeMesh containing line vertex positions and per-edge groups.
+ * @see toLineGeometryData — convert to Three.js LineSegments format
+ */
+export declare function meshEdges(shape: AnyShape<Dimension>, opts?: MeshOptions & {
+    cache?: boolean;
+}): EdgeMesh;
+export declare function exportSTEP(shape: AnyShape<Dimension>): Result<Blob>;
+/**
+ * Export a shape as an STL file Blob.
+ *
+ * @returns Ok with a Blob (MIME type `application/sla`), or Err on failure.
+ */
+export declare function exportSTL(shape: AnyShape<Dimension>, opts?: MeshOptions & {
+    binary?: boolean;
+}): Result<Blob>;
+/**
+ * Export a shape as an IGES file Blob.
+ *
+ * @returns Ok with a Blob (MIME type `application/iges`), or Err on failure.
+ */
+export declare function exportIGES(shape: AnyShape<Dimension>): Result<Blob>;
+export interface MultiLODMesh {
+    readonly coarse: ShapeMesh;
+    readonly fine: ShapeMesh;
+}
+/**
+ * Produce coarse (preview) + fine (export) meshes for a shape.
+ *
+ * Coarse mesh uses high tolerance for fast preview rendering.
+ * Fine mesh uses low tolerance for export quality.
+ */
+export declare function meshMultiLOD(shape: AnyShape<Dimension>, options?: {
+    readonly coarseTolerance?: number | undefined;
+    readonly fineTolerance?: number | undefined;
+    readonly angularTolerance?: number | undefined;
+}): MultiLODMesh;
+/** One level of a multi-resolution mesh: the geometry plus the tolerances it was meshed at. */
+export interface LODMesh {
+    /** Linear deflection (model units) used for this level. */
+    readonly tolerance: number;
+    /** Angular deflection (radians) used for this level. */
+    readonly angularTolerance: number;
+    /** The meshed geometry at this level. */
+    readonly mesh: ShapeMesh;
+}
+/** Options for {@link meshLODs}. */
+export interface MeshLODsOptions {
+    /** Number of levels, coarsest → finest (>= 1). Default 3. Ignored when `tolerances` is given. */
+    readonly levels?: number;
+    /**
+     * The finest level's linear tolerance as a fraction of the shape's bounding-box
+     * diagonal, so detail is scale-invariant across part sizes. Default 0.0005
+     * (0.05% of the diagonal). Ignored when `tolerances` is given.
+     */
+    readonly relativeTolerance?: number;
+    /**
+     * Geometric ratio between successive levels: each coarser level's tolerance is
+     * `spacing`× the next finer one. Default 4. Ignored when `tolerances` is given.
+     */
+    readonly spacing?: number;
+    /** Explicit absolute linear tolerances (one per level). Overrides `levels`/`relativeTolerance`/`spacing`; sorted coarse → fine. */
+    readonly tolerances?: readonly number[];
+    /** The finest level's angular deflection (radians). Defaults to the active quality level; coarser levels scale up with the tolerance ratio (capped at 1 rad). */
+    readonly angularTolerance?: number;
+    /** Abort signal forwarded to each level's mesh call. */
+    readonly signal?: AbortSignal;
+    /** Whether to use the mesh cache per level. Default true. */
+    readonly cache?: boolean;
+}
+/**
+ * Mesh a shape at several levels of detail, coarse → fine.
+ *
+ * Tolerances are **scale-relative** by default: the finest level is a fraction
+ * (`relativeTolerance`) of the shape's bounding-box diagonal and each coarser
+ * level steps up by `spacing`×, so the same call gives sensible detail whether
+ * the part is millimetres or metres. Pass `tolerances` for absolute control.
+ * Each level goes through {@link mesh}, so levels are cached individually.
+ *
+ * @returns LOD levels ordered coarsest → finest.
+ * @see toLODGeometryLevels — convert to THREE.LOD geometry data
+ */
+export declare function meshLODs(shape: AnyShape<Dimension>, options?: MeshLODsOptions): LODMesh[];
+/**
+ * Mesh one LOD level. Defaults to the synchronous main-thread {@link mesh}; pass
+ * an async implementation (e.g. one that serializes the shape with `toBREP` and
+ * meshes it on a worker) to refine finer levels off the main thread.
+ */
+export type MeshLevelFn = (shape: AnyShape<Dimension>, tolerance: number, angularTolerance: number) => ShapeMesh | Promise<ShapeMesh>;
+/** Options for {@link meshLODsProgressive}. */
+export interface MeshLODsProgressiveOptions extends MeshLODsOptions {
+    /**
+     * Called as each level finishes, coarsest first, so a viewer can show the
+     * coarse preview immediately and swap in finer meshes as they arrive.
+     */
+    readonly onLevel?: (level: LODMesh, index: number) => void;
+    /** How to mesh one level. Defaults to the synchronous main-thread {@link mesh}. */
+    readonly meshLevel?: MeshLevelFn;
+}
+/**
+ * Mesh a shape at several levels of detail, delivering them over time coarse →
+ * fine instead of all at once — so a viewer paints the coarse preview first and
+ * refines as finer levels land.
+ *
+ * The coarsest level is meshed first and reported via `onLevel`; control then
+ * yields to the event loop before each finer (heavier) level so the UI stays
+ * responsive. Each level is meshed synchronously on the calling thread by
+ * default; pass `meshLevel` to offload finer levels (e.g. to a worker). An
+ * aborted `signal` stops refinement and resolves with the levels produced so far.
+ *
+ * @returns the delivered LOD levels, coarsest → finest.
+ * @see meshLODs — the synchronous, all-at-once variant
+ */
+export declare function meshLODsProgressive(shape: AnyShape<Dimension>, options?: MeshLODsProgressiveOptions): Promise<LODMesh[]>;
+//# sourceMappingURL=meshFns.d.ts.map

package/dist/vendored/brepjs/topology/meshFns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meshFns.d.ts","sourceRoot":"","sources":["../../../../src/vendored/brepjs/topology/meshFns.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,mBAAmB,CAAC;AAkBzD,0EAA0E;AAC1E,MAAM,WAAW,SAAS;IACxB,gDAAgD;IAChD,SAAS,EAAE,WAAW,CAAC;IACvB,0DAA0D;IAC1D,QAAQ,EAAE,YAAY,CAAC;IACvB,wDAAwD;IACxD,OAAO,EAAE,YAAY,CAAC;IACtB,8EAA8E;IAC9E,GAAG,EAAE,YAAY,CAAC;IAClB,mEAAmE;IACnE,UAAU,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAChF;AAED,6DAA6D;AAC7D,MAAM,WAAW,QAAQ;IACvB,uFAAuF;IACvF,KAAK,EAAE,YAAY,CAAC;IACpB,4EAA4E;IAC5E,UAAU,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAChE;AAED,6CAA6C;AAC7C,MAAM,WAAW,WAAW;IAC1B;;8DAE0D;IAC1D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,8HAA8H;IAC9H,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,sEAAsE;IACtE,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAUD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,MAAM,CAYtF;AAMD;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAClB,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,EAC1B,IAAI,GAAE,WAAW,GAAG;IAAE,WAAW,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GACxF,SAAS,CAkDX;AAMD;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,EAC1B,IAAI,GAAE,WAAW,GAAG;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3C,QAAQ,CAgCV;AAiGD,wBAAgB,UAAU,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CASnE;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,EAC1B,IAAI,GAAE,WAAW,GAAG;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GAC5C,MAAM,CAAC,IAAI,CAAC,CAoBd;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAOnE;AAMD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,EAC1B,OAAO,CAAC,EAAE;IACR,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9C,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5C,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAChD,GACA,YAAY,CASd;AAMD,+FAA+F;AAC/F,MAAM,WAAW,OAAO;IACtB,2DAA2D;IAC3D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,wDAAwD;IACxD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;CAC1B;AAED,oCAAoC;AACpC,MAAM,WAAW,eAAe;IAC9B,iGAAiG;IACjG,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,mIAAmI;IACnI,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,iKAAiK;IACjK,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,wDAAwD;IACxD,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AAkCD;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,GAAE,eAAoB,GAAG,OAAO,EAAE,CAe7F;AAMD;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,CACxB,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,EAC1B,SAAS,EAAE,MAAM,EACjB,gBAAgB,EAAE,MAAM,KACrB,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;AAEpC,+CAA+C;AAC/C,MAAM,WAAW,0BAA2B,SAAQ,eAAe;IACjE;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3D,mFAAmF;IACnF,QAAQ,CAAC,SAAS,CAAC,EAAE,WAAW,CAAC;CAClC;AAQD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,EAC1B,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,OAAO,EAAE,CAAC,CAuCpB"}