cadorange 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LAU 
+
+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/dist/index-DceghC4N.d.ts

@@ -0,0 +1,305 @@
+//#region src/geom/index.d.ts
+/**
+ * Geometric value types and pure vector math.
+ *
+ * Ported from build123d's geometry semantics (Apache-2.0): `Axis` with
+ * `isParallel` (angle tolerance), vector ops as pure functions over `Vec3`.
+ */
+type Vec3 = readonly [number, number, number];
+declare const v: {
+  add: (a: Vec3, b: Vec3) => Vec3;
+  sub: (a: Vec3, b: Vec3) => Vec3;
+  scale: (a: Vec3, k: number) => Vec3;
+  dot: (a: Vec3, b: Vec3) => number;
+  cross: (a: Vec3, b: Vec3) => Vec3;
+  length: (a: Vec3) => number;
+  distance: (a: Vec3, b: Vec3) => number;
+  normalize: (a: Vec3) => Vec3;
+  /** Componentwise closeness. */
+  eq: (a: Vec3, b: Vec3, tol?: number) => boolean;
+};
+/**
+ * An oriented axis (origin + direction), build123d-style. Used by selectors:
+ * `part.edges().filterBy(Axis.Z)` keeps edges parallel to Z.
+ */
+declare class Axis {
+  readonly origin: Vec3;
+  static readonly X: Axis;
+  static readonly Y: Axis;
+  static readonly Z: Axis;
+  readonly direction: Vec3;
+  constructor(origin: Vec3, direction: Vec3);
+  /**
+   * True when this axis and `other` point the same or opposite way, within an
+   * angle of `toleranceDegrees` (build123d: `Axis.is_parallel`, default 1e-2°).
+   */
+  isParallel(other: Axis, toleranceDegrees?: number): boolean;
+}
+type AxisName = "X" | "Y" | "Z";
+declare function axisByName(name: AxisName): Axis;
+/** Placement: origin plus optional local axis directions. */
+interface Location {
+  origin: Vec3;
+  /** Local Z direction; defaults to the global +Z. */
+  zDir?: Vec3;
+  /** Local X direction; defaults to the global +X. */
+  xDir?: Vec3;
+}
+/** Short alias used by the kernel interface. */
+type Loc = Location;
+interface Axis3 {
+  origin: Vec3;
+  dir: Vec3;
+}
+interface Plane {
+  origin: Vec3;
+  normal: Vec3;
+  xDir: Vec3;
+}
+/** A plane from just origin + normal (xDir derived deterministically). */
+declare function planeFrom(origin: Vec3, normal: Vec3): Plane;
+interface BBox {
+  min: Vec3;
+  max: Vec3;
+}
+interface Mesh {
+  positions: Float32Array;
+  normals?: Float32Array;
+  indices: Uint32Array;
+}
+//#endregion
+//#region src/kernel/types.d.ts
+/** Opaque handle to a shape owned by the Kernel (WASM memory). Never construct one. */
+interface ShapeHandle {
+  readonly id: number;
+}
+/** Surface geometry kinds, mirroring OCCT analytic surfaces (build123d `GeomType`). */
+type SurfaceKind = "plane" | "cylinder" | "cone" | "sphere" | "torus" | "bspline-surface" | "other";
+/** Curve geometry kinds (build123d `GeomType`). */
+type CurveKind = "line" | "circle" | "ellipse" | "bspline" | "other";
+/**
+ * Metadata for one face, normalized from the kernel's interrogation output.
+ * `index` is the kernel's 1-based selection index (fillet/draft/shell targets).
+ *
+ * `center` is a reference point on the face's axis of symmetry where one
+ * exists (kernel `axisPoint` — cylinder/cone/sphere/torus), the integral
+ * centroid for planes and generic surfaces. Selection semantics key on it;
+ * occt.ts ≥0.10.0 reports both, we keep the axis-stable one.
+ */
+interface FaceMeta {
+  readonly index: number;
+  readonly surface: SurfaceKind;
+  readonly area: number;
+  readonly center: Vec3;
+  /** Plane only — unit normal. */
+  readonly normal?: Vec3;
+  /** Cylinder/cone/torus — unit axis. */
+  readonly axis?: Vec3;
+  /** Cylinder/sphere/torus. */
+  readonly radius?: number;
+}
+/** Metadata for one edge. `index` is the kernel's 1-based fillet/chamfer index. */
+interface EdgeMeta {
+  readonly index: number;
+  readonly curve: CurveKind;
+  readonly length: number;
+  /**
+   * Line: midpoint. Circle/ellipse: the underlying circle/ellipse center
+   * (kernel `axisPoint`, not the arc's integral centroid — matches
+   * build123d selector semantics). Others: integral centroid.
+   */
+  readonly center: Vec3;
+  /** Line only — unit direction (start → end). */
+  readonly direction?: Vec3;
+  /** Circle/ellipse — unit axis. */
+  readonly axis?: Vec3;
+  /** Circle only. */
+  readonly radius?: number;
+}
+/** A through-cylindrical-feature heuristic hit (bore/hole/boss). */
+interface HoleMeta {
+  readonly radius: number;
+  readonly axis: Vec3;
+  readonly center: Vec3;
+  readonly length: number | null;
+}
+/**
+ * Everything the kernel can tell us about a shape in one interrogation call.
+ * Sub-shape metadata (not handles) is the foundation selectors stand on.
+ */
+interface ShapeMeta {
+  readonly shapeType: string;
+  readonly volume: number;
+  readonly area: number;
+  readonly bbox: BBox;
+  readonly center: Vec3;
+  readonly valid: boolean;
+  readonly faces: readonly FaceMeta[];
+  readonly edges: readonly EdgeMeta[];
+  readonly holes: readonly HoleMeta[];
+}
+/**
+ * The only surface allowed to touch occt.ts.
+ *
+ * Revised for occt.ts reality (it is a high-level API, not an OCP-style class
+ * mirror): sub-shapes are addressed by 1-based `index` into `meta()`, never by
+ * handles; there are no lazily-composed locations — transforms execute
+ * immediately. Anything occt.ts cannot express shows up here as a missing
+ * method (see docs/occt-requirements.md before adding workarounds below this
+ * interface).
+ */
+interface Kernel {
+  makeBox(dx: number, dy: number, dz: number, at?: Vec3, dir?: Vec3): ShapeHandle;
+  makeCylinder(radius: number, height: number, at?: Vec3, dir?: Vec3): ShapeHandle;
+  makeSphere(radius: number, at?: Vec3): ShapeHandle;
+  makeCone(radius1: number, radius2: number, height: number, at?: Vec3): ShapeHandle;
+  makeTorus(radius1: number, radius2: number, at?: Vec3): ShapeHandle;
+  /**
+   * Booleans clean by default (UnifySameDomain — same as build123d/CadQuery):
+   * coplanar faces merge, collinear edges join. `clean: false` keeps raw
+   * fragment topology for callers that count fragments.
+   */
+  boolean(op: "fuse" | "cut" | "common", a: ShapeHandle, b: ShapeHandle, opts?: {
+    clean?: boolean;
+  }): ShapeHandle;
+  /** `edgeIndices` are 1-based indices into `meta(s).edges`. Empty = all edges. */
+  fillet(s: ShapeHandle, radius: number, edgeIndices: number[]): ShapeHandle;
+  chamfer(s: ShapeHandle, distance: number, edgeIndices: number[]): ShapeHandle;
+  translate(s: ShapeHandle, by: Vec3): ShapeHandle;
+  rotate(s: ShapeHandle, axisDir: Vec3, angleDegrees: number): ShapeHandle;
+  /** One interrogation call; implementations cache per handle. */
+  meta(s: ShapeHandle): ShapeMeta;
+  isValid(s: ShapeHandle): boolean;
+  exportStep(s: ShapeHandle): Uint8Array;
+  /** Ascii STL. */
+  exportStl(s: ShapeHandle, tolerance?: number): string;
+  exportGlb(s: ShapeHandle): Uint8Array;
+  importStep(data: Uint8Array): ShapeHandle;
+  /** Deterministic checksum (BRep serialization hash), for caching and eval replay. */
+  hash(s: ShapeHandle): string;
+  /** WASM memory is not GC'd — dispose explicitly. */
+  dispose(s: ShapeHandle): void;
+}
+//#endregion
+//#region src/topo/index.d.ts
+/** Plain-JSON shape summary returned by `describe()`. */
+interface Describe {
+  volume: number;
+  area: number;
+  bbox: {
+    min: Vec3;
+    max: Vec3;
+  };
+  center: Vec3;
+  faces: number;
+  edges: number;
+  valid: boolean;
+}
+/** A shape owned by the kernel: solids, and later shells/wires/faces. */
+declare class Shape {
+  #private;
+  readonly handle: ShapeHandle;
+  constructor(handle: ShapeHandle);
+  /** One kernel interrogation, cached per instance. */
+  meta(): ShapeMeta;
+  describe(): Describe;
+  volume(): number;
+  area(): number;
+  center(): Vec3;
+  isValid(): boolean;
+  hash(): string;
+  faces(): ShapeList<Face>;
+  edges(): ShapeList<Edge>;
+  /**
+   * Not available yet: the kernel's interrogation output carries no vertex
+   * records (docs/occt-requirements.md R5). Will land with that kernel API.
+   */
+  vertices(): ShapeList<never>;
+  /** See `Kernel.boolean` — cleaned by default (UnifySameDomain). */
+  cut(b: Shape, opts?: {
+    clean?: boolean;
+  }): Solid;
+  fuse(b: Shape, opts?: {
+    clean?: boolean;
+  }): Solid;
+  /** build123d's `intersect` (OCCT `common`). */
+  common(b: Shape, opts?: {
+    clean?: boolean;
+  }): Solid;
+  /** Immediate-bake transform (occt.ts has no lazy location chain). */
+  translate(by: Vec3): Solid;
+  fillet(edges: ShapeList<Edge> | readonly Edge[], radius: number): Solid;
+  chamfer(edges: ShapeList<Edge> | readonly Edge[], distance: number): Solid;
+  /** Export by file extension (.step/.stl/.glb). Node writes to disk. */
+  export(path: string, opts?: {
+    tolerance?: number;
+  }): Promise<void>;
+  dispose(): void;
+}
+declare class Solid extends Shape {}
+/** A face "view": kernel metadata plus the parent it was selected from. */
+declare class Face {
+  readonly parent: Shape;
+  readonly meta: FaceMeta;
+  constructor(parent: Shape, meta: FaceMeta);
+  get index(): number;
+  get surface(): FaceMeta["surface"];
+  get area(): number;
+  get center(): Vec3;
+  get normal(): Vec3 | undefined;
+  get axis(): Axis | undefined;
+  get radius(): number | undefined;
+}
+/** An edge "view". `index` is the kernel's fillet/chamfer selection index. */
+declare class Edge {
+  readonly parent: Shape;
+  readonly meta: EdgeMeta;
+  constructor(parent: Shape, meta: EdgeMeta);
+  get index(): number;
+  get curve(): EdgeMeta["curve"];
+  get length(): number;
+  get center(): Vec3;
+  get direction(): Vec3 | undefined;
+  get axis(): Axis | undefined;
+  get radius(): number | undefined;
+}
+type FilterBy<T> = Axis | Plane | string | ((item: T) => boolean);
+/**
+ * A typed, chainable collection of sub-shapes, build123d-style.
+ *
+ * - `filterBy(Axis)`: planar faces with parallel normal, line edges with
+ *   parallel tangent; everything else drops out.
+ * - `filterBy(Plane)`: faces parallel to the plane; circle/ellipse edges
+ *   lying in the plane; line edges with center in plane and tangent ⊥ normal.
+ * - `filterBy("cylinder" | "line" | ...)`: geometry-type equality.
+ * - `filterBy(fn)`: custom predicate.
+ */
+declare class ShapeList<T extends Face | Edge> implements Iterable<T> {
+  #private;
+  readonly items: readonly T[];
+  constructor(items: readonly T[]);
+  [Symbol.iterator](): Iterator<T>;
+  count(): number;
+  first(): T | undefined;
+  last(): T | undefined;
+  /** Exactly one, else a structured error (build123d raises on ambiguity). */
+  single(what?: string): T;
+  filterBy(filter: FilterBy<T>, opts?: {
+    reverse?: boolean;
+  }): ShapeList<T>;
+  /**
+   * Filter and sort by sub-shape center projected on `axis`
+   * (build123d `filter_by_position`).
+   */
+  filterByPosition(axis: Axis, minimum: number, maximum: number, inclusive?: [boolean, boolean]): ShapeList<T>;
+  /**
+   * Group by a key then return the groups sorted by that key
+   * (build123d `group_by`; Axis keys project centers, rounded to 6 digits).
+   */
+  groupBy(key: Axis | "length" | "radius" | "area" | "volume" | ((item: T) => number | string)): ShapeList<T>[];
+  /** Sort (build123d `sort_by`); Axis keys project centers on the axis). */
+  sortBy(key: Axis | "length" | "radius" | "area" | "volume" | ((item: T) => number), reverse?: boolean): ShapeList<T>;
+  sortByKey(keyFn: (item: T) => number | string, reverse?: boolean): ShapeList<T>;
+}
+//#endregion
+export { Vec3 as C, v as E, Plane as S, planeFrom as T, AxisName as _, ShapeList as a, Location as b, EdgeMeta as c, Kernel as d, ShapeHandle as f, Axis3 as g, Axis as h, Shape as i, FaceMeta as l, SurfaceKind as m, Edge as n, Solid as o, ShapeMeta as p, Face as r, CurveKind as s, Describe as t, HoleMeta as u, BBox as v, axisByName as w, Mesh as x, Loc as y };

package/dist/index.d.ts

@@ -0,0 +1,108 @@
+import { C as Vec3, E as v, S as Plane, T as planeFrom, _ as AxisName, a as ShapeList, b as Location, c as EdgeMeta, d as Kernel, f as ShapeHandle, g as Axis3, h as Axis, i as Shape, l as FaceMeta, m as SurfaceKind, n as Edge, o as Solid, p as ShapeMeta, r as Face, s as CurveKind, t as Describe, u as HoleMeta, v as BBox, w as axisByName, x as Mesh, y as Loc } from "./index-DceghC4N.js";
+import "occt.ts";
+//#region src/io/index.d.ts
+type ExportFormat = "step" | "stl" | "glb";
+export declare function exportStep(s: Shape): Uint8Array;
+export declare function exportStl(s: Shape, tolerance?: number): string;
+export declare function exportGlb(s: Shape): Uint8Array;
+export declare function importStep(data: Uint8Array | string): Promise<Solid>;
+/** Writes a shape to disk (Node). Extension picks the format. */
+export declare function exportShape(s: Shape, path: string, opts?: {
+  tolerance?: number;
+}): Promise<void>;
+//#endregion
+//#region src/kernel/occt.d.ts
+interface InitOptions {
+  /** Explicit URL or path to the OCCT WASM binary (file, http(s) or data:). */
+  wasmUrl?: string;
+}
+/** Loads the OCCT WASM kernel exactly once per process (idempotent). */
+export declare function init(opts?: InitOptions): Promise<void>;
+//#endregion
+//#region src/ops/index.d.ts
+export declare function fuse(a: Solid, b: Shape, opts?: {
+  clean?: boolean;
+}): Solid;
+export declare function cut(a: Solid, b: Shape, opts?: {
+  clean?: boolean;
+}): Solid;
+/** build123d `intersect` — OCCT `common`. */
+export declare function intersect(a: Solid, b: Shape, opts?: {
+  clean?: boolean;
+}): Solid;
+/** Keep the OCCT name for code translated from CadQuery. */
+export declare const common: typeof intersect;
+export declare function fillet(s: Shape, edges: ShapeList<Edge> | readonly Edge[], radius: number): Solid;
+/** Equal-distance chamfer; asymmetric needs kernel support (R3). */
+export declare function chamfer(s: Shape, edges: ShapeList<Edge> | readonly Edge[], distance: number): Solid;
+export declare function translate(s: Shape, by: readonly [number, number, number]): Solid;
+/** M1: extrude a 2D sketch into a solid. */
+export declare function extrude(_sketch: unknown, _height: number): Solid;
+/** M1: revolve a 2D sketch around an axis. */
+export declare function revolve(_sketch: unknown, _axis: unknown, _angle?: number): Solid;
+//#endregion
+//#region src/primitives/index.d.ts
+export declare function Box(dx: number, dy: number, dz: number, loc?: Loc): Solid;
+export declare function Cylinder(opts: {
+  radius: number;
+  height: number;
+  loc?: Loc;
+}): Solid;
+export declare function Sphere(opts: {
+  radius: number;
+  loc?: Loc;
+}): Solid;
+export declare function Cone(opts: {
+  radius1: number;
+  radius2: number;
+  height: number;
+  loc?: Loc;
+}): Solid;
+export declare function Torus(opts: {
+  radius1: number;
+  radius2: number;
+  loc?: Loc;
+}): Solid;
+//#endregion
+//#region src/record.d.ts
+/**
+ * Op recording — the day-one rule from docs/architecture.md §3.3:
+ * every mutating core operation goes through `record()`, so the runtime
+ * Session/OpLog can observe, snapshot and replay the exact same stream
+ * regardless of which API style (core algebra or workplane facade) produced it.
+ *
+ * With no subscribers installed this is a transparent pass-through.
+ */
+interface OpRecord {
+  /** Monotonic, process-wide — the id the OpLog keys snapshots by. */
+  readonly id: number;
+  readonly type: string;
+  readonly args: unknown;
+}
+type OpStatus = "done" | "error";
+interface OpEvent {
+  readonly op: OpRecord;
+  readonly status: OpStatus;
+  readonly result?: ShapeHandle;
+  readonly error?: unknown;
+}
+type OpListener = (event: OpEvent) => void;
+/** Subscribe to every recorded operation. Returns an unsubscribe function. */
+export declare function onOp(listener: OpListener): () => void;
+/**
+ * Runs `run()` and records it as one op. Errors propagate unchanged after
+ * being recorded — structured error mapping (runtime) subscribes via onOp.
+ */
+export declare function record<T>(type: string, args: unknown, run: () => T): T;
+//#endregion
+//#region src/selectors/index.d.ts
+type SubShape = Face | Edge;
+interface Selector {
+  /** The source string, for error messages and op-log readability. */
+  readonly source: string;
+  select(items: readonly SubShape[]): SubShape[];
+}
+/** Parses a CadQuery-style selector string into an executable selector. */
+export declare function parseSelector(source: string): Selector;
+//#endregion
+export { Axis, type Axis3, type AxisName, type BBox, type CurveKind, type Describe, Edge, type EdgeMeta, type ExportFormat, Face, type FaceMeta, type HoleMeta, type InitOptions, type Kernel, type Loc, type Location, type Mesh, type OpEvent, type OpListener, type OpRecord, type OpStatus, type Plane, type Selector, Shape, type ShapeHandle, ShapeList, type ShapeMeta, Solid, type SubShape, type SurfaceKind, type Vec3, axisByName, planeFrom, v };

package/dist/index.js

@@ -0,0 +1,48 @@
+import { a as importStep, i as exportStl, n as exportShape, r as exportStep, t as exportGlb } from "./io-DD2D1UYF.js";
+import { _ as Axis, a as Sphere, b as v, c as Face, d as Solid, g as init, i as Cylinder, l as Shape, m as record, n as Box, o as Torus, p as onOp, r as Cone, s as Edge, t as parseSelector, u as ShapeList, v as axisByName, y as planeFrom } from "./selectors-C0-da9aQ.js";
+//#region src/util.ts
+/** Thrown by every skeleton stub until the real M0 implementation lands. */
+var NotImplementedError = class extends Error {
+	constructor(what) {
+		super(`${what} is not implemented yet — this is the M0 repository skeleton.`);
+		this.name = "NotImplementedError";
+	}
+};
+/** Stub body helper: keeps signatures real while bodies wait for M0. */
+function todo(what) {
+	throw new NotImplementedError(what);
+}
+//#endregion
+//#region src/ops/index.ts
+function fuse(a, b, opts) {
+	return a.fuse(b, opts);
+}
+function cut(a, b, opts) {
+	return a.cut(b, opts);
+}
+/** build123d `intersect` — OCCT `common`. */
+function intersect(a, b, opts) {
+	return a.common(b, opts);
+}
+/** Keep the OCCT name for code translated from CadQuery. */
+const common = intersect;
+function fillet(s, edges, radius) {
+	return s.fillet(edges, radius);
+}
+/** Equal-distance chamfer; asymmetric needs kernel support (R3). */
+function chamfer(s, edges, distance) {
+	return s.chamfer(edges, distance);
+}
+function translate(s, by) {
+	return s.translate(by);
+}
+/** M1: extrude a 2D sketch into a solid. */
+function extrude(_sketch, _height) {
+	todo("extrude");
+}
+/** M1: revolve a 2D sketch around an axis. */
+function revolve(_sketch, _axis, _angle) {
+	todo("revolve");
+}
+//#endregion
+export { Axis, Box, Cone, Cylinder, Edge, Face, Shape, ShapeList, Solid, Sphere, Torus, axisByName, chamfer, common, cut, exportGlb, exportShape, exportStep, exportStl, extrude, fillet, fuse, importStep, init, intersect, onOp, parseSelector, planeFrom, record, revolve, translate, v };

package/dist/io-DD2D1UYF.js

@@ -0,0 +1,52 @@
+import { f as solidFromKernel, h as getKernel, m as record } from "./selectors-C0-da9aQ.js";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/io/index.ts
+/**
+* Import/export. `exportShape(shape, path)` writes to disk in Node; in the
+* browser (or for in-memory pipelines) call the format functions directly.
+*/
+var io_exports = /* @__PURE__ */ __exportAll({
+	exportGlb: () => exportGlb,
+	exportShape: () => exportShape,
+	exportStep: () => exportStep,
+	exportStl: () => exportStl,
+	importStep: () => importStep
+});
+function exportStep(s) {
+	return getKernel().exportStep(s.handle);
+}
+function exportStl(s, tolerance) {
+	return getKernel().exportStl(s.handle, tolerance);
+}
+function exportGlb(s) {
+	return getKernel().exportGlb(s.handle);
+}
+function importStep(data) {
+	const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+	return Promise.resolve(record("importStep", { bytes: bytes.length }, () => solidFromKernel(getKernel().importStep(bytes))));
+}
+function formatFor(path) {
+	const ext = path.slice(path.lastIndexOf(".") + 1).toLowerCase();
+	if (ext === "step" || ext === "stp" || ext === "stl" || ext === "glb") return ext === "stp" ? "step" : ext;
+	throw new Error(`Unsupported export extension in ${JSON.stringify(path)} — use .step, .stl or .glb.`);
+}
+/** Writes a shape to disk (Node). Extension picks the format. */
+async function exportShape(s, path, opts) {
+	const format = formatFor(path);
+	const payload = format === "step" ? exportStep(s) : format === "glb" ? exportGlb(s) : exportStl(s, opts?.tolerance);
+	const { writeFile } = await import("node:fs/promises");
+	await writeFile(path, payload);
+}
+//#endregion
+export { importStep as a, exportStl as i, exportShape as n, io_exports as o, exportStep as r, exportGlb as t };