brepjs-sheetmetal 0.1.0

package/dist/contourFlangeFns.d.ts

@@ -0,0 +1,74 @@
+import { Result, Vec3, Solid } from 'brepjs';
+import { ContourFlangeSpec, FlatSide, ProfileSegment, SheetMetalPart } from './types.js';
+export interface SegmentFrame {
+    /** Origin of the −normal (bottom) surface at the start of this segment. */
+    origin: Vec3;
+    /** Outward run direction (the segment's local +X). */
+    run: Vec3;
+    /** Top-surface normal (+Z), n = bendAxis × run. */
+    n: Vec3;
+    /** Bend axis along the base edge (+Y), shared by every segment. */
+    axis: Vec3;
+}
+/**
+ * Author a contour flange: an OPEN 2D profile (alternating line/arc segments) swept
+ * along one straight edge of the base flat. Each arc is a cylindrical bend, each
+ * line a flat leg; consecutive segments chain frame-to-frame exactly as
+ * {@link authorPart} chains flanges, building one connected multi-bend cross-section
+ * (a return, a hat, a J). The recorded {@link ContourFlangeFeature} carries each
+ * segment's EXACT developed length (lines: `length`; arcs: the canonical
+ * {@link developedLength}) so the unfold lays the strip out straight with no error.
+ * Construction stays on the public, OCCT-WASM-safe API.
+ */
+export declare function authorContourFlange(part: SheetMetalPart, spec: ContourFlangeSpec): Result<SheetMetalPart>;
+export interface BuiltSegment {
+    solid: Solid;
+    frame: SegmentFrame;
+}
+export interface BuiltArc extends BuiltSegment {
+    axisOrigin: Vec3;
+}
+/**
+ * Add one straight leg of `legLength` extending from `frame.origin` along
+ * `frame.run`, full thickness along `frame.n`, across `span` along `frame.axis`.
+ * The next segment's frame starts at the leg's far end.
+ */
+export declare function buildLineLeg(base: Solid, frame: SegmentFrame, span: number, thickness: number, legLength: number): Result<BuiltSegment>;
+/**
+ * Add one cylindrical bend turning the running direction by `angleDeg`. Mirrors
+ * {@link authorPart}'s bend patch: a hollow tube (outer R+T, inner R) intersected
+ * with the fold wedge, in a canonical frame mapped onto the current segment frame.
+ * The returned frame's run/normal are rotated by the fold so the next leg continues
+ * tangentially.
+ */
+export declare function buildArcBend(base: Solid, frame: SegmentFrame, span: number, thickness: number, seg: Extract<ProfileSegment, {
+    kind: 'arc';
+}>): Result<BuiltArc>;
+export interface BaseEdge {
+    dir: Vec3;
+    out: Vec3;
+    start: Vec3;
+    length: number;
+}
+/** Resolve one of the four edges of the base flat (the contour-flange root). */
+export declare function baseEdge(part: SheetMetalPart, side: FlatSide): BaseEdge;
+/**
+ * Resolve one of the four edges of an arbitrary flat region (its world top-surface
+ * frame), the region-aware generalization of {@link baseEdge}: the base is the
+ * special case where `origin = 0`, `u = +X`, `v = +Y`, `n = +Z`. Used by hems and
+ * jogs to chain their profile off a named flange (or the base) edge.
+ */
+export declare function regionEdge(frame: {
+    origin: Vec3;
+    u: Vec3;
+    v: Vec3;
+    n: Vec3;
+    uLen: number;
+    vLen: number;
+}, side: FlatSide): BaseEdge;
+/**
+ * The starting {@link SegmentFrame} for a profile chained off `edge` at `offset`
+ * along it: contact at the edge, run pointing outward, normal = the region normal,
+ * bend axis along the edge. Shared by the contour-flange, hem and jog builders.
+ */
+export declare function initialSegmentFrame(edge: BaseEdge, n: Vec3, offset: number): SegmentFrame;

package/dist/cutoutFns.d.ts

@@ -0,0 +1,52 @@
+import { Result } from 'brepjs';
+import { CutoutSpec, SheetMetalPart } from './types.js';
+import { FlatFrame } from './authorFns.js';
+import { Frame2 } from './unfoldFns.js';
+type Pt2 = [number, number];
+/**
+ * Punch a cutout (hole / slot / polygon) through a named flat region's thickness.
+ * The 2D profile is built in the region's LOCAL frame, then placed onto the correct
+ * folded face via the region's world {@link FlatFrame} (origin/u/v/n) and extruded
+ * through the sheet, so a feature authored at local `(x, y)` lands on the matching
+ * face whether the region is the base or a folded flange. The same local profile is
+ * mapped through the region's developed {@link Frame2} and recorded as a
+ * {@link CutoutFeature}, so {@link unfold} emits the matching loop in the flat
+ * pattern and {@link fold} can replay it. Guards a valid, single-bodied solid.
+ */
+export declare function addCutout(part: SheetMetalPart, spec: CutoutSpec): Result<SheetMetalPart>;
+/** Punch a circular hole of `diameter` centred at region-local `(x, y)`. */
+export declare function addHole(part: SheetMetalPart, region: string, x: number, y: number, diameter: number): Result<SheetMetalPart>;
+/** Punch a slot centred at `(x, y)`: `length` along the slot axis by `width` across. */
+export declare function addSlot(part: SheetMetalPart, region: string, opts: {
+    x: number;
+    y: number;
+    length: number;
+    width: number;
+    angleDeg?: number;
+    round?: boolean;
+}): Result<SheetMetalPart>;
+/** Punch an arbitrary polygon cutout from its region-local `points` (≥ 3). */
+export declare function addPolygonCutout(part: SheetMetalPart, region: string, points: [number, number][]): Result<SheetMetalPart>;
+/** `'base'` is an alias for the base region; everything else passes through. */
+export declare function resolveRegionId(region: string): string;
+/**
+ * Resolve a region's world {@link FlatFrame} and developed {@link Frame2} in one
+ * shared feature-tree walk — the lookup tabs/forms need to place geometry on the
+ * correct folded face and emit the matching developed-plane loops. Mirrors the
+ * frame resolution {@link addCutout} performs inline.
+ */
+export declare function regionFrames(part: SheetMetalPart, region: string): Result<{
+    regionId: string;
+    world: FlatFrame;
+    dev: Frame2;
+}>;
+/** Developed-plane (u, v) extent of a region: base dims, or a flange frame's lengths. */
+export declare function regionDevExtent(part: SheetMetalPart, regionId: string, world: FlatFrame): Extent;
+/** Local-frame extent the cutout must fit within. */
+export interface Extent {
+    uMax: number;
+    vMax: number;
+}
+/** Map a region-local `(x, y)` into developed-plane coordinates via its {@link Frame2}. */
+export declare function mapToFrame2(p: Pt2, f: Frame2): Pt2;
+export {};

package/dist/dxfFns.d.ts

@@ -0,0 +1,38 @@
+import { Result } from 'brepjs';
+import { FlatPattern } from './types.js';
+export interface DxfOptions {
+    textHeight?: number | undefined;
+}
+type Pt2 = [number, number];
+/**
+ * A 2D point transform applied to every emitted vertex. Used by the nesting writer
+ * to place each pattern at its `(x, y)` and rotation on the sheet; the default
+ * single-pattern writer uses the identity transform.
+ */
+export type Transform2 = (p: Pt2) => Pt2;
+/**
+ * Package-local DXF writer for sheet-metal flat patterns. The core public writer
+ * (`blueprintToDXF`) is R12 LINE/POLYLINE-only with no MTEXT, layer color, or
+ * INSUNITS, so it cannot carry the annotated multi-layer output required here.
+ *
+ * Emits a strict AC1015 (R2000) DXF: `INSUNITS=4` (mm), the outline polyline on
+ * layer OUTLINE, each bend line on BEND_UP / BEND_DOWN, and an MTEXT
+ * angle/direction annotation (e.g. "∠90° U") at each bend-line midpoint. Every
+ * table record and entity carries a unique handle and the AcDb subclass markers
+ * R13+ readers (AutoCAD AUDIT, ODA/Teigha) require to parse the file cleanly.
+ */
+export declare function flatPatternToDXF(pattern: FlatPattern, options?: DxfOptions): Result<string>;
+/** One pattern plus the sheet-placement transform applied to all its geometry. */
+export interface PlacedPattern {
+    pattern: FlatPattern;
+    transform: Transform2;
+}
+/**
+ * Emit one DXF for any number of placed patterns (the nesting per-sheet writer).
+ * Each pattern's outline / bend lines / holes / forms are run through its own
+ * {@link Transform2} (translate + rotate onto the sheet) before being written, so
+ * the nested file is fabrication-ready. Layers/colors/handle scheme match the
+ * single-pattern writer exactly.
+ */
+export declare function multiPatternToDXF(placed: PlacedPattern[], options?: DxfOptions): Result<string>;
+export {};

package/dist/facade.d.ts

@@ -0,0 +1,175 @@
+import { BrepError, Solid } from 'brepjs';
+import { AuthorSpec, BaseFlatSpec, FlangeSpec, SeamSpec } from './authorFns.js';
+import { MiterPlane, DxfOptions, SlotPlacement } from './api.js';
+import { SheetMetalPart, FlatPattern, FlatInput, BendReport, MaterialSpec, ReliefSpec, CutoutSpec, TabSpec, ContourFlangeSpec, LoftedFlangeSpec, HemSpec, JogSpec, SheetMetalWarning, UnfoldResult } from './types.js';
+/** Thrown by the fluent facade when an underlying `Result<T>` is an `Err`. */
+export declare class SheetMetalError extends Error {
+    readonly code: string;
+    readonly kind: string;
+    constructor(brepError: BrepError);
+}
+/** A built part already mitered/operated on, re-entering the fluent chain. */
+declare class SheetMetalPartHandle {
+    readonly part: SheetMetalPart;
+    constructor(part: SheetMetalPart);
+    /** Cut by an oriented plane, removing material on the `+normal` side. */
+    miter(plane: MiterPlane): SheetMetalPartHandle;
+    /** Auto-miter the shared corner of two flanges with an optional gap. */
+    miterCorner(flangeIdA: string, flangeIdB: string, gap?: number): SheetMetalPartHandle;
+    /** Add a bend relief at each mid-edge end of a partial flange's bend line. */
+    bendRelief(flangeId: string, spec?: ReliefSpec): SheetMetalPartHandle;
+    /** Add a bend relief to every partial-span bend in the part. */
+    autoReliefs(spec?: ReliefSpec): SheetMetalPartHandle;
+    /** Cut a corner relief notch at the shared corner of two adjacent flanges. */
+    cornerRelief(flangeIdA: string, flangeIdB: string, spec?: ReliefSpec): SheetMetalPartHandle;
+    /** Punch a cutout (hole / slot / polygon) through a named flat region. */
+    cutout(spec: CutoutSpec): SheetMetalPartHandle;
+    /** Punch a circular hole of `diameter` centred at region-local `(x, y)`. */
+    hole(region: string, x: number, y: number, diameter: number): SheetMetalPartHandle;
+    /** Punch a slot (rectangular or obround) centred at region-local `(x, y)`. */
+    slot(region: string, opts: {
+        x: number;
+        y: number;
+        length: number;
+        width: number;
+        angleDeg?: number;
+        round?: boolean;
+    }): SheetMetalPartHandle;
+    /** Punch an arbitrary polygon cutout from its region-local `points`. */
+    polygonCutout(region: string, points: [number, number][]): SheetMetalPartHandle;
+    /** Fuse a rectangular tab (additive protrusion) onto a region's edge. */
+    tab(spec: TabSpec): SheetMetalPartHandle;
+    /** Self-fixturing tab-and-slot joint: a tab on one region + a matching slot on another. */
+    tabAndSlot(tab: TabSpec, slot: SlotPlacement): SheetMetalPartHandle;
+    /** Form a louver (vent flap) on a region. */
+    louver(opts: {
+        region: string;
+        x: number;
+        y: number;
+        length: number;
+        width: number;
+        height: number;
+        direction?: 'up' | 'down';
+    }): SheetMetalPartHandle;
+    /** Form a round emboss (raised) or dimple (recessed) on a region. */
+    emboss(opts: {
+        region: string;
+        x: number;
+        y: number;
+        diameter: number;
+        height: number;
+        kind: 'dimple' | 'emboss';
+    }): SheetMetalPartHandle;
+    /** Author a contour flange (open line/arc profile swept along a base edge). */
+    contourFlange(spec: ContourFlangeSpec): SheetMetalPartHandle;
+    /** Author a lofted / ruled transition flange between two parallel open profiles. */
+    loftedFlange(spec: LoftedFlangeSpec): SheetMetalPartHandle;
+    /** Fold a region edge back ~180°+ onto its parent as a hem (closed/open/teardrop/rolled). */
+    hem(spec: HemSpec): SheetMetalPartHandle;
+    /** Step a region's flat by `offsetHeight` with two opposite bends (a jog/joggle). */
+    jog(spec: JogSpec): SheetMetalPartHandle;
+    /** Flatten into a developed flat pattern + bend report + warnings. */
+    unfold(): UnfoldResult;
+    /** Just the flat pattern from the unfold. */
+    flatPattern(): FlatPattern;
+    /** Bend report built from the feature tree. */
+    report(): BendReport;
+    /** Annotated multi-layer DXF of the developed flat pattern. */
+    dxf(options?: DxfOptions): string;
+    /** Manufacturability warnings (advisory, never throws). */
+    validate(): SheetMetalWarning[];
+    /** The materialized part (escape hatch back to the functional API). */
+    get(): SheetMetalPart;
+}
+/**
+ * An imported foreign solid (no feature tree) re-entering the fluent chain: detect
+ * its geometry and unfold it. `kFactor` defaults to the mid-surface neutral axis.
+ */
+declare class ForeignSolidHandle {
+    private readonly solid;
+    private readonly opts?;
+    constructor(solid: Solid, opts?: {
+        kFactor?: number;
+    } | undefined);
+    /** Override the neutral-axis K-factor (default 0.5, the mid-surface). */
+    kFactor(kFactor: number): ForeignSolidHandle;
+    /** Detect geometry and flatten into a developed flat pattern + report + warnings. */
+    unfold(): UnfoldResult;
+    /** Just the flat pattern from the detected unfold. */
+    flatPattern(): FlatPattern;
+    /** Annotated multi-layer DXF of the developed flat pattern. */
+    dxf(options?: DxfOptions): string;
+}
+/** Authoring builder — accumulates the base/flanges/material spec, then folds. */
+declare class SheetMetalBuilder {
+    private readonly spec;
+    private built?;
+    constructor(spec: AuthorSpec);
+    /** Add a flange folded off its parent edge (the base by default). */
+    flange(flange: FlangeSpec): SheetMetalBuilder;
+    /** Add a seam closing a profile into a tube/box (left unfolded). */
+    seam(seam: SeamSpec): SheetMetalBuilder;
+    /** Set the part material (its thickness/default rule). */
+    material(material: MaterialSpec): SheetMetalBuilder;
+    /**
+     * Fold the accumulated spec into a 3D part, re-entering the fluent chain.
+     * Memoized so chaining multiple terminal shortcuts (e.g. `unfold()` then
+     * `report()`) authors the solid only once.
+     */
+    build(): SheetMetalPartHandle;
+    miter(plane: MiterPlane): SheetMetalPartHandle;
+    miterCorner(flangeIdA: string, flangeIdB: string, gap?: number): SheetMetalPartHandle;
+    bendRelief(flangeId: string, spec?: ReliefSpec): SheetMetalPartHandle;
+    autoReliefs(spec?: ReliefSpec): SheetMetalPartHandle;
+    cornerRelief(flangeIdA: string, flangeIdB: string, spec?: ReliefSpec): SheetMetalPartHandle;
+    cutout(spec: CutoutSpec): SheetMetalPartHandle;
+    hole(region: string, x: number, y: number, diameter: number): SheetMetalPartHandle;
+    slot(region: string, opts: {
+        x: number;
+        y: number;
+        length: number;
+        width: number;
+        angleDeg?: number;
+        round?: boolean;
+    }): SheetMetalPartHandle;
+    polygonCutout(region: string, points: [number, number][]): SheetMetalPartHandle;
+    tab(spec: TabSpec): SheetMetalPartHandle;
+    tabAndSlot(tab: TabSpec, slot: SlotPlacement): SheetMetalPartHandle;
+    louver(opts: {
+        region: string;
+        x: number;
+        y: number;
+        length: number;
+        width: number;
+        height: number;
+        direction?: 'up' | 'down';
+    }): SheetMetalPartHandle;
+    emboss(opts: {
+        region: string;
+        x: number;
+        y: number;
+        diameter: number;
+        height: number;
+        kind: 'dimple' | 'emboss';
+    }): SheetMetalPartHandle;
+    contourFlange(spec: ContourFlangeSpec): SheetMetalPartHandle;
+    loftedFlange(spec: LoftedFlangeSpec): SheetMetalPartHandle;
+    hem(spec: HemSpec): SheetMetalPartHandle;
+    jog(spec: JogSpec): SheetMetalPartHandle;
+    unfold(): UnfoldResult;
+    report(): BendReport;
+    dxf(options?: DxfOptions): string;
+    validate(): SheetMetalWarning[];
+    get(): SheetMetalPart;
+}
+/** Start a fluent sheet-metal chain from a base flat (`length × width`). */
+export declare function sheetMetal(base: BaseFlatSpec, thickness: number): SheetMetalBuilder;
+/** Re-enter the fluent chain from an already-authored part. */
+export declare function fromPart(part: SheetMetalPart): SheetMetalPartHandle;
+/** Fold a flat pattern up into a part and re-enter the fluent chain. */
+export declare function foldFlat(input: FlatInput): SheetMetalPartHandle;
+/** Detect and unfold an imported foreign sheet-metal solid (no feature tree). */
+export declare function fromSolid(solid: Solid, opts?: {
+    kFactor?: number;
+}): ForeignSolidHandle;
+export { SheetMetalBuilder, SheetMetalPartHandle, ForeignSolidHandle };

package/dist/featureTreeFns.d.ts

@@ -0,0 +1,55 @@
+import { Result } from 'brepjs';
+import { BendFeature, FlangeFeature, SheetMetalPart, SheetMetalWarning } from './types.js';
+export declare const ROOT_FLAT_ID = "root";
+/** A flat region in the feature graph (the part's base plus every flange face). */
+export interface FlatNode {
+    id: string;
+    isRoot: boolean;
+    flange?: FlangeFeature | undefined;
+}
+/** A bend connecting two flats. `parent`/`child` are flat ids; `bend` is the recorded feature. */
+export interface BendEdge {
+    bend: BendFeature;
+    parent: string;
+    child: string;
+}
+/** Graph view of an authored part: flats = nodes, bends = edges. */
+export interface FeatureGraph {
+    nodes: Map<string, FlatNode>;
+    edges: BendEdge[];
+}
+/** A bend that survives in the spanning tree, paired with its source/target flat. */
+export interface TreeBend {
+    bend: BendFeature;
+    parent: string;
+    child: string;
+}
+/** A non-tree edge that must be cut to flatten a closed profile. */
+export interface SeamCut {
+    bend: BendFeature;
+    between: [string, string];
+}
+export interface FeatureTree {
+    rootId: string;
+    /** Tree edges in breadth-first order (parents precede their children). */
+    bends: TreeBend[];
+    seams: SeamCut[];
+    nodes: Map<string, FlatNode>;
+    warnings: SheetMetalWarning[];
+}
+/**
+ * Build the feature graph for an authored part. Each flange contributes a flat
+ * node `flange.id`; bends connect a parent flat to a child flat. A bend whose id
+ * matches a flange id (the flange's own fold) is wired parent→flange; any other
+ * bend is matched to a flange by id suffix `<flange>::<n>` or defaults to a
+ * root-anchored edge so authored parts always produce a connected graph.
+ */
+export declare function buildFeatureGraph(part: SheetMetalPart): Result<FeatureGraph>;
+/**
+ * Spanning tree over the feature graph, rooted at the base flat. Tree edges are
+ * returned BFS-ordered (every parent appears before its children); edges that
+ * would close a cycle (box/closed profiles) become seam cuts with a warning.
+ */
+export declare function buildFeatureTree(graph: FeatureGraph, rootId?: string): Result<FeatureTree>;
+/** Convenience: graph + spanning tree in one call. */
+export declare function featureTree(part: SheetMetalPart, rootId?: string): Result<FeatureTree>;

package/dist/foldFns.d.ts

@@ -0,0 +1,68 @@
+import { Result } from 'brepjs';
+import { BendRule, FlatInput, FlatPattern, MaterialSpec, SheetMetalPart, SheetMetalWarning } from './types.js';
+/** A folded part plus the warnings raised while folding (e.g. SEAM_CUT, MIN_RADIUS). */
+export interface FoldResult {
+    part: SheetMetalPart;
+    warnings: SheetMetalWarning[];
+}
+/**
+ * Fold a flat pattern up into a 3D part. Each {@link FoldRegion} folds about its
+ * fold line off its parent region, exactly inverting {@link unfold}: folding by an
+ * angle is the same rigid construction the forward authoring path performs, so this
+ * reuses {@link authorPart}'s bend geometry wholesale rather than re-deriving it.
+ *
+ * The result carries a fully-populated {@link SheetMetalPart} (valid solid + the
+ * BendFeature/FlangeFeature tree consistent with `authorPart`), so
+ * `unfold(fold(input))` round-trips. SEAM_CUT-style and min-radius warnings ride
+ * inside the Ok payload.
+ */
+export declare function fold(input: FlatInput): Result<SheetMetalPart>;
+/** {@link fold} that also surfaces the fold warnings alongside the part. */
+export declare function foldWithWarnings(input: FlatInput): Result<FoldResult>;
+/** How to resolve the bend rule for a bend line read out of a 2D flat pattern. */
+export interface PatternToFlatInputOptions {
+    thickness: number;
+    /**
+     * Rule for bend line `i` (0-based, in {@link FlatPattern.bendLines} order). A flat
+     * pattern is pure geometry and cannot encode K-factor/inner-radius, so the rule is
+     * a required *input*; only the regions/sides/offsets/spans/lengths/angles are
+     * recovered from the 2D geometry.
+     */
+    ruleFor: (bendIndex: number) => BendRule;
+    material?: MaterialSpec | undefined;
+}
+/**
+ * Reconstruct a {@link FlatInput} region-tree from the *2D flat-pattern geometry*
+ * alone — `pattern.outline` (a closed 2D wire) and `pattern.bendLines` (each a 2D
+ * segment + fold angle/direction). Nothing is read from a feature tree or a 3D
+ * solid: the regions, sides, offsets, spans and flat lengths are all recovered by
+ * reading real 2D coordinates back out of the wire/edges via the public brepjs
+ * geometry readers (`getEdges`, `curveStartPoint`, `curveEndPoint`).
+ *
+ * This is the non-circular round-trip bridge: feeding `unfold(part).pattern` through
+ * here and into {@link fold} exercises unfold's 2D placement, this parser, and the
+ * forward fold geometry — a bug in any of them breaks the round-trip.
+ *
+ * Algorithm (rectilinear families — PR1 develops only axis-aligned rectangles):
+ * every bend line is an axis-aligned segment lying on the shared edge between a
+ * parent region and a child's developed strip. The developed strip width is
+ * `developedLength(angle, thickness, ruleFor(i))` (the supplied rule). BFS outward
+ * from the base region (the one anchored at the origin): a bend line on a known
+ * region's edge spawns a child region whose far edge is the next outward bend line
+ * (a grandchild) or the outline boundary; `length = far-extent − dev`, `span` =
+ * bend-line length, `offset`/`side` are the bend line's position on the parent edge.
+ */
+export declare function patternToFlatInput(pattern: FlatPattern, opts: PatternToFlatInputOptions): Result<FlatInput>;
+/**
+ * Convert an authored {@link SheetMetalPart} into the {@link FlatInput} that folds
+ * back into it, going strictly through the 2D flat pattern: `unfold(part)` produces
+ * the developed wire + bend lines, and {@link patternToFlatInput} recovers the
+ * region tree from that 2D geometry. Only the bend *rule* is read off the part (by
+ * matching bend id), which a flat pattern legitimately cannot encode; every
+ * geometric attribute is parsed from the wire/edges. This makes the round-trip
+ * oracle non-circular — a bug in unfold's 2D placement or in the parser breaks it.
+ *
+ * Seam bends (closed profiles) are left unfolded by `unfold`, so the recovered part
+ * is the open spanning-tree shape, not the re-closed box.
+ */
+export declare function partToFlatInput(part: SheetMetalPart): Result<FlatInput>;

package/dist/foreignUnfoldFns.d.ts

@@ -0,0 +1,54 @@
+import { Result, Vec3, Solid, Face } from 'brepjs';
+import { UnfoldResult } from './types.js';
+/** A fitted cylinder recovered numerically from a face's sampled points + normals. */
+export interface FittedCylinder {
+    /** A point on the axis line. */
+    axisOrigin: Vec3;
+    /** Unit axis direction. */
+    axisDir: Vec3;
+    /** Fitted radius (mean distance from the axis line to the sampled points). */
+    radius: number;
+    /** Angular extent swept by the face about the axis, in radians. */
+    angleSpan: number;
+    /** Max relative residual of the fit (fraction of radius); small for a true cylinder. */
+    residual: number;
+}
+/**
+ * Numerically fit a cylinder to a face.
+ *
+ * Every normal of a cylinder is perpendicular to the axis, so the axis direction
+ * is the common perpendicular of the sampled normals: it is recovered as the
+ * sign-aligned average of the cross products of pairs of non-parallel sampled
+ * normals (each such cross product lies along ±axis). The axis LINE and RADIUS
+ * are then found by projecting the sample points onto the plane ⟂ axis and
+ * fitting a circle (algebraic least squares); the radius is the mean distance
+ * from the axis line to the points. The angular span is the extent of the
+ * projected points about the fitted centre. Returns `null` when the surface
+ * does not fit a cylinder within {@link FIT_RESIDUAL_TOL}.
+ */
+export declare function fitCylinder(face: Face): FittedCylinder | null;
+/**
+ * Unfold an ARBITRARY imported sheet-metal solid with no feature tree, by
+ * detecting its geometry numerically. The supported class is roughly-uniform-
+ * thickness solids whose panels are planar and whose bends are cylindrical:
+ *
+ * 1. Classify faces by surface type — planar faces are panel faces, cylindrical
+ *    faces are bend faces. Any other surface type is reported `UNSUPPORTED_FACE`.
+ * 2. Pair the two large parallel planar faces of each flat panel (a thickness
+ *    apart); pair the inner/outer cylindrical faces of each bend and fit its
+ *    axis + inner radius + swept angle via {@link fitCylinder}.
+ * 3. Build a bend graph (flats = nodes; a bend connects the two flats it shares
+ *    edges with), take a spanning tree from a root flat, and turn any non-tree
+ *    bend into a seam cut (warned).
+ * 4. Walk the tree replacing each cylindrical bend region with a developed strip
+ *    of length `developedLength(angle, thickness, { innerRadius, kFactor })`
+ *    (`kFactor` defaults to the {@link DEFAULT_FOREIGN_K} mid-surface), laying
+ *    each flat out into the plane. Bend direction (up/down) is read from the
+ *    cylinder centre relative to the parent flat.
+ *
+ * Non-fatal warnings ride inside the Ok payload; the function fails only when the
+ * input is not a recognizable sheet-metal solid at all.
+ */
+export declare function unfoldForeignSolid(solid: Solid, opts?: {
+    kFactor?: number | undefined;
+}): Result<UnfoldResult>;

package/dist/formFns.d.ts

@@ -0,0 +1,43 @@
+import { Result } from 'brepjs';
+import { FormSpec, SheetMetalPart } from './types.js';
+/**
+ * Add a form feature (louver or emboss/dimple) to a named flat region.
+ *
+ * 3D FIDELITY (simplified, by design — the public CSG-only API makes true forming
+ * impractical):
+ * - LOUVER: the vent opening (`length × width`) is cut fully through the sheet, and
+ *   the formed flap is represented as a thin box hinged on one side and tilted up to
+ *   `height`, fused so it stays connected to the body at the hinge. True forming
+ *   keeps the flap continuous with the parent and bends it; the cut+tilted-flap
+ *   representation captures the vent geometry while keeping a single valid solid.
+ * - EMBOSS: a short cylinder fused onto the formed face (raised by `height`).
+ *   DIMPLE: a shallow cylindrical recess cut into the formed face (recessed by
+ *   `height`, never through). A true spherical/conical form is approximated by the
+ *   flat-topped round so the result stays a valid single body.
+ *
+ * FLAT PATTERN (the fabrication-critical representation): the louver emits its
+ * footprint as an OPEN three-side cut path (the fabricator cuts three of its four
+ * sides — all but the hinge) plus the hinge fold line; the emboss emits its footprint
+ * circle as a marker. Forming removes no net material, so the developed outline and
+ * area are unchanged. Guards a valid, single-bodied solid.
+ */
+export declare function addForm(part: SheetMetalPart, spec: FormSpec): Result<SheetMetalPart>;
+/** A louver vent on a region; see {@link addForm}. */
+export declare function louver(part: SheetMetalPart, opts: {
+    region: string;
+    x: number;
+    y: number;
+    length: number;
+    width: number;
+    height: number;
+    direction?: 'up' | 'down';
+}): Result<SheetMetalPart>;
+/** An emboss (raised) or dimple (recessed) round form on a region; see {@link addForm}. */
+export declare function emboss(part: SheetMetalPart, opts: {
+    region: string;
+    x: number;
+    y: number;
+    diameter: number;
+    height: number;
+    kind: 'dimple' | 'emboss';
+}): Result<SheetMetalPart>;

package/dist/hemFns.d.ts

@@ -0,0 +1,12 @@
+import { Result } from 'brepjs';
+import { HemSpec, SheetMetalPart } from './types.js';
+/**
+ * Author a hem: fold a region edge back ~180°+ onto its parent flat, then run a
+ * short return leg. Built on the contour-flange segment chainer — the curl is one
+ * or more ≤120° sub-arcs (each a recorded `hem::<id>::<n>` bend) followed by a flat
+ * return — so the development is EXACT: Σ curl bend allowances (via the table-aware
+ * {@link developedLength}) + the return length, laid out straight past the edge.
+ * Four `type`s set the curl/gap geometry (see {@link HemSpec}). Construction stays
+ * on the public, OCCT-WASM-safe API; the result is guarded to a valid single solid.
+ */
+export declare function hem(part: SheetMetalPart, spec: HemSpec): Result<SheetMetalPart>;

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+export { DEFAULT_K_FACTOR, STEEL_GAUGES, ALUMINUM_GAUGES, MATERIALS, getMaterial, } from './materials.js';
+export { bendAllowance, developedLength, neutralRadius } from './allowanceFns.js';
+export { registerBendTable, getBendTable, resolveBendAllowance } from './bendTableFns.js';
+export type { BendTable, BendTableRow } from './bendTableFns.js';
+export { ROOT_FLAT_ID, buildFeatureGraph, buildFeatureTree, featureTree, } from './featureTreeFns.js';
+export type { FlatNode, BendEdge, FeatureGraph, TreeBend, SeamCut, FeatureTree, } from './featureTreeFns.js';
+export { unfold } from './unfoldFns.js';
+export { unfoldForeignSolid, fitCylinder } from './foreignUnfoldFns.js';
+export type { FittedCylinder } from './foreignUnfoldFns.js';
+export { fold, foldWithWarnings, patternToFlatInput, partToFlatInput } from './foldFns.js';
+export type { FoldResult, PatternToFlatInputOptions } from './foldFns.js';
+export { authorPart, baseEdgeRef } from './authorFns.js';
+export type { AuthorSpec, BaseFlatSpec, FlangeSpec, FlangeSide, SeamSpec, } from './authorFns.js';
+export { miterCut, autoMiterCorner } from './miterFns.js';
+export type { MiterPlane } from './miterFns.js';
+export { addBendRelief, autoBendReliefs, cornerRelief } from './reliefFns.js';
+export { addCutout, addHole, addSlot, addPolygonCutout } from './cutoutFns.js';
+export { addTab, tabAndSlot } from './tabFns.js';
+export type { SlotPlacement } from './tabFns.js';
+export { addForm, louver, emboss } from './formFns.js';
+export { authorContourFlange } from './contourFlangeFns.js';
+export { authorLoftedFlange } from './loftedFlangeFns.js';
+export { hem } from './hemFns.js';
+export { jog } from './jogFns.js';
+export { flatPatternToDXF, multiPatternToDXF } from './dxfFns.js';
+export type { DxfOptions, PlacedPattern, Transform2 } from './dxfFns.js';
+export { patternBbox } from './nestFns.js';
+export type { NestOptions, NestResult, NestSheet, Placement, SheetSpec, Bbox, } from './nestFns.js';
+export { wireToPolygon, polygonsOverlap, polygonsOverlapWithClearance, segmentsIntersect, pointInPolygon, transformPolygon, polygonBounds, signedArea, } from './polygonFns.js';
+export type { Polygon, Pt2 } from './polygonFns.js';
+export { buildReport, reportFromUnfold, reportToJSON } from './reportFns.js';
+export { validatePart } from './validateFns.js';
+export { author, unfold as unfoldPart, unfoldSolid, fold as foldPart, miter, miterCorner, bendRelief, autoReliefs, relieveCorner, toDXF, report, reportFrom, reportJSON, validate, allowance, developed, addBendTable, bendTable, resolveAllowance, contourFlange, loftedFlange, nest, nestToDXF, } from './api.js';
+export { sheetMetal, fromPart, foldFlat, fromSolid, SheetMetalError, SheetMetalBuilder, SheetMetalPartHandle, ForeignSolidHandle, } from './facade.js';
+export type { EdgeRef, FlatSide, BendRule, MaterialSpec, MiterSpec, BendFeature, FlangeFeature, CornerMiter, ReliefSpec, ReliefFeature, CutoutSpec, CutoutFeature, TabSpec, TabFeature, FormSpec, FormFeature, ProfileSegment, ContourFlangeSpec, ContourFlangeFeature, LoftedFlangeSpec, LoftedFlangeFeature, HemSpec, HemFeature, JogSpec, JogFeature, SheetMetalPart, FlatPattern, FlatInput, FoldRegion, BendReport, SheetMetalWarning, UnfoldResult, } from './types.js';

package/dist/internal.d.ts

@@ -0,0 +1,17 @@
+import { Solid, Vec3 } from 'brepjs';
+import { FlatSide } from './types.js';
+/**
+ * OCCT boolean fuse returns a compound wrapping the unioned solid. Extract the
+ * single solid so a part's cached shape is a true `Solid` (clean STEP/GLB
+ * export); fall back to the compound if the union produced multiple bodies.
+ */
+export declare function normalizeSolid(shape: Solid): Solid;
+/**
+ * Fallback develop side for a hand-built flange whose `baseEdge.side` is omitted:
+ * derive it from the recorded bend axis. An axis along +Y (|axisDir.y|>0.5) is an
+ * east flange that develops in +X (`xmax`); an axis along +X is a north flange
+ * developing in +Y (`ymax`). This preserves the original axis-only unfold
+ * heuristic for external fixtures predating the explicit `side` field; parts from
+ * {@link authorPart} always set `side`, so this only kicks in for the legacy path.
+ */
+export declare function sideFromAxisDir(axisDir: Vec3): FlatSide | undefined;

package/dist/jogFns.d.ts

@@ -0,0 +1,13 @@
+import { Result } from 'brepjs';
+import { JogSpec, SheetMetalPart } from './types.js';
+/**
+ * Author a jog (joggle): two opposite bends (`+θ` then `−θ`) that step a flat by
+ * `offsetHeight` perpendicular to its plane, then continue parallel past the step.
+ * Built on the contour-flange chainer: a flat position leg, a `+θ` up bend
+ * (`jog::<id>::0`), the connecting step run, a `−θ` down bend (`jog::<id>::1`), and
+ * a flat run-out leg. The development is EXACT (Σ legs + Σ bend allowances, via the
+ * table-aware {@link developedLength}). The connecting step run is
+ * `offsetHeight / sin(θ)` so the two bends realize the requested perpendicular step;
+ * the result is guarded to a valid single solid. OCCT-WASM-safe construction only.
+ */
+export declare function jog(part: SheetMetalPart, spec: JogSpec): Result<SheetMetalPart>;