@faicad/faijs 0.18.3 → 0.22.2

package/dist/geometry2d/blueprints.js

@@ -0,0 +1,72 @@
+import { centerOf, createBBox2d, mergeBBox } from './bbox2d.js';
+/**
+ * Blueprints — collection of disjoint 2D profiles.
+ * Typical result of boolean operations producing multiple independent regions.
+ */
+export class Blueprints {
+    /** The independent profiles in this collection. */
+    blueprints;
+    _bbox = null;
+    constructor(blueprints) {
+        this.blueprints = blueprints;
+    }
+    /**
+     * Return a copy of this collection.
+     * @returns a new Blueprints whose profiles are clones of the originals.
+     */
+    clone() {
+        return new Blueprints(this.blueprints.map((b) => b.clone()));
+    }
+    /**
+     * Bounding box (cached). The box spanning all contained profiles.
+     * @returns a BBox2d enclosing every profile in this collection.
+     */
+    get boundingBox() {
+        if (!this._bbox) {
+            const bb = createBBox2d();
+            for (const b of this.blueprints)
+                mergeBBox(bb, b.boundingBox);
+            this._bbox = bb;
+        }
+        return this._bbox;
+    }
+    /**
+     * Scale every profile about a center point.
+     * @param factor - the scale factor to apply.
+     * @param center - the scaling center `[x, y]` (defaults to the bounding-box center).
+     * @returns a new Blueprints with every profile scaled.
+     */
+    scale(factor, center) {
+        const ctr = center ?? centerOf(this.boundingBox);
+        return new Blueprints(this.blueprints.map((b) => b.scale(factor, ctr)));
+    }
+    /**
+     * Translate every profile by a delta.
+     * @param dxOrPoint - the x delta, or a full `[dx, dy]` offset point.
+     * @param dy - the y delta (default 0, ignored when `dxOrPoint` is a point).
+     * @returns a new Blueprints with every profile translated.
+     */
+    translate(dxOrPoint, dy) {
+        return new Blueprints(this.blueprints.map((b) => b.translate(dxOrPoint, dy ?? 0)));
+    }
+    /**
+     * Rotate every profile about a center point.
+     * @param angleDeg - the rotation angle in degrees.
+     * @param center - the rotation center `[x, y]` (defaults to the origin).
+     * @returns a new Blueprints with every profile rotated.
+     */
+    rotate(angleDeg, center) {
+        return new Blueprints(this.blueprints.map((b) => b.rotate(angleDeg, center)));
+    }
+    /**
+     * Mirror every profile.
+     * @param centerOrDirection - the mirror center (mode `center`) or the mirror axis direction.
+     * @param origin - the axis origin `[x, y]` when mirroring across a plane (defaults to the origin).
+     * @param mode - `center` mirrors about a point; `plane` mirrors across an axis.
+     * @returns a new Blueprints with every profile mirrored.
+     */
+    mirror(centerOrDirection, origin, mode = 'center') {
+        return new Blueprints(this.blueprints.map((b) => b.mirror(centerOrDirection, origin, mode)));
+    }
+}
+//# sourceMappingURL=blueprints.js.map

package/dist/geometry2d/blueprints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blueprints.js","sourceRoot":"","sources":["../../src/geometry2d/blueprints.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,SAAS,EAAe,MAAM,UAAU,CAAA;AAEzE;;;GAGG;AACH,MAAM,OAAO,UAAU;IACrB,mDAAmD;IAC1C,UAAU,CAAsC;IAEjD,KAAK,GAAkB,IAAI,CAAA;IAEnC,YAAY,UAAgD;QAC1D,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;IAC9B,CAAC;IAED;;;OAGG;IACH,KAAK;QACH,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;IAC9D,CAAC;IAED;;;OAGG;IACH,IAAI,WAAW;QACb,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;YAChB,MAAM,EAAE,GAAG,YAAY,EAAE,CAAA;YACzB,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,UAAU;gBAAE,SAAS,CAAC,EAAE,EAAE,CAAC,CAAC,WAAW,CAAC,CAAA;YAC7D,IAAI,CAAC,KAAK,GAAG,EAAE,CAAA;QACjB,CAAC;QACD,OAAO,IAAI,CAAC,KAAK,CAAA;IACnB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,MAAc,EAAE,MAAe;QACnC,MAAM,GAAG,GAAG,MAAM,IAAI,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAA;QAChD,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAA;IACzE,CAAC;IAED;;;;;OAKG;IACH,SAAS,CAAC,SAA0B,EAAE,EAAW;QAC/C,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,SAAS,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;IACpF,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,QAAgB,EAAE,MAAe;QACtC,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,CAAA;IAC/E,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,iBAAyB,EAAE,MAAe,EAAE,OAA2B,QAAQ;QACpF,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,iBAAiB,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAAA;IAC9F,CAAC;CACF","sourcesContent":["/**\n * Blueprints — collection of disjoint 2D profiles (pure-data port of brepjs,\n * Apache-2.0). Typical result of boolean operations producing multiple regions.\n * @module\n */\nimport { Blueprint, type Point2 } from './blueprint'\nimport { CompoundBlueprint } from './compound-blueprint'\nimport { centerOf, createBBox2d, mergeBBox, type BBox2d } from './bbox2d'\n\n/**\n * Blueprints — collection of disjoint 2D profiles.\n * Typical result of boolean operations producing multiple independent regions.\n */\nexport class Blueprints {\n  /** The independent profiles in this collection. */\n  readonly blueprints: Array<Blueprint | CompoundBlueprint>\n\n  private _bbox: BBox2d | null = null\n\n  constructor(blueprints: Array<Blueprint | CompoundBlueprint>) {\n    this.blueprints = blueprints\n  }\n\n  /**\n   * Return a copy of this collection.\n   * @returns a new Blueprints whose profiles are clones of the originals.\n   */\n  clone(): Blueprints {\n    return new Blueprints(this.blueprints.map((b) => b.clone()))\n  }\n\n  /**\n   * Bounding box (cached). The box spanning all contained profiles.\n   * @returns a BBox2d enclosing every profile in this collection.\n   */\n  get boundingBox(): BBox2d {\n    if (!this._bbox) {\n      const bb = createBBox2d()\n      for (const b of this.blueprints) mergeBBox(bb, b.boundingBox)\n      this._bbox = bb\n    }\n    return this._bbox\n  }\n\n  /**\n   * Scale every profile about a center point.\n   * @param factor - the scale factor to apply.\n   * @param center - the scaling center `[x, y]` (defaults to the bounding-box center).\n   * @returns a new Blueprints with every profile scaled.\n   */\n  scale(factor: number, center?: Point2): Blueprints {\n    const ctr = center ?? centerOf(this.boundingBox)\n    return new Blueprints(this.blueprints.map((b) => b.scale(factor, ctr)))\n  }\n\n  /**\n   * Translate every profile by a delta.\n   * @param dxOrPoint - the x delta, or a full `[dx, dy]` offset point.\n   * @param dy - the y delta (default 0, ignored when `dxOrPoint` is a point).\n   * @returns a new Blueprints with every profile translated.\n   */\n  translate(dxOrPoint: number | Point2, dy?: number): Blueprints {\n    return new Blueprints(this.blueprints.map((b) => b.translate(dxOrPoint, dy ?? 0)))\n  }\n\n  /**\n   * Rotate every profile about a center point.\n   * @param angleDeg - the rotation angle in degrees.\n   * @param center - the rotation center `[x, y]` (defaults to the origin).\n   * @returns a new Blueprints with every profile rotated.\n   */\n  rotate(angleDeg: number, center?: Point2): Blueprints {\n    return new Blueprints(this.blueprints.map((b) => b.rotate(angleDeg, center)))\n  }\n\n  /**\n   * Mirror every profile.\n   * @param centerOrDirection - the mirror center (mode `center`) or the mirror axis direction.\n   * @param origin - the axis origin `[x, y]` when mirroring across a plane (defaults to the origin).\n   * @param mode - `center` mirrors about a point; `plane` mirrors across an axis.\n   * @returns a new Blueprints with every profile mirrored.\n   */\n  mirror(centerOrDirection: Point2, origin?: Point2, mode: 'center' | 'plane' = 'center'): Blueprints {\n    return new Blueprints(this.blueprints.map((b) => b.mirror(centerOrDirection, origin, mode)))\n  }\n}"]}

package/dist/geometry2d/bridge/lift-on-plane.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 2D curve → 3D plane placement primitives (E2, occt-only bridge layer).
+ *
+ * This is the "lift" half of `sketchOnPlane`: it maps a pure-2D `Curve2dObj[]`
+ * (or `Blueprint`) onto an arbitrary plane and assembles the resulting 3D edges
+ * into a wire. `curvesAsEdgesOnPlane` / `assembleWire` mirror the plan's E2 work
+ * items. The kernel edge/wire primitives are accepted as `Pick<BrepEngineApi, …>`
+ * (the bridge may import the kernel contract, only `api/` is off-limits) so
+ * callers pass `getBrepApi()` directly with no casts.
+ * @module
+ */
+import type { BrepEngineApi } from '../../brep/engine/primitives.js';
+import type { BrepHandle } from '../../brep/engine/types.js';
+import type { Curve2dObj } from '../curve2d.js';
+import type { Blueprint } from '../blueprint.js';
+import { type Plane } from './plane.js';
+/** Minimal kernel edge/wire surface needed for planar placement. */
+export type PlaneWireKernel = Pick<BrepEngineApi, 'makeLineEdge' | 'makeArcEdge' | 'makeBezierEdge' | 'makeWire'>;
+/**
+ * Build the 3D edge(s) for a single 2D curve lifted onto a plane. Line and
+ * bezier build exact analytic edges; circle / trimmed-circle build a true arc
+ * edge from three on-plane lift points (a full circle is split into two arcs to
+ * keep `makeArcEdge` well-formed); ellipse / bspline fall back to a dense
+ * sampled polyline.
+ * @param kernel - the kernel edge primitives.
+ * @param plane - the target plane frame.
+ * @param c - the ordered 2D curve to lift.
+ * @returns the lifted 3D edge handle(s), in curve order.
+ */
+export declare function liftCurve2dToPlane(kernel: PlaneWireKernel, plane: Plane, c: Curve2dObj): BrepHandle[];
+/**
+ * Lift an ordered list of 2D curves to edges on a plane frame.
+ * @param kernel - the kernel edge/wire primitives.
+ * @param plane - the target plane.
+ * @param curves - the ordered 2D curves (a closed loop stays closed).
+ * @returns the lifted 3D edge handles in the same order.
+ */
+export declare function curvesAsEdgesOnPlane(kernel: PlaneWireKernel, plane: Plane, curves: readonly Curve2dObj[]): BrepHandle[];
+/**
+ * Assemble a Blueprint's curves into a 3D wire on a plane — the shared placement
+ * step for all of the profile / draw / sketch sources.
+ * @param kernel - the curve kernel/wire primitives.
+ * @param planeOrName - a plane frame or a named plane string (`'XY'` / `'XZ'` / …).
+ * @param bp - the blueprint whose ordered curves become the wire.
+ * @returns the assembled 3D wire.
+ */
+export declare function assembleWire(kernel: PlaneWireKernel, planeOrName: Plane | string, bp: Blueprint): BrepHandle;
+export { liftPointToPlane, namedPlane, makePlane, toVec3 } from './plane.js';
+export type { Plane, Vec3, Vec3Input } from './plane.js';
+//# sourceMappingURL=lift-on-plane.d.ts.map

package/dist/geometry2d/bridge/lift-on-plane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lift-on-plane.d.ts","sourceRoot":"","sources":["../../../src/geometry2d/bridge/lift-on-plane.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AACjE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAgC,KAAK,KAAK,EAAa,MAAM,SAAS,CAAA;AAE7E,oEAAoE;AACpE,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,aAAa,EAAE,cAAc,GAAG,aAAa,GAAG,gBAAgB,GAAG,UAAU,CAAC,CAAA;AAEjH;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,eAAe,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,GAAG,UAAU,EAAE,CA4BrG;AAaD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,eAAe,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,UAAU,EAAE,GAAG,UAAU,EAAE,CAIvH;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,EAAE,WAAW,EAAE,KAAK,GAAG,MAAM,EAAE,EAAE,EAAE,SAAS,GAAG,UAAU,CAG5G;AAED,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AACzE,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA"}

package/dist/geometry2d/bridge/lift-on-plane.js

@@ -0,0 +1,78 @@
+import { evaluateCurve2d } from '../curve2d.js';
+import { namedPlane, liftPointToPlane } from './plane.js';
+/**
+ * Build the 3D edge(s) for a single 2D curve lifted onto a plane. Line and
+ * bezier build exact analytic edges; circle / trimmed-circle build a true arc
+ * edge from three on-plane lift points (a full circle is split into two arcs to
+ * keep `makeArcEdge` well-formed); ellipse / bspline fall back to a dense
+ * sampled polyline.
+ * @param kernel - the kernel edge primitives.
+ * @param plane - the target plane frame.
+ * @param c - the ordered 2D curve to lift.
+ * @returns the lifted 3D edge handle(s), in curve order.
+ */
+export function liftCurve2dToPlane(kernel, plane, c) {
+    const on = (c2, t) => liftPointToPlane(plane, ...evaluateCurve2d(c2, t));
+    switch (c.kind2d) {
+        case 'line':
+            // P2 (2026-09-28, ArchDetail class): a fully-trimmed sketch can carry a
+            // ZERO-LENGTH line; makeLineEdge(start, start) is rejected by the OCCT
+            // kernel and killed the whole sketchOnPlane call. A zero-length segment
+            // contributes nothing to the wire — skip it.
+            if (c.len === 0)
+                return [];
+            return [
+                kernel.makeLineEdge(liftPointToPlane(plane, c.ox, c.oy), liftPointToPlane(plane, c.ox + c.dx * c.len, c.oy + c.dy * c.len)),
+            ];
+        case 'bezier':
+            return [kernel.makeBezierEdge(c.poles.map(([x, y]) => liftPointToPlane(plane, x, y)))];
+        case 'circle':
+            return [
+                kernel.makeArcEdge(on(c, 0), on(c, Math.PI / 2), on(c, Math.PI)),
+                kernel.makeArcEdge(on(c, Math.PI), on(c, (3 * Math.PI) / 2), on(c, 2 * Math.PI)),
+            ];
+        case 'trimmed':
+            if (c.basis.kind2d === 'circle')
+                return [kernel.makeArcEdge(on(c, 0), on(c, 0.5), on(c, 1))];
+            return sampledEdges(kernel, plane, c);
+        default:
+            return sampledEdges(kernel, plane, c);
+    }
+}
+/** Sample a non-analytic curve into a polyline of `makeLineEdge`s on the plane. */
+function sampledEdges(kernel, plane, c) {
+    const out = [];
+    for (let k = 0; k < 32; k++) {
+        const t0 = k / 32;
+        const t1 = (k + 1) / 32;
+        out.push(kernel.makeLineEdge(liftPointToPlane(plane, ...evaluateCurve2d(c, t0)), liftPointToPlane(plane, ...evaluateCurve2d(c, t1))));
+    }
+    return out;
+}
+/**
+ * Lift an ordered list of 2D curves to edges on a plane frame.
+ * @param kernel - the kernel edge/wire primitives.
+ * @param plane - the target plane.
+ * @param curves - the ordered 2D curves (a closed loop stays closed).
+ * @returns the lifted 3D edge handles in the same order.
+ */
+export function curvesAsEdgesOnPlane(kernel, plane, curves) {
+    const out = [];
+    for (const c of curves)
+        out.push(...liftCurve2dToPlane(kernel, plane, c));
+    return out;
+}
+/**
+ * Assemble a Blueprint's curves into a 3D wire on a plane — the shared placement
+ * step for all of the profile / draw / sketch sources.
+ * @param kernel - the curve kernel/wire primitives.
+ * @param planeOrName - a plane frame or a named plane string (`'XY'` / `'XZ'` / …).
+ * @param bp - the blueprint whose ordered curves become the wire.
+ * @returns the assembled 3D wire.
+ */
+export function assembleWire(kernel, planeOrName, bp) {
+    const plane = typeof planeOrName === 'string' ? namedPlane(planeOrName) : planeOrName;
+    return kernel.makeWire(curvesAsEdgesOnPlane(kernel, plane, bp.curves));
+}
+export { liftPointToPlane, namedPlane, makePlane, toVec3 } from './plane.js';
+//# sourceMappingURL=lift-on-plane.js.map

package/dist/geometry2d/bridge/lift-on-plane.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lift-on-plane.js","sourceRoot":"","sources":["../../../src/geometry2d/bridge/lift-on-plane.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * 2D curve → 3D plane placement primitives (E2, occt-only bridge layer).\n *\n * This is the \"lift\" half of `sketchOnPlane`: it maps a pure-2D `Curve2dObj[]`\n * (or `Blueprint`) onto an arbitrary plane and assembles the resulting 3D edges\n * into a wire. `curvesAsEdgesOnPlane` / `assembleWire` mirror the plan's E2 work\n * items. The kernel edge/wire primitives are accepted as `Pick<BrepEngineApi, …>`\n * (the bridge may import the kernel contract, only `api/` is off-limits) so\n * callers pass `getBrepApi()` directly with no casts.\n * @module\n */\nimport type { BrepEngineApi } from '../../brep/engine/primitives'\nimport type { BrepHandle } from '../../brep/engine/types'\nimport type { Curve2dObj } from '../curve2d'\nimport { evaluateCurve2d } from '../curve2d'\nimport type { Blueprint } from '../blueprint'\nimport { namedPlane, liftPointToPlane, type Plane, type Vec3 } from './plane'\n\n/** Minimal kernel edge/wire surface needed for planar placement. */\nexport type PlaneWireKernel = Pick<BrepEngineApi, 'makeLineEdge' | 'makeArcEdge' | 'makeBezierEdge' | 'makeWire'>\n\n/**\n * Build the 3D edge(s) for a single 2D curve lifted onto a plane. Line and\n * bezier build exact analytic edges; circle / trimmed-circle build a true arc\n * edge from three on-plane lift points (a full circle is split into two arcs to\n * keep `makeArcEdge` well-formed); ellipse / bspline fall back to a dense\n * sampled polyline.\n * @param kernel - the kernel edge primitives.\n * @param plane - the target plane frame.\n * @param c - the ordered 2D curve to lift.\n * @returns the lifted 3D edge handle(s), in curve order.\n */\nexport function liftCurve2dToPlane(kernel: PlaneWireKernel, plane: Plane, c: Curve2dObj): BrepHandle[] {\n  const on = (c2: Curve2dObj, t: number): Vec3 => liftPointToPlane(plane, ...evaluateCurve2d(c2, t))\n  switch (c.kind2d) {\n    case 'line':\n      // P2 (2026-09-28, ArchDetail class): a fully-trimmed sketch can carry a\n      // ZERO-LENGTH line; makeLineEdge(start, start) is rejected by the OCCT\n      // kernel and killed the whole sketchOnPlane call. A zero-length segment\n      // contributes nothing to the wire — skip it.\n      if (c.len === 0) return []\n      return [\n        kernel.makeLineEdge(\n          liftPointToPlane(plane, c.ox, c.oy),\n          liftPointToPlane(plane, c.ox + c.dx * c.len, c.oy + c.dy * c.len),\n        ),\n      ]\n    case 'bezier':\n      return [kernel.makeBezierEdge(c.poles.map(([x, y]) => liftPointToPlane(plane, x, y)))]\n    case 'circle':\n      return [\n        kernel.makeArcEdge(on(c, 0), on(c, Math.PI / 2), on(c, Math.PI)),\n        kernel.makeArcEdge(on(c, Math.PI), on(c, (3 * Math.PI) / 2), on(c, 2 * Math.PI)),\n      ]\n    case 'trimmed':\n      if (c.basis.kind2d === 'circle') return [kernel.makeArcEdge(on(c, 0), on(c, 0.5), on(c, 1))]\n      return sampledEdges(kernel, plane, c)\n    default:\n      return sampledEdges(kernel, plane, c)\n  }\n}\n\n/** Sample a non-analytic curve into a polyline of `makeLineEdge`s on the plane. */\nfunction sampledEdges(kernel: PlaneWireKernel, plane: Plane, c: Curve2dObj): BrepHandle[] {\n  const out: BrepHandle[] = []\n  for (let k = 0; k < 32; k++) {\n    const t0 = k / 32\n    const t1 = (k + 1) / 32\n    out.push(kernel.makeLineEdge(liftPointToPlane(plane, ...evaluateCurve2d(c, t0)), liftPointToPlane(plane, ...evaluateCurve2d(c, t1))))\n  }\n  return out\n}\n\n/**\n * Lift an ordered list of 2D curves to edges on a plane frame.\n * @param kernel - the kernel edge/wire primitives.\n * @param plane - the target plane.\n * @param curves - the ordered 2D curves (a closed loop stays closed).\n * @returns the lifted 3D edge handles in the same order.\n */\nexport function curvesAsEdgesOnPlane(kernel: PlaneWireKernel, plane: Plane, curves: readonly Curve2dObj[]): BrepHandle[] {\n  const out: BrepHandle[] = []\n  for (const c of curves) out.push(...liftCurve2dToPlane(kernel, plane, c))\n  return out\n}\n\n/**\n * Assemble a Blueprint's curves into a 3D wire on a plane — the shared placement\n * step for all of the profile / draw / sketch sources.\n * @param kernel - the curve kernel/wire primitives.\n * @param planeOrName - a plane frame or a named plane string (`'XY'` / `'XZ'` / …).\n * @param bp - the blueprint whose ordered curves become the wire.\n * @returns the assembled 3D wire.\n */\nexport function assembleWire(kernel: PlaneWireKernel, planeOrName: Plane | string, bp: Blueprint): BrepHandle {\n  const plane = typeof planeOrName === 'string' ? namedPlane(planeOrName) : planeOrName\n  return kernel.makeWire(curvesAsEdgesOnPlane(kernel, plane, bp.curves))\n}\n\nexport { liftPointToPlane, namedPlane, makePlane, toVec3 } from './plane'\nexport type { Plane, Vec3, Vec3Input } from './plane'"]}

package/dist/geometry2d/bridge/on-surface.d.ts

@@ -0,0 +1,98 @@
+/**
+ * 2D curve → face UV-surface placement primitives (E3, occt-only bridge layer).
+ *
+ * This is the "on-surface" half of `sketchOnFace`: it places a pure-2D
+ * `Curve2dObj[]` contour onto the UV parameter domain of an existing face and
+ * assembles 3D edges living on that surface. Unlike `liftCurve2dToPlane` (which
+ * maps 2D onto a plane *frame*), `buildEdgeOnSurface` samples each 2D curve,
+ * maps the samples into the face's UV space under a scale mode, evaluates the
+ * surface at those UVs via `pointOnSurface(face,u,v)`, and interpolates a
+ * B-spline edge through the resulting 3D points — the plan's §164 composite
+ * approach (engine-method-map marks `buildEdgeOnSurface` as "occt 适配器组合实现").
+ * It is surface-type-independent (plane / cylinder / any parametric surface).
+ *
+ * The three scale modes (plan §164):
+ *   - `original`: `u=x, v=y` — reads 2D coordinates as face UVs directly.
+ *   - `bounds` / `native`: affine-fit the 2D contour's bounding box onto the
+ *     face's UV bounds, ratio-preserving — the generic mode for any face.
+ *
+ * The UV-mapping functions are pure and the bridge takes an injected
+ * `Pick<BrepEngineApi, …>` kernel plus the target face handle, so the math is
+ * unit-testable with a recording kernel exactly like `lift-on-plane.ts` (no
+ * occt-wasm needed). The bridge imports the kernel contract and `geometry2d`
+ * only — `api/` is off-limits.
+ *
+ * @module
+ */
+import type { BrepEngineApi } from '../../brep/engine/primitives.js';
+import type { BrepUvBounds, BrepHandle } from '../../brep/engine/types.js';
+import type { Curve2dObj } from '../curve2d.js';
+import type { Blueprint } from '../blueprint.js';
+/** How a 2D contour's coordinates map onto a face's UV space (`cad.sketchOnFace`). */
+export type FaceScaleMode = 'original' | 'bounds' | 'native';
+/** An axis-aligned 2D box (the contour's coordinate span). */
+export interface Rect2d {
+    x0: number;
+    x1: number;
+    y0: number;
+    y1: number;
+}
+/** A 3D surface point (the `pointOnSurface` result). */
+export interface SurfacePoint {
+    x: number;
+    y: number;
+    z: number;
+}
+/** `(x,y)` → `(u,v)` face parameter-space mapping (pure). */
+export type UvMap = (x: number, y: number) => [number, number];
+/** Kernel surface needed for curve-on-face placement (wider than the plane-lift Pick). */
+export type SurfaceEdgesKernel = Pick<BrepEngineApi, 'pointOnSurface' | 'uvBounds' | 'interpolatePoints' | 'makeLineEdge' | 'makeWire'>;
+/** BrepVec3 element type handed to `interpolatePoints` / returned by `pointOnSurface`. */
+export type SurfaceVec3 = SurfacePoint;
+/**
+ * Sample the tight axis-aligned 2D bounding box of an ordered curve set, used
+ * to affine-fit a contour onto a face's UV bounds under `bounds`/`native`.
+ * @param curves - the ordered 2D curves of a single contour.
+ * @returns the sampled bounding rect; an empty set becomes the origin rect.
+ */
+export declare function curves2dBounds(curves: readonly Curve2dObj[]): Rect2d;
+/**
+ * Build a `(x,y)` → `(u,v)` mapping for a scale mode against a face's UV bounds.
+ * `original` returns the identity (2D coords are read as UVs). `bounds`/`native`
+ * affine-scale the contour's 2D box onto the full UV bounds, preserving aspect.
+ * @param mode - the face-scale mode.
+ * @param rect - the 2D bounding box of the contour (sampled; ignored by `original`).
+ * @param bounds - the face UV bounds from `uvBounds`.
+ * @returns an `(x,y)` → `(u,v)` function (pure; assertable in unit tests).
+ */
+export declare function makeUvMap(mode: FaceScaleMode, rect: Rect2d, bounds: BrepUvBounds): UvMap;
+/**
+ * Build the 3D edge for a single 2D curve laid on a face: sample the curve, map
+ * samples to UV under the given mapping, evaluate the face surface there, and
+ * interpolate a curve edge through the resulting 3D points. A curve that
+ * evaluates to 2 or fewer distinct points is emitted as an exact `makeLineEdge`
+ * (the planar fast path).
+ * @param kernel - the surface kernel (`pointOnSurface` + `interpolatePoints`).
+ * @param face - the target face handle (for `pointOnSurface(face,u,v)`).
+ * @param uv - the UV mapping for this curve (see `makeUvMap`).
+ * @param c - the ordered 2D curve to place on the face.
+ * @param samples - the sample count per curve (>= 3 for smooth edges).
+ * @returns the placed 3D edge handle (one per curve).
+ */
+export declare function buildEdgeOnSurface(kernel: Pick<SurfaceEdgesKernel, 'pointOnSurface' | 'interpolatePoints' | 'makeLineEdge'>, face: BrepHandle, uv: UvMap, c: Curve2dObj, samples?: number): BrepHandle;
+/**
+ * Place every curve of a contour onto a face's UV space and assemble a wire.
+ * Computes the face UV bounds and the contour's 2D box, derives the UV map for
+ * the chosen scale mode, and buildings edges + a `makeWire` on the surface.
+ * @param kernel - the surface kernel.
+ * @param face - the target face handle.
+ * @param mode - the face-scale mode (`original`/`bounds`/`native`).
+ * @param bp - the blueprint whose ordered curves become on-face edges.
+ * @param samples - samples per curve (default 12).
+ * @returns `{ wire, uv }`: the assembled 3D wire and the UV map used.
+ */
+export declare function assembleWireOnFace(kernel: Pick<SurfaceEdgesKernel, 'pointOnSurface' | 'uvBounds' | 'interpolatePoints' | 'makeLineEdge' | 'makeWire'>, face: BrepHandle, mode: FaceScaleMode, bp: Blueprint, samples?: number): {
+    wire: BrepHandle;
+    uv: UvMap;
+};
+//# sourceMappingURL=on-surface.d.ts.map

package/dist/geometry2d/bridge/on-surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"on-surface.d.ts","sourceRoot":"","sources":["../../../src/geometry2d/bridge/on-surface.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AACvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAE7C,sFAAsF;AACtF,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,QAAQ,GAAG,QAAQ,CAAA;AAE5D,8DAA8D;AAC9D,MAAM,WAAW,MAAM;IACrB,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;CACX;AAED,wDAAwD;AACxD,MAAM,WAAW,YAAY;IAC3B,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,6DAA6D;AAC7D,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE9D,0FAA0F;AAC1F,MAAM,MAAM,kBAAkB,GAAG,IAAI,CACnC,aAAa,EACb,gBAAgB,GAAG,UAAU,GAAG,mBAAmB,GAAG,cAAc,GAAG,UAAU,CAClF,CAAA;AAED,0FAA0F;AAC1F,MAAM,MAAM,WAAW,GAAG,YAAY,CAAA;AAEtC;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,GAAG,MAAM,CAqBpE;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,KAAK,CAKxF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,gBAAgB,GAAG,mBAAmB,GAAG,cAAc,CAAC,EACzF,IAAI,EAAE,UAAU,EAChB,EAAE,EAAE,KAAK,EACT,CAAC,EAAE,UAAU,EACb,OAAO,SAAK,GACX,UAAU,CAYZ;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,gBAAgB,GAAG,UAAU,GAAG,mBAAmB,GAAG,cAAc,GAAG,UAAU,CAAC,EACnH,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,aAAa,EACnB,EAAE,EAAE,SAAS,EACb,OAAO,SAAK,GACX;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,EAAE,EAAE,KAAK,CAAA;CAAE,CAKjC"}

package/dist/geometry2d/bridge/on-surface.js

@@ -0,0 +1,94 @@
+import { evaluateCurve2d, curveBounds } from '../curve2d.js';
+/**
+ * Sample the tight axis-aligned 2D bounding box of an ordered curve set, used
+ * to affine-fit a contour onto a face's UV bounds under `bounds`/`native`.
+ * @param curves - the ordered 2D curves of a single contour.
+ * @returns the sampled bounding rect; an empty set becomes the origin rect.
+ */
+export function curves2dBounds(curves) {
+    const segments = 100;
+    let x0 = Infinity;
+    let x1 = -Infinity;
+    let y0 = Infinity;
+    let y1 = -Infinity;
+    for (const c of curves) {
+        // Sample across the curve's actual domain (a line spans [0,len] arc length, a
+        // full circle [0,2π]); the naive [0,1] interval would under-measure both.
+        const { first, last } = curveBounds(c);
+        for (let k = 0; k <= segments; k++) {
+            const t = first + ((last - first) * k) / segments;
+            const [x, y] = evaluateCurve2d(c, t);
+            if (x < x0)
+                x0 = x;
+            if (x > x1)
+                x1 = x;
+            if (y < y0)
+                y0 = y;
+            if (y > y1)
+                y1 = y;
+        }
+    }
+    if (x0 === Infinity)
+        return { x0: 0, x1: 0, y0: 0, y1: 0 };
+    return { x0, x1, y0, y1 };
+}
+/**
+ * Build a `(x,y)` → `(u,v)` mapping for a scale mode against a face's UV bounds.
+ * `original` returns the identity (2D coords are read as UVs). `bounds`/`native`
+ * affine-scale the contour's 2D box onto the full UV bounds, preserving aspect.
+ * @param mode - the face-scale mode.
+ * @param rect - the 2D bounding box of the contour (sampled; ignored by `original`).
+ * @param bounds - the face UV bounds from `uvBounds`.
+ * @returns an `(x,y)` → `(u,v)` function (pure; assertable in unit tests).
+ */
+export function makeUvMap(mode, rect, bounds) {
+    if (mode === 'original')
+        return (x, y) => [x, y];
+    const su = rect.x1 > rect.x0 ? (bounds.uMax - bounds.uMin) / (rect.x1 - rect.x0) : 0;
+    const sv = rect.y1 > rect.y0 ? (bounds.vMax - bounds.vMin) / (rect.y1 - rect.y0) : 0;
+    return (x, y) => [bounds.uMin + (x - rect.x0) * su, bounds.vMin + (y - rect.y0) * sv];
+}
+/**
+ * Build the 3D edge for a single 2D curve laid on a face: sample the curve, map
+ * samples to UV under the given mapping, evaluate the face surface there, and
+ * interpolate a curve edge through the resulting 3D points. A curve that
+ * evaluates to 2 or fewer distinct points is emitted as an exact `makeLineEdge`
+ * (the planar fast path).
+ * @param kernel - the surface kernel (`pointOnSurface` + `interpolatePoints`).
+ * @param face - the target face handle (for `pointOnSurface(face,u,v)`).
+ * @param uv - the UV mapping for this curve (see `makeUvMap`).
+ * @param c - the ordered 2D curve to place on the face.
+ * @param samples - the sample count per curve (>= 3 for smooth edges).
+ * @returns the placed 3D edge handle (one per curve).
+ */
+export function buildEdgeOnSurface(kernel, face, uv, c, samples = 12) {
+    const raw = [];
+    for (let k = 0; k <= samples; k++) {
+        const [x, y] = evaluateCurve2d(c, k / samples);
+        const [u, v] = uv(x, y);
+        raw.push(kernel.pointOnSurface(face, u, v));
+    }
+    const unique = Array.from(new Map(raw.map((p) => [`${p.x},${p.y},${p.z}`, p])).values());
+    if (unique.length <= 2) {
+        return kernel.makeLineEdge(unique[0], unique[unique.length - 1]);
+    }
+    return kernel.interpolatePoints(unique, 3);
+}
+/**
+ * Place every curve of a contour onto a face's UV space and assemble a wire.
+ * Computes the face UV bounds and the contour's 2D box, derives the UV map for
+ * the chosen scale mode, and buildings edges + a `makeWire` on the surface.
+ * @param kernel - the surface kernel.
+ * @param face - the target face handle.
+ * @param mode - the face-scale mode (`original`/`bounds`/`native`).
+ * @param bp - the blueprint whose ordered curves become on-face edges.
+ * @param samples - samples per curve (default 12).
+ * @returns `{ wire, uv }`: the assembled 3D wire and the UV map used.
+ */
+export function assembleWireOnFace(kernel, face, mode, bp, samples = 12) {
+    const bounds = kernel.uvBounds(face);
+    const uv = makeUvMap(mode, curves2dBounds(bp.curves), bounds);
+    const edges = bp.curves.map((c) => buildEdgeOnSurface(kernel, face, uv, c, samples));
+    return { wire: kernel.makeWire(edges), uv };
+}
+//# sourceMappingURL=on-surface.js.map

package/dist/geometry2d/bridge/on-surface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"on-surface.js","sourceRoot":"","sources":["../../../src/geometry2d/bridge/on-surface.ts"],"names":[],"mappings":"AA6BA,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAiCzD;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,MAA6B;IAC1D,MAAM,QAAQ,GAAG,GAAG,CAAA;IACpB,IAAI,EAAE,GAAG,QAAQ,CAAA;IACjB,IAAI,EAAE,GAAG,CAAC,QAAQ,CAAA;IAClB,IAAI,EAAE,GAAG,QAAQ,CAAA;IACjB,IAAI,EAAE,GAAG,CAAC,QAAQ,CAAA;IAClB,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,8EAA8E;QAC9E,0EAA0E;QAC1E,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;QACtC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC;YACnC,MAAM,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,QAAQ,CAAA;YACjD,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;YACpC,IAAI,CAAC,GAAG,EAAE;gBAAE,EAAE,GAAG,CAAC,CAAA;YAClB,IAAI,CAAC,GAAG,EAAE;gBAAE,EAAE,GAAG,CAAC,CAAA;YAClB,IAAI,CAAC,GAAG,EAAE;gBAAE,EAAE,GAAG,CAAC,CAAA;YAClB,IAAI,CAAC,GAAG,EAAE;gBAAE,EAAE,GAAG,CAAC,CAAA;QACpB,CAAC;IACH,CAAC;IACD,IAAI,EAAE,KAAK,QAAQ;QAAE,OAAO,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAA;IAC1D,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAA;AAC3B,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,SAAS,CAAC,IAAmB,EAAE,IAAY,EAAE,MAAoB;IAC/E,IAAI,IAAI,KAAK,UAAU;QAAE,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;IAChD,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IACpF,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IACpF,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;AACvF,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAAyF,EACzF,IAAgB,EAChB,EAAS,EACT,CAAa,EACb,OAAO,GAAG,EAAE;IAEZ,MAAM,GAAG,GAAmB,EAAE,CAAA;IAC9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,OAAO,EAAE,CAAC,EAAE,EAAE,CAAC;QAClC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,CAAA;QAC9C,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;QACvB,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IAC7C,CAAC;IACD,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAA;IACxF,IAAI,MAAM,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;QACvB,OAAO,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAE,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAE,CAAC,CAAA;IACpE,CAAC;IACD,OAAO,MAAM,CAAC,iBAAiB,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;AAC5C,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAAmH,EACnH,IAAgB,EAChB,IAAmB,EACnB,EAAa,EACb,OAAO,GAAG,EAAE;IAEZ,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;IACpC,MAAM,EAAE,GAAG,SAAS,CAAC,IAAI,EAAE,cAAc,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAA;IAC7D,MAAM,KAAK,GAAG,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,kBAAkB,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,CAAU,CAAC,CAAA;IAC7F,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAA;AAC7C,CAAC","sourcesContent":["/**\n * 2D curve → face UV-surface placement primitives (E3, occt-only bridge layer).\n *\n * This is the \"on-surface\" half of `sketchOnFace`: it places a pure-2D\n * `Curve2dObj[]` contour onto the UV parameter domain of an existing face and\n * assembles 3D edges living on that surface. Unlike `liftCurve2dToPlane` (which\n * maps 2D onto a plane *frame*), `buildEdgeOnSurface` samples each 2D curve,\n * maps the samples into the face's UV space under a scale mode, evaluates the\n * surface at those UVs via `pointOnSurface(face,u,v)`, and interpolates a\n * B-spline edge through the resulting 3D points — the plan's §164 composite\n * approach (engine-method-map marks `buildEdgeOnSurface` as \"occt 适配器组合实现\").\n * It is surface-type-independent (plane / cylinder / any parametric surface).\n *\n * The three scale modes (plan §164):\n *   - `original`: `u=x, v=y` — reads 2D coordinates as face UVs directly.\n *   - `bounds` / `native`: affine-fit the 2D contour's bounding box onto the\n *     face's UV bounds, ratio-preserving — the generic mode for any face.\n *\n * The UV-mapping functions are pure and the bridge takes an injected\n * `Pick<BrepEngineApi, …>` kernel plus the target face handle, so the math is\n * unit-testable with a recording kernel exactly like `lift-on-plane.ts` (no\n * occt-wasm needed). The bridge imports the kernel contract and `geometry2d`\n * only — `api/` is off-limits.\n *\n * @module\n */\nimport type { BrepEngineApi } from '../../brep/engine/primitives'\nimport type { BrepUvBounds, BrepHandle } from '../../brep/engine/types'\nimport type { Curve2dObj } from '../curve2d'\nimport { evaluateCurve2d, curveBounds } from '../curve2d'\nimport type { Blueprint } from '../blueprint'\n\n/** How a 2D contour's coordinates map onto a face's UV space (`cad.sketchOnFace`). */\nexport type FaceScaleMode = 'original' | 'bounds' | 'native'\n\n/** An axis-aligned 2D box (the contour's coordinate span). */\nexport interface Rect2d {\n  x0: number\n  x1: number\n  y0: number\n  y1: number\n}\n\n/** A 3D surface point (the `pointOnSurface` result). */\nexport interface SurfacePoint {\n  x: number\n  y: number\n  z: number\n}\n\n/** `(x,y)` → `(u,v)` face parameter-space mapping (pure). */\nexport type UvMap = (x: number, y: number) => [number, number]\n\n/** Kernel surface needed for curve-on-face placement (wider than the plane-lift Pick). */\nexport type SurfaceEdgesKernel = Pick<\n  BrepEngineApi,\n  'pointOnSurface' | 'uvBounds' | 'interpolatePoints' | 'makeLineEdge' | 'makeWire'\n>\n\n/** BrepVec3 element type handed to `interpolatePoints` / returned by `pointOnSurface`. */\nexport type SurfaceVec3 = SurfacePoint\n\n/**\n * Sample the tight axis-aligned 2D bounding box of an ordered curve set, used\n * to affine-fit a contour onto a face's UV bounds under `bounds`/`native`.\n * @param curves - the ordered 2D curves of a single contour.\n * @returns the sampled bounding rect; an empty set becomes the origin rect.\n */\nexport function curves2dBounds(curves: readonly Curve2dObj[]): Rect2d {\n  const segments = 100\n  let x0 = Infinity\n  let x1 = -Infinity\n  let y0 = Infinity\n  let y1 = -Infinity\n  for (const c of curves) {\n    // Sample across the curve's actual domain (a line spans [0,len] arc length, a\n    // full circle [0,2π]); the naive [0,1] interval would under-measure both.\n    const { first, last } = curveBounds(c)\n    for (let k = 0; k <= segments; k++) {\n      const t = first + ((last - first) * k) / segments\n      const [x, y] = evaluateCurve2d(c, t)\n      if (x < x0) x0 = x\n      if (x > x1) x1 = x\n      if (y < y0) y0 = y\n      if (y > y1) y1 = y\n    }\n  }\n  if (x0 === Infinity) return { x0: 0, x1: 0, y0: 0, y1: 0 }\n  return { x0, x1, y0, y1 }\n}\n\n/**\n * Build a `(x,y)` → `(u,v)` mapping for a scale mode against a face's UV bounds.\n * `original` returns the identity (2D coords are read as UVs). `bounds`/`native`\n * affine-scale the contour's 2D box onto the full UV bounds, preserving aspect.\n * @param mode - the face-scale mode.\n * @param rect - the 2D bounding box of the contour (sampled; ignored by `original`).\n * @param bounds - the face UV bounds from `uvBounds`.\n * @returns an `(x,y)` → `(u,v)` function (pure; assertable in unit tests).\n */\nexport function makeUvMap(mode: FaceScaleMode, rect: Rect2d, bounds: BrepUvBounds): UvMap {\n  if (mode === 'original') return (x, y) => [x, y]\n  const su = rect.x1 > rect.x0 ? (bounds.uMax - bounds.uMin) / (rect.x1 - rect.x0) : 0\n  const sv = rect.y1 > rect.y0 ? (bounds.vMax - bounds.vMin) / (rect.y1 - rect.y0) : 0\n  return (x, y) => [bounds.uMin + (x - rect.x0) * su, bounds.vMin + (y - rect.y0) * sv]\n}\n\n/**\n * Build the 3D edge for a single 2D curve laid on a face: sample the curve, map\n * samples to UV under the given mapping, evaluate the face surface there, and\n * interpolate a curve edge through the resulting 3D points. A curve that\n * evaluates to 2 or fewer distinct points is emitted as an exact `makeLineEdge`\n * (the planar fast path).\n * @param kernel - the surface kernel (`pointOnSurface` + `interpolatePoints`).\n * @param face - the target face handle (for `pointOnSurface(face,u,v)`).\n * @param uv - the UV mapping for this curve (see `makeUvMap`).\n * @param c - the ordered 2D curve to place on the face.\n * @param samples - the sample count per curve (>= 3 for smooth edges).\n * @returns the placed 3D edge handle (one per curve).\n */\nexport function buildEdgeOnSurface(\n  kernel: Pick<SurfaceEdgesKernel, 'pointOnSurface' | 'interpolatePoints' | 'makeLineEdge'>,\n  face: BrepHandle,\n  uv: UvMap,\n  c: Curve2dObj,\n  samples = 12,\n): BrepHandle {\n  const raw: SurfacePoint[] = []\n  for (let k = 0; k <= samples; k++) {\n    const [x, y] = evaluateCurve2d(c, k / samples)\n    const [u, v] = uv(x, y)\n    raw.push(kernel.pointOnSurface(face, u, v))\n  }\n  const unique = Array.from(new Map(raw.map((p) => [`${p.x},${p.y},${p.z}`, p])).values())\n  if (unique.length <= 2) {\n    return kernel.makeLineEdge(unique[0]!, unique[unique.length - 1]!)\n  }\n  return kernel.interpolatePoints(unique, 3)\n}\n\n/**\n * Place every curve of a contour onto a face's UV space and assemble a wire.\n * Computes the face UV bounds and the contour's 2D box, derives the UV map for\n * the chosen scale mode, and buildings edges + a `makeWire` on the surface.\n * @param kernel - the surface kernel.\n * @param face - the target face handle.\n * @param mode - the face-scale mode (`original`/`bounds`/`native`).\n * @param bp - the blueprint whose ordered curves become on-face edges.\n * @param samples - samples per curve (default 12).\n * @returns `{ wire, uv }`: the assembled 3D wire and the UV map used.\n */\nexport function assembleWireOnFace(\n  kernel: Pick<SurfaceEdgesKernel, 'pointOnSurface' | 'uvBounds' | 'interpolatePoints' | 'makeLineEdge' | 'makeWire'>,\n  face: BrepHandle,\n  mode: FaceScaleMode,\n  bp: Blueprint,\n  samples = 12,\n): { wire: BrepHandle; uv: UvMap } {\n  const bounds = kernel.uvBounds(face)\n  const uv = makeUvMap(mode, curves2dBounds(bp.curves), bounds)\n  const edges = bp.curves.map((c) => buildEdgeOnSurface(kernel, face, uv, c, samples) as never)\n  return { wire: kernel.makeWire(edges), uv }\n}"]}

package/dist/geometry2d/bridge/plane.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Plane frame helpers for 2D→3D placement (pure TS, no kernel, no `api/` import).
+ *
+ * A {@link Plane} carries an origin plus a right-handed, orthonormal frame
+ * `xDir / yDir / zDir` where `zDir` is the plane normal — the same semantic as
+ * the kernel `gp_Ax3` frame and the `createPlane` helper in `api/brepjs-compat`.
+ * The bridge may **not** import `api/` (plan rule against a cycle), so this
+ * module re-derives the framing math self-containedly. Points use the
+ * `{ x, y, z }` shape compatible with the BREP engine's neutral `BrepVec3`.
+ * @module
+ */
+/** A 3D point / vector (neutral {x,y,z} shape, kernel-compatible). */
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+/** User-facing 3D input: `{x,y,z}` object or `[x,y,z]` array (the script form). */
+export type Vec3Input = Vec3 | readonly [number, number, number];
+/**
+ * Normalize a raw script- or API-facing 3D input to the canonical `{x,y,z}`.
+ * Accepts both the array form (`[1,0,0]`, as produced by `.fai.js` literals)
+ * and the object form (`{x,y,z}`, used by the bridge internals).
+ * @param v - the input 3D value.
+ * @returns the canonical vector.
+ */
+export declare function toVec3(v: Vec3Input): Vec3;
+/**
+ * A right-handed, orthonormal plane frame: an origin plus `xDir`/`yDir` (in-plane
+ * axes) and `zDir` (the normal). 2D `(x, y)` maps to `origin + x*xDir + y*yDir`.
+ */
+export interface Plane {
+    /** The plane's anchor point (the 2D origin maps here). */
+    readonly origin: Vec3;
+    /** The in-plane X axis (maps the 2D +X). */
+    readonly xDir: Vec3;
+    /** The in-plane Y axis (maps the 2D +Y). */
+    readonly yDir: Vec3;
+    /** The plane normal (2D +Z after placement). */
+    readonly zDir: Vec3;
+}
+/**
+ * Build a right-handed plane frame from an origin, a normal, and an optional
+ * in-plane X direction. The X direction is auto-derived (least-aligned-axis
+ * cross product) when omitted, mirroring the kernel `gp_Ax3` convention.
+ * @param origin - the plane origin (2D origin maps here).
+ * @param normal - the plane normal (becomes the zDir); must be non-zero.
+ * @param xDir - optional explicit in-plane X; auto-derived when omitted.
+ * @returns the orthonormal plane frame.
+ */
+export declare function makePlane(origin: Vec3Input, normal: Vec3Input, xDir?: Vec3Input): Plane;
+/**
+ * Resolve a named plane (e.g. `'XY'` / `'XZ'` / `'top'`) to a frame at a given
+ * origin. Unknown names throw.
+ * @param name - the canonical plane name.
+ * @param origin - the plane origin (default [0,0,0]).
+ * @returns the plane frame.
+ */
+export declare function namedPlane(name: string, origin?: Vec3Input): Plane;
+/**
+ * Map a 2D point `(x, y)` into 3D on a plane frame:
+ * `origin + x*xDir + y*yDir`. This is the per-point lift used by curve lifting.
+ * @param plane - the target plane.
+ * @param x - the 2D `x` coordinate.
+ * @param y - the 2D `y` coordinate.
+ * @returns the 3D point on the plane.
+ */
+export declare function liftPointToPlane(plane: Plane, x: number, y: number): Vec3;
+//# sourceMappingURL=plane.d.ts.map

package/dist/geometry2d/bridge/plane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plane.d.ts","sourceRoot":"","sources":["../../../src/geometry2d/bridge/plane.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,sEAAsE;AACtE,MAAM,WAAW,IAAI;IACnB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,mFAAmF;AACnF,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAEhE;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI,CAIzC;AAED;;;GAGG;AACH,MAAM,WAAW,KAAK;IACpB,0DAA0D;IAC1D,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;IACrB,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,gDAAgD;IAChD,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;CACpB;AAeD;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE,SAAS,GAAG,KAAK,CAcvF;AAeD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,SAAgC,GAAG,KAAK,CAIxF;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAGzE"}

package/dist/geometry2d/bridge/plane.js

@@ -0,0 +1,96 @@
+/**
+ * Plane frame helpers for 2D→3D placement (pure TS, no kernel, no `api/` import).
+ *
+ * A {@link Plane} carries an origin plus a right-handed, orthonormal frame
+ * `xDir / yDir / zDir` where `zDir` is the plane normal — the same semantic as
+ * the kernel `gp_Ax3` frame and the `createPlane` helper in `api/brepjs-compat`.
+ * The bridge may **not** import `api/` (plan rule against a cycle), so this
+ * module re-derives the framing math self-containedly. Points use the
+ * `{ x, y, z }` shape compatible with the BREP engine's neutral `BrepVec3`.
+ * @module
+ */
+/**
+ * Normalize a raw script- or API-facing 3D input to the canonical `{x,y,z}`.
+ * Accepts both the array form (`[1,0,0]`, as produced by `.fai.js` literals)
+ * and the object form (`{x,y,z}`, used by the bridge internals).
+ * @param v - the input 3D value.
+ * @returns the canonical vector.
+ */
+export function toVec3(v) {
+    if (Array.isArray(v))
+        return { x: v[0], y: v[1], z: v[2] };
+    const o = v;
+    return { x: o.x, y: o.y, z: o.z };
+}
+function cross(a, b) {
+    return { x: a.y * b.z - a.z * b.y, y: a.z * b.x - a.x * b.z, z: a.x * b.y - a.y * b.x };
+}
+function norm(v) {
+    return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+}
+function normalize(v) {
+    const len = norm(v);
+    return len > 1e-14 ? { x: v.x / len, y: v.y / len, z: v.z / len } : { x: 1, y: 0, z: 0 };
+}
+/**
+ * Build a right-handed plane frame from an origin, a normal, and an optional
+ * in-plane X direction. The X direction is auto-derived (least-aligned-axis
+ * cross product) when omitted, mirroring the kernel `gp_Ax3` convention.
+ * @param origin - the plane origin (2D origin maps here).
+ * @param normal - the plane normal (becomes the zDir); must be non-zero.
+ * @param xDir - optional explicit in-plane X; auto-derived when omitted.
+ * @returns the orthonormal plane frame.
+ */
+export function makePlane(origin, normal, xDir) {
+    const o = toVec3(origin);
+    const z = normalize(toVec3(normal));
+    let x;
+    if (xDir) {
+        x = normalize(toVec3(xDir));
+    }
+    else {
+        const ax = Math.abs(z.x), ay = Math.abs(z.y), az = Math.abs(z.z);
+        const cand = ax <= ay && ax <= az ? { x: 1, y: 0, z: 0 } : ay <= az ? { x: 0, y: 1, z: 0 } : { x: 0, y: 0, z: 1 };
+        x = normalize(cross(cand, z));
+    }
+    const y = normalize(cross(z, x));
+    return { origin: o, xDir: x, yDir: y, zDir: z };
+}
+/** Named CAD planes with their canonical frames (origin defaults to [0,0,0]). */
+const NAMED_PLANES = {
+    XY: { xDir: { x: 1, y: 0, z: 0 }, zDir: { x: 0, y: 0, z: 1 } },
+    XZ: { xDir: { x: 1, y: 0, z: 0 }, zDir: { x: 0, y: -1, z: 0 } },
+    YZ: { xDir: { x: 0, y: 1, z: 0 }, zDir: { x: 1, y: 0, z: 0 } },
+    front: { xDir: { x: 1, y: 0, z: 0 }, zDir: { x: 0, y: 0, z: 1 } },
+    back: { xDir: { x: -1, y: 0, z: 0 }, zDir: { x: 0, y: 0, z: -1 } },
+    left: { xDir: { x: 0, y: 0, z: 1 }, zDir: { x: -1, y: 0, z: 0 } },
+    right: { xDir: { x: 0, y: 0, z: -1 }, zDir: { x: 1, y: 0, z: 0 } },
+    top: { xDir: { x: 1, y: 0, z: 0 }, zDir: { x: 0, y: 1, z: 0 } },
+    bottom: { xDir: { x: 1, y: 0, z: 0 }, zDir: { x: 0, y: -1, z: 0 } },
+};
+/**
+ * Resolve a named plane (e.g. `'XY'` / `'XZ'` / `'top'`) to a frame at a given
+ * origin. Unknown names throw.
+ * @param name - the canonical plane name.
+ * @param origin - the plane origin (default [0,0,0]).
+ * @returns the plane frame.
+ */
+export function namedPlane(name, origin = { x: 0, y: 0, z: 0 }) {
+    const cfg = NAMED_PLANES[name];
+    if (!cfg)
+        throw new Error(`unknown plane '${name}' (expected XY | XZ | YZ | front/back/left/right/top/bottom)`);
+    return makePlane(toVec3(origin), cfg.zDir, cfg.xDir);
+}
+/**
+ * Map a 2D point `(x, y)` into 3D on a plane frame:
+ * `origin + x*xDir + y*yDir`. This is the per-point lift used by curve lifting.
+ * @param plane - the target plane.
+ * @param x - the 2D `x` coordinate.
+ * @param y - the 2D `y` coordinate.
+ * @returns the 3D point on the plane.
+ */
+export function liftPointToPlane(plane, x, y) {
+    const { origin: o, xDir: u, yDir: v } = plane;
+    return { x: o.x + x * u.x + y * v.x, y: o.y + x * u.y + y * v.y, z: o.z + x * u.z + y * v.z };
+}
+//# sourceMappingURL=plane.js.map