@faicad/faijs-sketch 0.18.0

package/LICENSE

@@ -0,0 +1,28 @@
+MIT License
+
+Copyright (c) 2026 Faicad contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+The brepjs-derived sources (compat facade) in `src/api/` retain their
+Apache-2.0 attribution, which now lives in the standalone
+`@faicad/faijs-brepjs` package (see `@faicad/faijs-brepjs` NOTICE and
+LICENSE). Apache-2.0 text: https://www.apache.org/licenses/LICENSE-2.0

package/NOTICE

@@ -0,0 +1,28 @@
+faijs — @faicad/faijs NOTICE
+============================
+
+This product's brepjs-compat facade contains code ported from the
+`brepjs` project (https://github.com/OpenCascade/brepjs, licensed under
+the Apache License 2.0, locked at upstream commit 8685273a).
+The ported sources now live in the standalone `@faicad/faijs-brepjs`
+package; its NOTICE and LICENSE carry the full attribution.
+
+Full Apache-2.0 text: https://www.apache.org/licenses/LICENSE-2.0
+
+Runtime dependencies (not distributed inside this package)
+----------------------------------------------------------
+
+The following optional/peer dependencies are loaded by the host at
+runtime and are NOT distributed inside this tarball. They carry their
+own licenses:
+
+- `occt-wasm` — JS glue: MIT OR Apache-2.0; the compiled WASM output is
+  LGPL-2.1-only (inherited from OCCT, https://dev.opencascade.org).
+  The LGPL replacement obligation is satisfied because the host loads
+  the `.wasm` from a URL that can be overridden
+  (`OcctKernel.init({ wasm: '...' })`).
+- `manifold-3d` — Apache-2.0.
+
+`@salusoft89/planegcs` (LGPL-2.0-or-later) is used only by the
+non-shipped `src/fcstd` module and is intentionally not a dependency of
+the published package.

package/dist/bspline.d.ts

@@ -0,0 +1,58 @@
+/**
+ * P4 — B-spline curve evaluation for FCStd sketch geometry
+ * (Part::GeomBSplineCurve → BSplineCurve element: Poles/Knots/Degree).
+ *
+ * Contours only need chained endpoints, but a spline interior must be
+ * faithfully flattened into the 2D contour it feeds (P4: no-silent-loss —
+ * a pole-only bounding approximation would distort Pad/Pocket profiles).
+ * Cox–de Boor evaluation over the clamped knot vector is exact at the
+ * sampled parameters; sampling density is chord-driven (see sampleBSpline).
+ */
+/** One control pole (2D sketch-local; Z is 0 for planar sketches). */
+export interface BSPole {
+    x: number;
+    y: number;
+}
+/** Parsed BSplineCurve payload (freeCAD stores knots with multiplicity). */
+export interface BSplineCurveData {
+    poles: BSPole[];
+    /** expanded knot vector (length === poles + degree + 1 for a clamped spline) */
+    knots: number[];
+    degree: number;
+    periodic: boolean;
+}
+/**
+ * Evaluate the B-spline at parameter t via Cox–de Boor recursion.
+ * Outside the valid domain [knots[degree], knots[n]] the value is clamped.
+ *
+ * @param d - the parsed BSplineCurve payload (poles/knots/degree).
+ * @param t - the parameter to evaluate (clamped to the valid domain).
+ * @returns the evaluated pole (2D point) on the spline.
+ */
+export declare function evalBSpline(d: BSplineCurveData, t: number): BSPole;
+/**
+ * Sample the spline into a polyline. `min` samples per span, at least the
+ * pole count (a degree-3 spline needs ≥ poles points to show its shape).
+ * Endpoints are exact (clamped knot vector).
+ *
+ * @param d - the parsed BSplineCurve payload (poles/knots/degree).
+ * @param perSpan - minimum samples per knot span (default 6).
+ * @returns the sampled polyline points (first/last are the exact endpoints).
+ */
+export declare function sampleBSpline(d: BSplineCurveData, perSpan?: number): BSPole[];
+/**
+ * Flatten the spline into consecutive straight contour segments (P4: the
+ * contour chain only understands line/arc; a sampled polyline preserves the
+ * profile within chord tolerance).
+ *
+ * @param d - the parsed BSplineCurve payload (poles/knots/degree).
+ * @param perSpan - minimum samples per knot span (passed to sampleBSpline).
+ * @returns the consecutive line segments approximating the spline.
+ */
+export declare function bsplineToSegments(d: BSplineCurveData, perSpan?: number): {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}[];
+//# sourceMappingURL=bspline.d.ts.map

package/dist/bspline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bspline.d.ts","sourceRoot":"","sources":["../src/bspline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,sEAAsE;AACtE,MAAM,WAAW,MAAM;IACrB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,4EAA4E;AAC5E,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,gFAAgF;IAChF,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,OAAO,CAAA;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,gBAAgB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CA6BlE;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,gBAAgB,EAAE,OAAO,SAAI,GAAG,MAAM,EAAE,CAcxE;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,gBAAgB,EAAE,OAAO,SAAI,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,EAAE,CAOxH"}

package/dist/bspline.js

@@ -0,0 +1,93 @@
+/**
+ * P4 — B-spline curve evaluation for FCStd sketch geometry
+ * (Part::GeomBSplineCurve → BSplineCurve element: Poles/Knots/Degree).
+ *
+ * Contours only need chained endpoints, but a spline interior must be
+ * faithfully flattened into the 2D contour it feeds (P4: no-silent-loss —
+ * a pole-only bounding approximation would distort Pad/Pocket profiles).
+ * Cox–de Boor evaluation over the clamped knot vector is exact at the
+ * sampled parameters; sampling density is chord-driven (see sampleBSpline).
+ */
+/**
+ * Evaluate the B-spline at parameter t via Cox–de Boor recursion.
+ * Outside the valid domain [knots[degree], knots[n]] the value is clamped.
+ *
+ * @param d - the parsed BSplineCurve payload (poles/knots/degree).
+ * @param t - the parameter to evaluate (clamped to the valid domain).
+ * @returns the evaluated pole (2D point) on the spline.
+ */
+export function evalBSpline(d, t) {
+    const { poles, knots, degree: p } = d;
+    const n = knots.length - p - 1; // last span index
+    const lo = knots[p];
+    const hi = knots[n];
+    const u = Math.min(Math.max(t, lo), hi);
+    // find span k such that knots[k] <= u < knots[k+1] (clamped: hi lands in last span)
+    let k = p;
+    for (let i = p; i < n; i++) {
+        if (u >= knots[i] && u < knots[i + 1]) {
+            k = i;
+            break;
+        }
+    }
+    // de Boor: d[j] = poles[j + k - p], j = 0..p; lerp over levels
+    const dd = [];
+    for (let j = 0; j <= p; j++)
+        dd.push({ ...poles[j + k - p] });
+    for (let r = 1; r <= p; r++) {
+        for (let j = p; j >= r; j--) {
+            const i = j + k - p;
+            const denom = knots[i + p - r + 1] - knots[i];
+            const a = denom === 0 ? 0 : (u - knots[i]) / denom;
+            dd[j] = {
+                x: (1 - a) * dd[j - 1].x + a * dd[j].x,
+                y: (1 - a) * dd[j - 1].y + a * dd[j].y,
+            };
+        }
+    }
+    return dd[p];
+}
+/**
+ * Sample the spline into a polyline. `min` samples per span, at least the
+ * pole count (a degree-3 spline needs ≥ poles points to show its shape).
+ * Endpoints are exact (clamped knot vector).
+ *
+ * @param d - the parsed BSplineCurve payload (poles/knots/degree).
+ * @param perSpan - minimum samples per knot span (default 6).
+ * @returns the sampled polyline points (first/last are the exact endpoints).
+ */
+export function sampleBSpline(d, perSpan = 6) {
+    const { poles, knots, degree: p } = d;
+    if (poles.length === 0)
+        return [];
+    if (knots.length < p + 2)
+        return [...poles]; // degenerate: treat as control polygon
+    const lo = knots[p];
+    const hi = knots[knots.length - p - 1];
+    const spans = Math.max(1, knots.length - 2 * p - 1);
+    const count = Math.max(poles.length, spans * perSpan + 1);
+    const out = [];
+    for (let i = 0; i < count; i++) {
+        const t = lo + ((hi - lo) * i) / (count - 1);
+        out.push(evalBSpline(d, t));
+    }
+    return out;
+}
+/**
+ * Flatten the spline into consecutive straight contour segments (P4: the
+ * contour chain only understands line/arc; a sampled polyline preserves the
+ * profile within chord tolerance).
+ *
+ * @param d - the parsed BSplineCurve payload (poles/knots/degree).
+ * @param perSpan - minimum samples per knot span (passed to sampleBSpline).
+ * @returns the consecutive line segments approximating the spline.
+ */
+export function bsplineToSegments(d, perSpan = 6) {
+    const pts = sampleBSpline(d, perSpan);
+    const segs = [];
+    for (let i = 1; i < pts.length; i++) {
+        segs.push({ x1: pts[i - 1].x, y1: pts[i - 1].y, x2: pts[i].x, y2: pts[i].y });
+    }
+    return segs;
+}
+//# sourceMappingURL=bspline.js.map

package/dist/bspline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bspline.js","sourceRoot":"","sources":["../src/bspline.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * P4 — B-spline curve evaluation for FCStd sketch geometry\n * (Part::GeomBSplineCurve → BSplineCurve element: Poles/Knots/Degree).\n *\n * Contours only need chained endpoints, but a spline interior must be\n * faithfully flattened into the 2D contour it feeds (P4: no-silent-loss —\n * a pole-only bounding approximation would distort Pad/Pocket profiles).\n * Cox–de Boor evaluation over the clamped knot vector is exact at the\n * sampled parameters; sampling density is chord-driven (see sampleBSpline).\n */\n\n/** One control pole (2D sketch-local; Z is 0 for planar sketches). */\nexport interface BSPole {\n  x: number\n  y: number\n}\n\n/** Parsed BSplineCurve payload (freeCAD stores knots with multiplicity). */\nexport interface BSplineCurveData {\n  poles: BSPole[]\n  /** expanded knot vector (length === poles + degree + 1 for a clamped spline) */\n  knots: number[]\n  degree: number\n  periodic: boolean\n}\n\n/**\n * Evaluate the B-spline at parameter t via Cox–de Boor recursion.\n * Outside the valid domain [knots[degree], knots[n]] the value is clamped.\n *\n * @param d - the parsed BSplineCurve payload (poles/knots/degree).\n * @param t - the parameter to evaluate (clamped to the valid domain).\n * @returns the evaluated pole (2D point) on the spline.\n */\nexport function evalBSpline(d: BSplineCurveData, t: number): BSPole {\n  const { poles, knots, degree: p } = d;\n  const n = knots.length - p - 1; // last span index\n  const lo = knots[p]!;\n  const hi = knots[n]!;\n  const u = Math.min(Math.max(t, lo), hi);\n  // find span k such that knots[k] <= u < knots[k+1] (clamped: hi lands in last span)\n  let k = p;\n  for (let i = p; i < n; i++) {\n    if (u >= knots[i]! && u < knots[i + 1]!) {\n      k = i;\n      break;\n    }\n  }\n  // de Boor: d[j] = poles[j + k - p], j = 0..p; lerp over levels\n  const dd: BSPole[] = [];\n  for (let j = 0; j <= p; j++) dd.push({ ...poles[j + k - p]! });\n  for (let r = 1; r <= p; r++) {\n    for (let j = p; j >= r; j--) {\n      const i = j + k - p;\n      const denom = knots[i + p - r + 1]! - knots[i]!;\n      const a = denom === 0 ? 0 : (u - knots[i]!) / denom;\n      dd[j] = {\n        x: (1 - a) * dd[j - 1]!.x + a * dd[j]!.x,\n        y: (1 - a) * dd[j - 1]!.y + a * dd[j]!.y,\n      };\n    }\n  }\n  return dd[p]!;\n}\n\n/**\n * Sample the spline into a polyline. `min` samples per span, at least the\n * pole count (a degree-3 spline needs ≥ poles points to show its shape).\n * Endpoints are exact (clamped knot vector).\n *\n * @param d - the parsed BSplineCurve payload (poles/knots/degree).\n * @param perSpan - minimum samples per knot span (default 6).\n * @returns the sampled polyline points (first/last are the exact endpoints).\n */\nexport function sampleBSpline(d: BSplineCurveData, perSpan = 6): BSPole[] {\n  const { poles, knots, degree: p } = d;\n  if (poles.length === 0) return [];\n  if (knots.length < p + 2) return [...poles]; // degenerate: treat as control polygon\n  const lo = knots[p]!;\n  const hi = knots[knots.length - p - 1]!;\n  const spans = Math.max(1, knots.length - 2 * p - 1);\n  const count = Math.max(poles.length, spans * perSpan + 1);\n  const out: BSPole[] = [];\n  for (let i = 0; i < count; i++) {\n    const t = lo + ((hi - lo) * i) / (count - 1);\n    out.push(evalBSpline(d, t));\n  }\n  return out;\n}\n\n/**\n * Flatten the spline into consecutive straight contour segments (P4: the\n * contour chain only understands line/arc; a sampled polyline preserves the\n * profile within chord tolerance).\n *\n * @param d - the parsed BSplineCurve payload (poles/knots/degree).\n * @param perSpan - minimum samples per knot span (passed to sampleBSpline).\n * @returns the consecutive line segments approximating the spline.\n */\nexport function bsplineToSegments(d: BSplineCurveData, perSpan = 6): { x1: number; y1: number; x2: number; y2: number }[] {\n  const pts = sampleBSpline(d, perSpan);\n  const segs: { x1: number; y1: number; x2: number; y2: number }[] = [];\n  for (let i = 1; i < pts.length; i++) {\n    segs.push({ x1: pts[i - 1]!.x, y1: pts[i - 1]!.y, x2: pts[i]!.x, y2: pts[i]!.y });\n  }\n  return segs;\n}\n"]}

package/dist/canonical.d.ts

@@ -0,0 +1,205 @@
+/**
+ * canonical — the faijs canonical sketch model (§4 of the sketch library plan).
+ *
+ * One model, projected outward: the FreeCAD side (`fcstd-types.ts`) and the
+ * CadQuery side (`./project.ts`) are projections of this shape, not parallel
+ * implementations. Geometry declarations carry coordinates that ARE the solve
+ * initial guess; constraints pull them exact.
+ *
+ * Units follow the project contract: lengths in mm, angles in degrees.
+ */
+/**
+ * A position on an element. `number` is the 0..1 parametric position (0 =
+ * start, 1 = end, 0.5 = arc/line midpoint). `'center'` is the circle/arc/ellipse
+ * centre — semantically distinct from `'mid'`.
+ */
+export type At = number | 'start' | 'end' | 'mid' | 'center';
+/** An element reference: `tag` (named) or `index` (array position); `at` omitted = whole element. */
+export type Ref = {
+    tag: string;
+    at?: At;
+} | {
+    index: number;
+    at?: At;
+};
+/**
+ * Canonical sketch geometry. First release supports `line` + `circle` + `arc`;
+ * `point` / `ellipse` / `bspline` are reserved schema (a hit reports
+ * `E_SKETCHC_UNSUPPORTED_GEOM`).
+ */
+export type SketchGeom = {
+    tag?: string;
+    kind: 'line';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+} | {
+    tag?: string;
+    kind: 'circle';
+    cx: number;
+    cy: number;
+    r: number;
+} | {
+    tag?: string;
+    kind: 'arc';
+    cx: number;
+    cy: number;
+    r: number;
+    a0: number;
+    a1: number;
+    ccw?: boolean;
+} | {
+    tag?: string;
+    kind: 'point';
+    x: number;
+    y: number;
+} | {
+    tag?: string;
+    kind: 'ellipse';
+    cx: number;
+    cy: number;
+    rx: number;
+    ry: number;
+    a0?: number;
+    a1?: number;
+    /** major-axis rotation, radians */
+    angle?: number;
+} | {
+    tag?: string;
+    kind: 'bspline';
+    poles: {
+        x: number;
+        y: number;
+    }[];
+    knots: number[];
+    degree: number;
+    periodic?: boolean;
+};
+/** Canonical constraint kinds (string enums; integer enums only appear at projection boundaries). */
+export type SketchConstraint = {
+    kind: 'fixed';
+    of: Ref;
+} | {
+    kind: 'coincident';
+    a: Ref;
+    b: Ref;
+} | {
+    kind: 'horizontal';
+    of: Ref;
+} | {
+    kind: 'vertical';
+    of: Ref;
+} | {
+    kind: 'parallel';
+    a: Ref;
+    b: Ref;
+} | {
+    kind: 'perpendicular';
+    a: Ref;
+    b: Ref;
+} | {
+    kind: 'tangent';
+    a: Ref;
+    b: Ref;
+} | {
+    kind: 'distance';
+    a: Ref;
+    b: Ref;
+    value: number;
+} | {
+    kind: 'distanceX';
+    a: Ref;
+    b: Ref;
+    value: number;
+} | {
+    kind: 'distanceY';
+    a: Ref;
+    b: Ref;
+    value: number;
+} | {
+    kind: 'length';
+    of: Ref;
+    value: number;
+} | {
+    kind: 'angle';
+    a: Ref;
+    b: Ref;
+    value: number;
+} | {
+    kind: 'orientation';
+    of: Ref;
+    dir: [number, number];
+} | {
+    kind: 'radius';
+    of: Ref;
+    value: number;
+} | {
+    kind: 'diameter';
+    of: Ref;
+    value: number;
+} | {
+    kind: 'arcAngle';
+    of: Ref;
+    value: number;
+} | {
+    kind: 'equal';
+    a: Ref;
+    b: Ref;
+} | {
+    kind: 'pointOnObject';
+    p: Ref;
+    on: Ref;
+} | {
+    kind: 'symmetric';
+    p1: Ref;
+    p2: Ref;
+    about: Ref;
+};
+/** The `kind` string of a canonical constraint. */
+export type SketchConstraintKind = SketchConstraint['kind'];
+/** A canonical sketch: geometry declarations plus constraints. */
+export interface SketchInput {
+    geoms: SketchGeom[];
+    constraints?: SketchConstraint[];
+}
+/**
+ * Solve status (§5): under- and over-constraint are allowed, but never silent.
+ */
+export type SolveStatus = 
+/** all constraints satisfied, zero remaining DoF */
+'solved'
+/** free DoF remain; solved to a minimal-displacement solution */
+ | 'underconstrained'
+/** redundant constraints were dropped; solved */
+ | 'redundant'
+/** constraints conflict; best-effort least-squares solution returned */
+ | 'conflicting'
+/** solver failed numerically (not an under/over-constraint cause) */
+ | 'failed';
+/**
+ * Result of one canonical solve: solved geometry plus explicit diagnostics.
+ *
+ * `converged` is false only for `failed` — under/redundant/conflicting all
+ * produce geometry (allowed ≠ silent: the status and diagnostics carry the
+ * story).
+ */
+export interface SolveOutcome {
+    /** solved geometry, same order/index as input */
+    geoms: SketchGeom[];
+    /** true unless `status === 'failed'` */
+    converged: boolean;
+    /** explicit solve status (§5) */
+    status: SolveStatus;
+    /** remaining degrees of freedom when known (-1 = not reported) */
+    dof: number;
+    /** constraint indices the solver flagged (conflicting/redundant) */
+    problemConstraints: number[];
+    /** constraint indices dropped because they could not be projected/pushed */
+    droppedConstraints: number[];
+    /** per-problem-constraint residual magnitude when available */
+    residuals?: number[];
+    /** human-readable detail for a non-solved status */
+    reason?: string;
+}
+//# sourceMappingURL=canonical.d.ts.map

package/dist/canonical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical.d.ts","sourceRoot":"","sources":["../src/canonical.ts"],"names":[],"mappings":"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"}

package/dist/canonical.js

@@ -0,0 +1,12 @@
+/**
+ * canonical — the faijs canonical sketch model (§4 of the sketch library plan).
+ *
+ * One model, projected outward: the FreeCAD side (`fcstd-types.ts`) and the
+ * CadQuery side (`./project.ts`) are projections of this shape, not parallel
+ * implementations. Geometry declarations carry coordinates that ARE the solve
+ * initial guess; constraints pull them exact.
+ *
+ * Units follow the project contract: lengths in mm, angles in degrees.
+ */
+export {};
+//# sourceMappingURL=canonical.js.map

package/dist/canonical.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical.js","sourceRoot":"","sources":["../src/canonical.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG","sourcesContent":["/**\n * canonical — the faijs canonical sketch model (§4 of the sketch library plan).\n *\n * One model, projected outward: the FreeCAD side (`fcstd-types.ts`) and the\n * CadQuery side (`./project.ts`) are projections of this shape, not parallel\n * implementations. Geometry declarations carry coordinates that ARE the solve\n * initial guess; constraints pull them exact.\n *\n * Units follow the project contract: lengths in mm, angles in degrees.\n */\n\n/**\n * A position on an element. `number` is the 0..1 parametric position (0 =\n * start, 1 = end, 0.5 = arc/line midpoint). `'center'` is the circle/arc/ellipse\n * centre — semantically distinct from `'mid'`.\n */\nexport type At = number | 'start' | 'end' | 'mid' | 'center'\n\n/** An element reference: `tag` (named) or `index` (array position); `at` omitted = whole element. */\nexport type Ref = { tag: string; at?: At } | { index: number; at?: At }\n\n/**\n * Canonical sketch geometry. First release supports `line` + `circle` + `arc`;\n * `point` / `ellipse` / `bspline` are reserved schema (a hit reports\n * `E_SKETCHC_UNSUPPORTED_GEOM`).\n */\nexport type SketchGeom =\n  | { tag?: string; kind: 'line'; x1: number; y1: number; x2: number; y2: number }\n  | { tag?: string; kind: 'circle'; cx: number; cy: number; r: number }\n  | { tag?: string; kind: 'arc'; cx: number; cy: number; r: number; a0: number; a1: number; ccw?: boolean }\n  | { tag?: string; kind: 'point'; x: number; y: number }\n  | {\n      tag?: string\n      kind: 'ellipse'\n      cx: number\n      cy: number\n      rx: number\n      ry: number\n      a0?: number\n      a1?: number\n      /** major-axis rotation, radians */\n      angle?: number\n    }\n  | {\n      tag?: string\n      kind: 'bspline'\n      poles: { x: number; y: number }[]\n      knots: number[]\n      degree: number\n      periodic?: boolean\n    }\n\n/** Canonical constraint kinds (string enums; integer enums only appear at projection boundaries). */\nexport type SketchConstraint =\n  | { kind: 'fixed'; of: Ref }\n  | { kind: 'coincident'; a: Ref; b: Ref }\n  | { kind: 'horizontal'; of: Ref }\n  | { kind: 'vertical'; of: Ref }\n  | { kind: 'parallel'; a: Ref; b: Ref }\n  | { kind: 'perpendicular'; a: Ref; b: Ref }\n  | { kind: 'tangent'; a: Ref; b: Ref }\n  | { kind: 'distance'; a: Ref; b: Ref; value: number }\n  | { kind: 'distanceX'; a: Ref; b: Ref; value: number }\n  | { kind: 'distanceY'; a: Ref; b: Ref; value: number }\n  | { kind: 'length'; of: Ref; value: number }\n  | { kind: 'angle'; a: Ref; b: Ref; value: number }\n  | { kind: 'orientation'; of: Ref; dir: [number, number] }\n  | { kind: 'radius'; of: Ref; value: number }\n  | { kind: 'diameter'; of: Ref; value: number }\n  | { kind: 'arcAngle'; of: Ref; value: number }\n  | { kind: 'equal'; a: Ref; b: Ref }\n  | { kind: 'pointOnObject'; p: Ref; on: Ref }\n  | { kind: 'symmetric'; p1: Ref; p2: Ref; about: Ref }\n\n/** The `kind` string of a canonical constraint. */\nexport type SketchConstraintKind = SketchConstraint['kind']\n\n/** A canonical sketch: geometry declarations plus constraints. */\nexport interface SketchInput {\n  geoms: SketchGeom[]\n  constraints?: SketchConstraint[]\n}\n\n/**\n * Solve status (§5): under- and over-constraint are allowed, but never silent.\n */\nexport type SolveStatus =\n  /** all constraints satisfied, zero remaining DoF */\n  | 'solved'\n  /** free DoF remain; solved to a minimal-displacement solution */\n  | 'underconstrained'\n  /** redundant constraints were dropped; solved */\n  | 'redundant'\n  /** constraints conflict; best-effort least-squares solution returned */\n  | 'conflicting'\n  /** solver failed numerically (not an under/over-constraint cause) */\n  | 'failed'\n\n/**\n * Result of one canonical solve: solved geometry plus explicit diagnostics.\n *\n * `converged` is false only for `failed` — under/redundant/conflicting all\n * produce geometry (allowed ≠ silent: the status and diagnostics carry the\n * story).\n */\nexport interface SolveOutcome {\n  /** solved geometry, same order/index as input */\n  geoms: SketchGeom[]\n  /** true unless `status === 'failed'` */\n  converged: boolean\n  /** explicit solve status (§5) */\n  status: SolveStatus\n  /** remaining degrees of freedom when known (-1 = not reported) */\n  dof: number\n  /** constraint indices the solver flagged (conflicting/redundant) */\n  problemConstraints: number[]\n  /** constraint indices dropped because they could not be projected/pushed */\n  droppedConstraints: number[]\n  /** per-problem-constraint residual magnitude when available */\n  residuals?: number[]\n  /** human-readable detail for a non-solved status */\n  reason?: string\n}"]}

package/dist/contour.d.ts

@@ -0,0 +1,43 @@
+/**
+ * M3.6 — contour extraction: solved sketch geometry → closed loops → 2D
+ * contour (R6: pure data, no OCCT dependency; the cad-face wiring that turns
+ * contours into Blueprint/extrude inputs happens in M4.6/M5).
+ *
+ * Extraction: collect endpoints of every non-construction geometry, chain
+ * segments sharing endpoints (tolerance-based), keep closed loops.
+ */
+import type { FcstdSketchGeom } from './fcstd-types.js';
+/** One segment of a 2D contour: either a straight line or a circular arc (planar, sketch-local coordinates). */
+export type ContourSeg = {
+    kind: 'line';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+} | {
+    kind: 'arc';
+    cx: number;
+    cy: number;
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+    ccw: boolean;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+/** A chained run of segments; `closed` when the chain's ends meet (R6: pure data, no OCCT dependency). */
+export interface Contour {
+    /** chained segments in traversal order */
+    segments: ContourSeg[];
+    /** true when the chain's endpoints meet within JOIN_TOL */
+    closed: boolean;
+}
+/**
+ * Extract closed contours (chains of segments whose endpoints meet).
+ * @param geoms solved sketch geometry to chain (non-construction segments only)
+ * @returns closed loops plus self-closed circles (open chains are dropped)
+ */
+export declare function extractContours(geoms: FcstdSketchGeom[]): Contour[];
+//# sourceMappingURL=contour.d.ts.map

package/dist/contour.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contour.d.ts","sourceRoot":"","sources":["../src/contour.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAGxD,gHAAgH;AAChH,MAAM,MAAM,UAAU,GAClB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAChE;IACE,IAAI,EAAE,KAAK,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,OAAO,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAEN,0GAA0G;AAC1G,MAAM,WAAW,OAAO;IACtB,0CAA0C;IAC1C,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,2DAA2D;IAC3D,MAAM,EAAE,OAAO,CAAC;CACjB;AAwCD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,OAAO,EAAE,CA8EnE"}

package/dist/contour.js

@@ -0,0 +1,132 @@
+import { bsplineToSegments } from './bspline.js';
+const JOIN_TOL = 1e-7;
+function segEnds(g) {
+    switch (g.kind) {
+        case 'line':
+            return [
+                { kind: 'line', x1: g.x1, y1: g.y1, x2: g.x2, y2: g.y2 },
+                { x: g.x1, y: g.y1 },
+                { x: g.x2, y: g.y2 },
+            ];
+        case 'arc':
+            return [
+                {
+                    kind: 'arc', cx: g.cx, cy: g.cy, radius: g.radius,
+                    startAngle: g.startAngle, endAngle: g.endAngle, ccw: true,
+                    x1: g.x1, y1: g.y1, x2: g.x2, y2: g.y2,
+                },
+                { x: g.x1, y: g.y1 },
+                { x: g.x2, y: g.y2 },
+            ];
+        case 'bspline': {
+            // P4: flatten the spline into a sampled polyline. Only the FIRST
+            // sub-segment is returned here so the pool gets exactly one entry per
+            // geometry (no index duplication); extractContours splices the full
+            // polyline run in its place (see expandBSpline below).
+            const segs = bsplineToSegments({
+                poles: g.poles, knots: g.knots, degree: g.degree, periodic: g.periodic,
+            });
+            const first = segs[0];
+            const last = segs[segs.length - 1];
+            if (!first || !last)
+                return undefined;
+            return [{ kind: 'line', x1: first.x1, y1: first.y1, x2: last.x2, y2: last.y2 }, { x: first.x1, y: first.y1 }, { x: last.x2, y: last.y2 }];
+        }
+        default:
+            return undefined; // circles are closed on their own; points don't join
+    }
+}
+/**
+ * Extract closed contours (chains of segments whose endpoints meet).
+ * @param geoms solved sketch geometry to chain (non-construction segments only)
+ * @returns closed loops plus self-closed circles (open chains are dropped)
+ */
+export function extractContours(geoms) {
+    const pool = [];
+    for (const g of geoms) {
+        const s = segEnds(g);
+        if (!s)
+            continue;
+        // P4: keep the full sampled polyline for splines — after chaining, the
+        // winning seg is expanded back into all sub-segments (no interior loss).
+        const spline = g.kind === 'bspline'
+            ? bsplineToSegments({ poles: g.poles, knots: g.knots, degree: g.degree, periodic: g.periodic })
+            : undefined;
+        pool.push({ seg: s[0], a: s[1], b: s[2], used: false, spline });
+    }
+    const near = (p, q) => Math.hypot(p.x - q.x, p.y - q.y) <= JOIN_TOL;
+    const contours = [];
+    for (const start of pool) {
+        if (start.used)
+            continue;
+        start.used = true;
+        const head = start.a;
+        // GOTCHA (slittingsaw corpus, 2026-09-20): junction points with free
+        // branches (three+ segments sharing an endpoint) defeat first-come
+        // chaining — a branch to a dead end consumed the segments and the real
+        // loop never closed. DFS with backtracking: try each candidate
+        // continuation; the FIRST chain that closes at the head wins; a dead
+        // branch returns its segments to the pool. Closure-stop (tap GOTCHA) and
+        // pool-restart are both subsumed by the DFS ordering.
+        const dfs = (tail, walk) => {
+            if (walk.length > 0 && near(tail, head))
+                return walk;
+            for (const cand of pool) {
+                if (cand.used)
+                    continue;
+                cand.used = true;
+                if (near(tail, cand.a)) {
+                    const r = dfs(cand.b, [...walk, cand.seg]);
+                    if (r)
+                        return r;
+                }
+                else if (near(tail, cand.b)) {
+                    const r = dfs(cand.a, [...walk, reverseSeg(cand.seg)]);
+                    if (r)
+                        return r;
+                }
+                cand.used = false; // dead branch — return the segment to the pool
+            }
+            return undefined;
+        };
+        const solved = dfs(start.b, [start.seg]);
+        if (solved && solved.length > 1) {
+            // P4: replace spline proxy segs with their full sampled polyline runs.
+            // The proxy seg for geometry index i sits in pool order; recover the
+            // spline runs by matching the seg reference against pool entries.
+            const expanded = [];
+            for (const seg of solved) {
+                const entry = pool.find((e) => e.seg === seg && e.spline);
+                if (entry?.spline) {
+                    for (const sub of entry.spline) {
+                        expanded.push({ kind: 'line', x1: sub.x1, y1: sub.y1, x2: sub.x2, y2: sub.y2 });
+                    }
+                }
+                else {
+                    expanded.push(seg);
+                }
+            }
+            contours.push({ segments: expanded, closed: true });
+        }
+    }
+    // circles are self-closed contours
+    for (const g of geoms) {
+        if (g.kind === 'circle' && g.radius > 0) {
+            contours.push({
+                segments: [{
+                        kind: 'arc', cx: g.cx, cy: g.cy, radius: g.radius,
+                        startAngle: 0, endAngle: Math.PI * 2, ccw: true,
+                        x1: g.cx + g.radius, y1: g.cy, x2: g.cx + g.radius, y2: g.cy,
+                    }],
+                closed: true,
+            });
+        }
+    }
+    return contours;
+}
+function reverseSeg(s) {
+    if (s.kind === 'line')
+        return { kind: 'line', x1: s.x2, y1: s.y2, x2: s.x1, y2: s.y1 };
+    return { ...s, startAngle: s.endAngle, endAngle: s.startAngle, ccw: !s.ccw, x1: s.x2, y1: s.y2, x2: s.x1, y2: s.y1 };
+}
+//# sourceMappingURL=contour.js.map