allyhub 0.2.0-next.0 → 0.2.0-next.2

package/node_modules/@allyhub-next/model/dist/bmesh-data.d.ts

@@ -0,0 +1,227 @@
+import { type ModelMesh, type MeshUVLoop, type Vec3 } from "./data.js";
+/** Stable element references are valid until explicitly deleted or their BMesh is freed. */
+export declare abstract class BMElement {
+    readonly mesh: BMesh;
+    readonly identity: symbol;
+    private live;
+    private selected;
+    private elementIndex;
+    constructor(mesh: BMesh);
+    get is_valid(): boolean;
+    assertValid(): void;
+    invalidate(): void;
+    get index(): number;
+    set index(value: number);
+    get select(): boolean;
+    set select(value: boolean);
+    /** Internal flag copy without the public selection propagation. */
+    setSelectionRaw(value: boolean): void;
+    select_set(value: boolean): void;
+}
+export declare class BMVert extends BMElement {
+    private coordinate;
+    private readonly deform;
+    /** TypeScript adaptation of vert[deform_layer]: the vertex's weights. */
+    get(layer: BMLayerItem): BMDeformVert;
+    readonly edgeLinks: Set<BMEdge>;
+    readonly loopLinks: Set<BMLoop>;
+    constructor(mesh: BMesh, co: Vec3);
+    get co(): Vec3;
+    set co(value: Vec3);
+    get link_edges(): readonly BMEdge[];
+    get link_loops(): readonly BMLoop[];
+    get link_faces(): readonly BMFace[];
+    get is_boundary(): boolean;
+    get is_wire(): boolean;
+    get normal(): Vec3;
+}
+export declare class BMEdge extends BMElement {
+    get select(): boolean;
+    set select(value: boolean);
+    private endpoints;
+    readonly loopLinks: Set<BMLoop>;
+    private readonly floats;
+    /** TypeScript adaptation of edge[float_layer]; 0 until set. */
+    get(layer: BMLayerItem): number;
+    /** TypeScript adaptation of edge[float_layer] = value. */
+    set(layer: BMLayerItem, value: number): void;
+    private isSeam;
+    private isSmooth;
+    get seam(): boolean;
+    set seam(value: boolean);
+    get smooth(): boolean;
+    set smooth(value: boolean);
+    constructor(mesh: BMesh, verts: readonly [BMVert, BMVert]);
+    get verts(): readonly [BMVert, BMVert];
+    /** Internal topology mutation; callers must rewire incident loops in the same operation. */
+    setEndpoints(verts: readonly [BMVert, BMVert]): void;
+    get link_loops(): readonly BMLoop[];
+    get link_faces(): readonly BMFace[];
+    get is_boundary(): boolean;
+    get is_manifold(): boolean;
+    get is_wire(): boolean;
+    calc_length(): number;
+    other_vert(vertex: BMVert): BMVert;
+}
+export declare class BMUVLayer {
+    readonly mesh: BMesh;
+    readonly name: string;
+    is_valid: boolean;
+    constructor(mesh: BMesh, name: string);
+}
+export declare class BMUVLayers implements Iterable<BMUVLayer> {
+    private readonly mesh;
+    private readonly entries;
+    private activeIndex;
+    constructor(mesh: BMesh);
+    new(name?: string): BMUVLayer;
+    verify(): BMUVLayer;
+    get active(): BMUVLayer | null;
+    /** Internal custom-data transfer; Blender's public active layer accessor is read-only. */
+    setActive(layer: BMUVLayer): void;
+    get(name: string): BMUVLayer | null;
+    get length(): number;
+    remove(layer: BMUVLayer): void;
+    [Symbol.iterator](): Iterator<BMUVLayer>;
+}
+/** A vertex or edge custom-data layer (bm.verts.layers.deform, bm.edges.layers.float). */
+export declare class BMLayerItem {
+    readonly mesh: BMesh;
+    readonly name: string;
+    is_valid: boolean;
+    constructor(mesh: BMesh, name: string);
+}
+/** Blender's BMLayerCollection for one kind of layer. */
+export declare class BMLayerCollection implements Iterable<BMLayerItem> {
+    private readonly mesh;
+    private readonly kind;
+    private readonly entries;
+    constructor(mesh: BMesh, kind: "deform" | "float");
+    /** A new layer; a BMesh has at most one deform layer, as in Blender. */
+    new(name?: string): BMLayerItem;
+    /** The layer, made if there is none (the deform layer), as Blender's verify. */
+    verify(): BMLayerItem;
+    get active(): BMLayerItem | null;
+    get(name: string): BMLayerItem | null;
+    keys(): string[];
+    get length(): number;
+    remove(layer: BMLayerItem): void;
+    [Symbol.iterator](): Iterator<BMLayerItem>;
+}
+/** A vertex's deform weights by group index (Blender's BMDeformVert, a dict). */
+export declare class BMDeformVert {
+    private readonly weights;
+    get(group: number, fallback?: number): number | undefined;
+    set(group: number, weight: number): void;
+    delete(group: number): void;
+    has(group: number): boolean;
+    keys(): number[];
+    values(): number[];
+    items(): [number, number][];
+    clear(): void;
+    get length(): number;
+}
+export declare class BMLoop extends BMElement {
+    private readonly vertex;
+    private boundary;
+    private readonly polygon;
+    private readonly uvData;
+    constructor(mesh: BMesh, vertex: BMVert, edge: BMEdge, face: BMFace);
+    get vert(): BMVert;
+    get edge(): BMEdge;
+    /** Internal adjacency update, preserving the loop's corner attributes and identity. */
+    setEdge(edge: BMEdge): void;
+    get face(): BMFace;
+    get link_loop_next(): BMLoop;
+    get link_loop_prev(): BMLoop;
+    get link_loop_radial_next(): BMLoop;
+    /** TypeScript adaptation of loop[uv_layer]. */
+    get(layer: BMUVLayer): MeshUVLoop;
+}
+export declare class BMFace extends BMElement {
+    get select(): boolean;
+    set select(value: boolean);
+    private readonly corners;
+    private materialIndex;
+    private isSmooth;
+    get material_index(): number;
+    set material_index(value: number);
+    get smooth(): boolean;
+    set smooth(value: boolean);
+    get loops(): readonly BMLoop[];
+    get verts(): readonly BMVert[];
+    get edges(): readonly BMEdge[];
+    /** Internal face construction. */
+    addLoop(loop: BMLoop): void;
+    /** Internal boundary replacement. Reuse surviving corners unless the operation replaces them. */
+    setBoundary(verts: readonly BMVert[], reuseLoops?: boolean): void;
+    normal_flip(): void;
+    get normal(): Vec3;
+    calc_center_median(): Vec3;
+    calc_area(): number;
+    select_set(value: boolean): void;
+}
+export declare class BMElemSeq<T extends BMElement> implements Iterable<T> {
+    protected readonly mesh: BMesh;
+    private readonly values;
+    private readonly removeElement;
+    constructor(mesh: BMesh, remove: (value: T) => void);
+    get length(): number;
+    at(index: number): T | undefined;
+    filter(predicate: (value: T, index: number) => boolean): T[];
+    find(predicate: (value: T, index: number) => boolean): T | undefined;
+    ensure_lookup_table(): void;
+    index_update(): void;
+    remove(value: T): void;
+    /** Internal membership mutations; topology owners update adjacency. */
+    add(value: T): void;
+    discard(value: T): void;
+    [Symbol.iterator](): Iterator<T>;
+}
+export declare class BMVertSeq extends BMElemSeq<BMVert> {
+    readonly layers: {
+        deform: BMLayerCollection;
+    };
+    new(co: Vec3): BMVert;
+}
+export declare class BMEdgeSeq extends BMElemSeq<BMEdge> {
+    readonly layers: {
+        float: BMLayerCollection;
+    };
+    get(verts: readonly [BMVert, BMVert]): BMEdge | null;
+    new(verts: readonly [BMVert, BMVert]): BMEdge;
+}
+export declare class BMFaceSeq extends BMElemSeq<BMFace> {
+    get(verts: readonly BMVert[]): BMFace | null;
+    new(verts: readonly BMVert[]): BMFace;
+}
+export declare class BMesh {
+    private active;
+    readonly verts: BMVertSeq;
+    readonly edges: BMEdgeSeq;
+    readonly faces: BMFaceSeq;
+    readonly loops: {
+        layers: {
+            uv: BMUVLayers;
+        };
+    };
+    constructor();
+    get is_valid(): boolean;
+    assertValid(): void;
+    check(element: BMElement): void;
+    normal_update(): void;
+    clear(): void;
+    free(): void;
+    /** AllyHub validation extension: structural invariants, including non-manifold radial loops. */
+    validate(): void;
+    from_mesh(mesh: ModelMesh): void;
+    to_mesh(mesh: ModelMesh): void;
+    copy(): BMesh;
+}
+/** @internal A vertex's weights copied to another of its BMesh (extrusion, duplication). */
+export declare function copyVertexData(from: BMVert, to: BMVert): void;
+/** @internal An edge's float values copied to another of its BMesh. */
+export declare function copyEdgeData(from: BMEdge, to: BMEdge): void;
+/** @internal Weights blended from vertices of the same BMesh (a split edge's new point). */
+export declare function blendVertexData(to: BMVert, sources: [BMVert, number][]): void;
+//# sourceMappingURL=bmesh-data.d.ts.map

package/node_modules/@allyhub-next/model/dist/bmesh-dissolve.d.ts

@@ -0,0 +1,30 @@
+import type { BMEdge, BMesh, BMFace, BMVert } from "./bmesh-data.js";
+/** Blender's `bmesh.ops.dissolve_verts`: the faces around each vertex become one, and the vertex goes. */
+export declare function dissolve_verts(bm: BMesh, options?: {
+    verts?: readonly BMVert[];
+    use_face_split?: boolean;
+    use_boundary_tear?: boolean;
+}): Record<string, never>;
+/** Blender's `bmesh.ops.dissolve_faces`: each connected region of the faces becomes one face. */
+export declare function dissolve_faces(bm: BMesh, options?: {
+    faces?: readonly BMFace[];
+    use_verts?: boolean;
+}): {
+    region: BMFace[];
+};
+/** Blender's `bmesh.ops.dissolve_edges`: the two faces of each edge become one. */
+export declare function dissolve_edges(bm: BMesh, options?: {
+    edges?: readonly BMEdge[];
+    use_verts?: boolean;
+    use_face_split?: boolean;
+    angle_threshold?: number;
+}): {
+    region: BMFace[];
+};
+/**
+ * Blender's limited dissolve is refused: it orders its joins and collapses by
+ * float32 angle costs in a heap, so meshes with equal or nearly equal costs
+ * dissolve in an order AllyHub cannot reproduce exactly.
+ */
+export declare function dissolve_limit(..._options: unknown[]): never;
+//# sourceMappingURL=bmesh-dissolve.d.ts.map

package/node_modules/@allyhub-next/model/dist/bmesh-edit.d.ts

@@ -0,0 +1,54 @@
+import { BMEdge, BMFace, BMVert, type BMesh } from "./bmesh-data.js";
+export type BMGeometry = BMVert | BMEdge | BMFace;
+/** Blender utility signature: the returned edge joins the supplied endpoint to the new vertex. */
+export declare function edge_split(edge: BMEdge, vert: BMVert, fac: number): [BMEdge, BMVert];
+export interface ExtrudeRegionOptions {
+    geom?: readonly BMGeometry[] | undefined;
+    edges_exclude?: ReadonlySet<BMEdge> | undefined;
+    use_keep_orig?: boolean | undefined;
+    use_normal_flip?: boolean | undefined;
+    use_normal_from_adjacent?: boolean | undefined;
+    use_dissolve_ortho_edges?: boolean | undefined;
+    use_select_history?: boolean | undefined;
+}
+export declare function extrude_face_region(bm: BMesh, options?: ExtrudeRegionOptions): {
+    geom: BMGeometry[];
+};
+export declare function extrude_discrete_faces(bm: BMesh, options?: {
+    faces?: readonly BMFace[];
+    use_normal_flip?: boolean;
+    use_select_history?: boolean;
+}): {
+    faces: BMFace[];
+};
+export type DeleteContext = "VERTS" | "EDGES" | "FACES_ONLY" | "EDGES_FACES" | "FACES" | "FACES_KEEP_BOUNDARY" | "TAGGED_ONLY";
+export declare function deleteGeometry(bm: BMesh, options?: {
+    geom?: readonly BMGeometry[] | undefined;
+    context?: DeleteContext | undefined;
+}): Record<string, never>;
+export declare function holes_fill(bm: BMesh, options?: {
+    edges?: readonly BMEdge[];
+    sides?: number;
+}): {
+    faces: BMFace[];
+};
+export interface TriangulateOptions {
+    faces?: readonly BMFace[];
+    quad_method?: "BEAUTY" | "FIXED" | "ALTERNATE" | "SHORT_EDGE" | "LONG_EDGE";
+    ngon_method?: "BEAUTY" | "EAR_CLIP";
+}
+export declare function triangulate(bm: BMesh, options?: TriangulateOptions): {
+    edges: BMEdge[];
+    faces: BMFace[];
+    face_map: Map<BMFace, BMFace>;
+    face_map_double: Map<BMFace, BMFace>;
+};
+/** Explicit target ownership: surviving vertices retain their coordinates and identities. */
+export declare function weld_verts(bm: BMesh, options?: {
+    targetmap?: ReadonlyMap<BMVert, BMVert>;
+}): Record<string, never>;
+export declare function remove_doubles(bm: BMesh, options?: {
+    verts?: readonly BMVert[];
+    dist?: number;
+}): Record<string, never>;
+//# sourceMappingURL=bmesh-edit.d.ts.map

package/node_modules/@allyhub-next/model/dist/bmesh-inset.d.ts

@@ -0,0 +1,39 @@
+import { BMFace, type BMesh } from "./bmesh-data.js";
+export interface InsetIndividualOptions {
+    faces?: readonly BMFace[];
+    thickness?: number;
+    depth?: number;
+    use_even_offset?: boolean;
+    use_interpolate?: boolean;
+    use_relative_offset?: boolean;
+}
+/**
+ * Insets each face on its own: the face keeps its place in the mesh and its
+ * corners move inwards; a ring of quads joins it to its old outline.
+ * Returns the ring's quads.
+ */
+export declare function inset_individual(bm: BMesh, options?: InsetIndividualOptions): {
+    faces: BMFace[];
+};
+export interface InsetRegionOptions {
+    faces?: readonly BMFace[];
+    faces_exclude?: readonly BMFace[];
+    use_boundary?: boolean;
+    use_even_offset?: boolean;
+    use_interpolate?: boolean;
+    use_relative_offset?: boolean;
+    use_edge_rail?: boolean;
+    thickness?: number;
+    depth?: number;
+    use_outset?: boolean;
+}
+/**
+ * Insets a region of faces: the edges between it and the rest (with
+ * use_boundary, also the mesh's open edges along it) are doubled, the inner
+ * copy moving into the region, and quads join the two.
+ * Returns those quads.
+ */
+export declare function inset_region(bm: BMesh, options?: InsetRegionOptions): {
+    faces: BMFace[];
+};
+//# sourceMappingURL=bmesh-inset.d.ts.map

package/node_modules/@allyhub-next/model/dist/bmesh-primitives.d.ts

@@ -0,0 +1,41 @@
+import { Matrix4 } from "three";
+import { BMesh, type BMVert } from "./bmesh-data.js";
+/** TypeScript adaptation: Blender matrix values are nested row-major arrays. */
+export type MatrixRows = readonly (readonly number[])[];
+interface PrimitiveOptions {
+    matrix?: MatrixRows;
+    calc_uvs?: boolean;
+}
+export declare function matrixOf(rows?: MatrixRows): Matrix4;
+export declare function allowedOptions(options: object, allowed: readonly string[]): void;
+export declare function create_cube(bm: BMesh, options?: PrimitiveOptions & {
+    size?: number;
+}): {
+    verts: BMVert[];
+};
+export declare function create_grid(bm: BMesh, options?: PrimitiveOptions & {
+    size?: number;
+    x_segments?: number;
+    y_segments?: number;
+}): {
+    verts: BMVert[];
+};
+export declare function create_uvsphere(bm: BMesh, options?: PrimitiveOptions & {
+    u_segments?: number;
+    v_segments?: number;
+    radius?: number;
+}): {
+    verts: BMVert[];
+};
+export declare function create_cone(bm: BMesh, options?: PrimitiveOptions & {
+    cap_ends?: boolean;
+    cap_tris?: boolean;
+    segments?: number;
+    radius1?: number;
+    radius2?: number;
+    depth?: number;
+}): {
+    verts: BMVert[];
+};
+export {};
+//# sourceMappingURL=bmesh-primitives.d.ts.map

package/node_modules/@allyhub-next/model/dist/bmesh-smooth.d.ts

@@ -0,0 +1,22 @@
+import type { BMesh, BMVert } from "./bmesh-data.js";
+/**
+ * Blender's bmesh.ops.smooth_vert (bmo_smooth_vert_exec): each vertex moves
+ * towards the mean of the vertices its edges reach, by `factor`, only along
+ * the axes asked for (`use_axis_x/y/z`, all false by default, as in
+ * Blender, so nothing moves unless one is given). Every new position is
+ * computed from the positions before the call, then written. With
+ * `mirror_clip_x/y/z`, a vertex within `clip_dist` of that axis's plane is
+ * put on it. A vertex with no edges stays.
+ */
+export declare function smooth_vert(bm: BMesh, options?: {
+    verts?: readonly BMVert[];
+    factor?: number;
+    mirror_clip_x?: boolean;
+    mirror_clip_y?: boolean;
+    mirror_clip_z?: boolean;
+    clip_dist?: number;
+    use_axis_x?: boolean;
+    use_axis_y?: boolean;
+    use_axis_z?: boolean;
+}): Record<string, never>;
+//# sourceMappingURL=bmesh-smooth.d.ts.map

package/node_modules/@allyhub-next/model/dist/bmesh-spin.d.ts

@@ -0,0 +1,25 @@
+import { type Vec3 } from "./data.js";
+import { BMEdge, BMFace, BMVert, type BMesh } from "./bmesh-data.js";
+import { type MatrixRows } from "./bmesh-primitives.js";
+export type SpinGeometry = BMVert | BMEdge | BMFace;
+export interface SpinOptions {
+    geom?: readonly SpinGeometry[];
+    cent?: Vec3;
+    axis?: Vec3;
+    dvec?: Vec3;
+    angle?: number;
+    space?: MatrixRows;
+    steps?: number;
+    use_merge?: boolean;
+    use_normal_flip?: boolean;
+    use_duplicate?: boolean;
+}
+/**
+ * Blender's `bmesh.ops.spin`: extrudes (or duplicates) the geometry `steps`
+ * times, turning each copy by `angle / steps` about `axis` through `cent`
+ * and moving it by `dvec` turned as far, all in `space`.
+ */
+export declare function spin(bm: BMesh, options?: SpinOptions): {
+    geom_last: SpinGeometry[];
+};
+//# sourceMappingURL=bmesh-spin.d.ts.map

package/node_modules/@allyhub-next/model/dist/bmesh-subdivide.d.ts

@@ -0,0 +1,89 @@
+/**
+ * bmesh.ops.subdivide_edges, as Blender 4.5 does it: the edges are cut first,
+ * then each face they bound is filled by the pattern its cut sides match (one
+ * side, two sides at a corner, three sides, all sides, a triangle's one or
+ * three sides), or cut straight across between two cut sides. The patterns'
+ * vertex pairings, which piece of a split face keeps the original face, the
+ * corners each piece starts at and the elements each result list holds were
+ * measured against Blender 4.5.14 (test/reference/blender-subdivide.py). This
+ * is AllyHub's own implementation; no Blender code is copied.
+ */
+import { type MeshUVLoop } from "./data.js";
+import { BMEdge, BMFace, BMVert, type BMesh, type BMLoop, type BMUVLayer } from "./bmesh-data.js";
+import type { BMGeometry } from "./bmesh-edit.js";
+/** @internal A face corner's UV data, layer by layer. */
+export type Corner = Map<BMUVLayer, MeshUVLoop>;
+/** @internal */
+export declare function readCorner(loop: BMLoop): Corner;
+/** @internal */
+export declare function writeCorner(loop: BMLoop, corner: Corner): void;
+/** @internal Corners a and b mixed, (1 − t)·a + t·b; flags are kept where either has them. */
+export declare function mixCorner(a: Corner, b: Corner, t: number): Corner;
+/** @internal A face's corners by vertex. */
+export declare function cornersOf(face: BMFace): Map<BMVert, Corner>;
+/** @internal Writes each corner of a face from corners kept by vertex. */
+export declare function writeCorners(face: BMFace, corners: ReadonlyMap<BMVert, Corner>): void;
+/** @internal An edge's flags and float values copied to another (Blender copies all but selection). */
+export declare function copyEdgeFlags(source: BMEdge, target: BMEdge, select: boolean): void;
+/** @internal A face's material and shading copied to another, unselected. */
+export declare function copyFaceLook(source: BMFace, target: BMFace): void;
+/**
+ * @internal Splits an edge at `fac` of the way from `from` to its other end,
+ * as Blender's BM_edge_split: the new edge runs from `from` to the new vertex
+ * and takes the edge's flags (selection too), the edge itself keeps the
+ * stretch to its other end, the vertex's weights and each face's corner are
+ * mixed from the ends.
+ */
+export declare function splitEdgeAt(edge: BMEdge, from: BMVert, fac: number): {
+    vert: BMVert;
+    edge: BMEdge;
+};
+/**
+ * @internal Splits a face along a new edge from `a` to `b`, as Blender's
+ * BM_face_split: the face keeps its corners from a to b, a new face (with
+ * the face's material and shading, unselected) takes those from b back to a,
+ * and the corner each starts at follows Blender's rule for its first loop.
+ * Returns null where Blender splits nothing: either vertex is not on the
+ * face, or they are neighbours.
+ */
+export declare function splitFace(face: BMFace, a: BMVert, b: BMVert): {
+    face: BMFace;
+    edge: BMEdge;
+} | null;
+declare const CORNER_TYPES: readonly ["STRAIGHT_CUT", "INNER_VERT", "PATH", "FAN"];
+declare const FALLOFFS: readonly ["SMOOTH", "SPHERE", "ROOT", "SHARP", "LINEAR", "INVERSE_SQUARE"];
+export interface SubdivideEdgesOptions {
+    edges?: readonly BMEdge[];
+    smooth?: number;
+    smooth_falloff?: (typeof FALLOFFS)[number];
+    fractal?: number;
+    along_normal?: number;
+    cuts?: number;
+    seed?: number;
+    custom_patterns?: ReadonlyMap<BMFace, unknown>;
+    edge_percents?: ReadonlyMap<BMEdge, number>;
+    quad_corner_type?: (typeof CORNER_TYPES)[number];
+    use_grid_fill?: boolean;
+    use_single_edge?: boolean;
+    use_only_quads?: boolean;
+    use_sphere?: boolean;
+    use_smooth_even?: boolean;
+}
+export interface SubdivideEdgesResult {
+    geom_inner: BMGeometry[];
+    geom_split: BMGeometry[];
+    geom: BMGeometry[];
+}
+/**
+ * Cuts edges into `cuts` + 1 pieces and fills the faces they bound. With
+ * `use_grid_fill` a quad or triangle cut on every side becomes a grid; a ring
+ * of edges across quads, each quad cut on two opposite sides, is a loop cut.
+ */
+/**
+ * Blender's bmesh.ops.subdivide_edges. A cut that would join two vertices
+ * already joined is found only partway through, so the whole operation runs
+ * first on a copy: when it fails, the BMesh is left as it was.
+ */
+export declare function subdivide_edges(bm: BMesh, options?: SubdivideEdgesOptions): SubdivideEdgesResult;
+export {};
+//# sourceMappingURL=bmesh-subdivide.d.ts.map

package/node_modules/@allyhub-next/model/dist/bmesh.d.ts

@@ -0,0 +1,72 @@
+import { edge_split, extrude_face_region, extrude_discrete_faces, deleteGeometry, holes_fill, triangulate, weld_verts, remove_doubles } from "./bmesh-edit.js";
+import { subdivide_edges } from "./bmesh-subdivide.js";
+import { bridge_loops } from "./bmesh-bridge.js";
+import { inset_individual, inset_region } from "./bmesh-inset.js";
+import { spin } from "./bmesh-spin.js";
+import { smooth_vert } from "./bmesh-smooth.js";
+import { dissolve_edges, dissolve_faces, dissolve_limit, dissolve_verts } from "./bmesh-dissolve.js";
+import { type Vec3 } from "./data.js";
+import { BMesh, type BMVert } from "./bmesh-data.js";
+import { bevel } from "./bmesh-bevel.js";
+import { create_cube, create_grid, create_uvsphere, create_cone, type MatrixRows } from "./bmesh-primitives.js";
+declare function transform(bm: BMesh, options: {
+    verts: readonly BMVert[];
+    matrix: MatrixRows;
+    space?: MatrixRows;
+}): Record<string, never>;
+declare function translate(bm: BMesh, options: {
+    verts: readonly BMVert[];
+    vec: Vec3;
+    space?: MatrixRows;
+}): Record<string, never>;
+declare function scale(bm: BMesh, options: {
+    verts: readonly BMVert[];
+    vec: Vec3;
+    space?: MatrixRows;
+}): Record<string, never>;
+/** Rotates (or applies any 3×3 or 4×4 matrix) about `cent`, as Blender's bmesh.ops.rotate. */
+declare function rotate(bm: BMesh, options: {
+    verts: readonly BMVert[];
+    matrix: MatrixRows;
+    cent?: Vec3;
+    space?: MatrixRows;
+}): Record<string, never>;
+export declare const bmesh: {
+    "new"(options?: {
+        use_operators?: boolean;
+    }): BMesh;
+    utils: {
+        edge_split: typeof edge_split;
+    };
+    ops: {
+        create_cube: typeof create_cube;
+        create_grid: typeof create_grid;
+        create_uvsphere: typeof create_uvsphere;
+        create_cone: typeof create_cone;
+        transform: typeof transform;
+        translate: typeof translate;
+        scale: typeof scale;
+        rotate: typeof rotate;
+        extrude_face_region: typeof extrude_face_region;
+        extrude_discrete_faces: typeof extrude_discrete_faces;
+        bevel: typeof bevel;
+        inset_region: typeof inset_region;
+        inset_individual: typeof inset_individual;
+        delete: typeof deleteGeometry;
+        holes_fill: typeof holes_fill;
+        triangulate: typeof triangulate;
+        weld_verts: typeof weld_verts;
+        remove_doubles: typeof remove_doubles;
+        subdivide_edges: typeof subdivide_edges;
+        bridge_loops: typeof bridge_loops;
+        spin: typeof spin;
+        smooth_vert: typeof smooth_vert;
+        dissolve_verts: typeof dissolve_verts;
+        dissolve_edges: typeof dissolve_edges;
+        dissolve_faces: typeof dissolve_faces;
+        dissolve_limit: typeof dissolve_limit;
+    };
+};
+export { BMesh, BMVert, BMEdge, BMFace, BMLoop, BMUVLayer, BMLayerItem, BMLayerCollection, BMDeformVert, } from "./bmesh-data.js";
+export type { MatrixRows } from "./bmesh-primitives.js";
+//# sourceMappingURL=bmesh.d.ts.map

package/node_modules/@allyhub-next/model/dist/boolean.d.ts

@@ -0,0 +1,20 @@
+import type { ManifoldToplevel } from "manifold-3d";
+import { type BooleanModifier } from "./data.js";
+import { type Geometry } from "./geometry.js";
+/**
+ * Starts the Boolean kernel (Manifold) now, and from `manifoldWasm` when
+ * given. Without it the kernel finds `manifold.wasm` beside its own module
+ * (`new URL("manifold.wasm", import.meta.url)`), which Node and the bundlers
+ * that follow that form (Vite, webpack 5) need nothing for; a page that serves
+ * the file elsewhere passes its address before the first Boolean. Evaluation
+ * starts the kernel itself when a Boolean needs it; a model with none never
+ * loads it.
+ */
+export declare function loadManifold(options?: {
+    manifoldWasm?: string | URL;
+}): Promise<void>;
+/** Internal backend entry for evaluation and isolated ownership diagnostics. */
+export declare function manifoldKernel(): Promise<ManifoldToplevel>;
+/** Own every WASM handle for exactly one evaluation; failures release partial results too. */
+export declare function booleanGeometry(target: Geometry, operand: Geometry, modifier: Pick<BooleanModifier, "operation" | "material_mode">, label: string): Promise<Geometry>;
+//# sourceMappingURL=boolean.d.ts.map

package/node_modules/@allyhub-next/model/dist/build-cache.d.ts

@@ -0,0 +1,42 @@
+/** Where a cache is: the project's root, which entries name their inputs from, and the cache's folder. */
+export interface ModelCacheLocation {
+    root: string;
+    dir: string;
+}
+export interface ModelCacheKey {
+    /** The module, absolute. */
+    file: string;
+    parameters: unknown;
+    seed: number;
+    maxPatternVertices: number;
+    maxSurfaceVertices: number;
+    maxInstances: number;
+    /** A digest of the runtime files a build runs (`runtimeDigest`). */
+    runtime: string;
+}
+/** One digest of every file in `dirs` and of `files`, names included. */
+export declare function runtimeDigest(dirs: readonly string[], files?: readonly string[]): Promise<string>;
+export declare function cacheKey(key: ModelCacheKey): string;
+/** The files a build read: what the worker reports, plus the module's own folder. */
+export interface BuildInputs {
+    files: string[];
+    /** The module's folder, whose listing is part of the entry (none at the project's root). */
+    folder?: string;
+}
+export declare function buildInputs(root: string, module: string, read: readonly string[]): Promise<BuildInputs>;
+export interface CachedBuild {
+    result: unknown;
+    /** The cached GLB, present when the entry was made by a build. */
+    glb?: string;
+}
+/**
+ * The entry for `key` under `root`, if every input still hashes as recorded
+ * and its GLB (when `needGlb`) is whole. Anything unreadable removes the
+ * entry; a changed input only misses.
+ */
+export declare function readModelCache({ root, dir: base }: ModelCacheLocation, key: string, needGlb: boolean): Promise<CachedBuild | undefined>;
+/** Stores a successful build; a failure to store never fails the build. */
+export declare function writeModelCache({ root, dir: base }: ModelCacheLocation, key: string, inputs: BuildInputs | readonly string[], result: unknown, glb?: string): Promise<boolean>;
+/** Removes temporary entries an interrupted run left behind. */
+export declare function sweepModelCache(base: string, now?: number): Promise<void>;
+//# sourceMappingURL=build-cache.d.ts.map