@metamesh/modeling 0.8.0 → 0.10.0

package/dist/api/index.d.ts

@@ -588,7 +588,19 @@ export declare type LinearPatternOptions = {
 /** Host-bound loft operation. Valid only during a synchronous build. */
 export declare const loft: ModelingContext["loft"];
 
-/** Deterministic ordered edge subdivision or bounded geometric vertex association. */
+/**
+ * Associates ordered loft contours without inferring component identities or repairing topology.
+ *
+ * - `direct` preserves seams and subdivides edges to a common count without dropping vertices.
+ * - `reindex` applies direct subdivision, then selects the next contour's cyclic phase with the
+ *   least total world-space connection length.
+ * - `fast-distance` preserves supplied seams and minimizes connection length over ordered closed
+ *   vertex associations, repeating vertices for triangular fans.
+ * - `distance` runs the same ordered optimization over every cyclic phase of the next contour.
+ *
+ * Components and holes are paired by their existing order. Use identified profiles when semantic
+ * correspondence must remain authoritative.
+ */
 export declare type LoftCorrespondence = "direct" | "reindex" | "fast-distance" | "distance";
 
 /**

package/dist/geometry/index.js

@@ -27,7 +27,8 @@ export { sampleHelix } from "./paths/helix.js";
 export { cumulativePathLengths, pathLength } from "./paths/path.js";
 export { distributeAlongPath, roundClosedPolylinePath, } from "./paths/planar.js";
 export { circleLoop, rectangleLoop, regularPolygonLoop, starLoop, } from "./profiles/profiles.js";
-export { sampleOpenProfile, } from "./profiles/open-profile.js";
+export { sampleSideProfile, } from "./profiles/side-profile.js";
+export { sampleContour, } from "./profiles/contour.js";
 export { ellipseLoop } from "./profiles/shapes.js";
 export { rectangleProfile, } from "./profiles/rectangle.js";
 export { loopContainsPoint, normalizeLoop2, normalizePolygon2, normalizeRegion2, regionArea, regionBounds, signedAreaLoop2, } from "./regions.js";

package/dist/geometry/profiles/contour.js

@@ -0,0 +1,102 @@
+import { sampleCurve2 } from "../curves/sampling.js";
+import { GeometryError } from "../errors.js";
+import { normalizeLoop2 } from "../regions.js";
+import { resolveGeometrySamplingLimits } from "../sampling-limits.js";
+import { requireProfileVertexCount } from "./validation.js";
+const OPERATION = "sampleContour";
+function invalid(message) {
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation: OPERATION });
+}
+/**
+ * Samples 2–32 connected line/cubic segments into a simple, nonzero-area, immutable CCW XY loop.
+ * Physical scaling precedes adaptive curve sampling; the final end must repeat start exactly.
+ * Shared anchors and the closing seam are emitted once. Winding normalization may change the
+ * starting vertex. The sampled loop is checked for self-intersection and degeneracy by
+ * `normalizeLoop2`; this is a single contour without holes. No editor modes or normalized
+ * coordinate range are required. No native engine, SDK, or ambient resolution is used.
+ *
+ * @param curve - Closed contour in millimetres unless positive scales convert its coordinates.
+ * @param options - Physical resolution and unique vertex budget; defaults to 4096 vertices.
+ * @returns Frozen counterclockwise loop in millimetres, without a repeated seam endpoint.
+ * @throws {@link GeometryError} for invalid data, topology, scale, or exceeded sampling budgets.
+ *
+ * @example
+ * ```ts
+ * const section = sampleContour({
+ *   start: { x: 0, y: 0 },
+ *   segments: [
+ *     { type: "line", end: { x: 1, y: 0 } },
+ *     { type: "line", end: { x: 0.5, y: 1 } },
+ *     { type: "line", end: { x: 0, y: 0 } },
+ *   ],
+ * }, { widthScale: 20, heightScale: 12 });
+ * ```
+ */
+export function sampleContour(curve, options = {}) {
+    const widthScale = options.widthScale ?? 1;
+    const heightScale = options.heightScale ?? 1;
+    if (![widthScale, heightScale].every((scale) => Number.isFinite(scale) && scale > 0))
+        invalid("Cross-section scales must be finite and positive.");
+    const limits = resolveGeometrySamplingLimits(options.limits);
+    const maximumVertices = options.maximumVertices ?? Math.min(4096, limits.maxProfilePoints);
+    requireProfileVertexCount(maximumVertices, 3, OPERATION, limits);
+    const segmentInput = curve?.segments;
+    if (!curve ||
+        !Array.isArray(segmentInput) ||
+        curve.segments.length < 2 ||
+        curve.segments.length > 32)
+        invalid("A cross section must contain 2–32 segments.");
+    const physical = (point) => {
+        if (!point || !Number.isFinite(point.x) || !Number.isFinite(point.y))
+            invalid("Cross-section coordinates must be finite.");
+        const result = [point.x * widthScale, point.y * heightScale];
+        if (!result.every(Number.isFinite))
+            invalid("Scaled cross-section coordinates must be finite.");
+        return result;
+    };
+    const first = physical(curve.start);
+    const final = curve.segments.at(-1)?.end;
+    if (!final || final.x !== curve.start.x || final.y !== curve.start.y)
+        invalid("The final cross-section endpoint must match the start exactly.");
+    const output = [first];
+    let start = first;
+    for (let index = 0; index < curve.segments.length; index++) {
+        const segment = curve.segments[index];
+        if (!segment)
+            invalid("Cross-section segments must be lines or cubics.");
+        const end = physical(segment.end);
+        const closed = index === curve.segments.length - 1;
+        const remainingVertices = Math.min(limits.maxPathPoints, maximumVertices - output.length + 1 + (closed ? 1 : 0));
+        if (remainingVertices < 2)
+            throw new GeometryError("COMPLEXITY_LIMIT", "Cross-section sampling exceeds its vertex budget.", {
+                operation: OPERATION,
+                details: { maximumVertices },
+            });
+        let span;
+        if (segment.type === "line") {
+            span = { kind: "line", start, end };
+        }
+        else if (segment.type === "cubic") {
+            span = {
+                kind: "cubic",
+                start,
+                end,
+                control1: physical(segment.control1),
+                control2: physical(segment.control2),
+            };
+        }
+        else {
+            invalid("Cross-section segments must be lines or cubics.");
+        }
+        const sampled = sampleCurve2(span, {
+            ...(options.resolution === undefined ? {} : { resolution: options.resolution }),
+            maximumVertices: remainingVertices,
+            limits,
+        }).points;
+        const endIndex = sampled.length - (closed ? 1 : 0);
+        for (let pointIndex = 1; pointIndex < endIndex; pointIndex++)
+            output.push(sampled[pointIndex]);
+        start = end;
+    }
+    return normalizeLoop2(output, true);
+}

package/dist/geometry/profiles/{open-profile.js → side-profile.js}

@@ -2,7 +2,7 @@ import { GeometryError } from "../errors.js";
 import { resolveGeometryResolution } from "../resolution.js";
 import { resolveGeometrySamplingLimits } from "../sampling-limits.js";
 import { requireProfileVertexCount } from "./validation.js";
-const OPERATION = "sampleOpenProfile";
+const OPERATION = "sampleSideProfile";
 const MAX_SEGMENTS = 31;
 const MAX_DEPTH = 24;
 function invalid(message) {
@@ -35,13 +35,13 @@ function distanceToChord(point, start, end) {
  *
  * @example
  * ```ts
- * const side = sampleOpenProfile({
+ * const side = sampleSideProfile({
  *   start: { radius: 0.5, height: 0 },
  *   segments: [{ type: "line", end: { radius: 1, height: 1 } }],
  * }, { radiusScale: 12, heightScale: 30 });
  * ```
  */
-export function sampleOpenProfile(curve, options = {}) {
+export function sampleSideProfile(curve, options = {}) {
     const radiusScale = options.radiusScale ?? 1;
     const heightScale = options.heightScale ?? 1;
     if (![radiusScale, heightScale].every((scale) => Number.isFinite(scale) && scale > 0)) {

package/dist/geometry/svg-import.js

@@ -5,6 +5,7 @@ import { resolveCircularSegments, resolveGeometryResolution, } from "./resolutio
 import { resolveGeometrySamplingLimits } from "./sampling-limits.js";
 import { strokePathMultiPolygon } from "./stroke-path.js";
 import { createBoundedSvgClipping } from "./svg/fill.js";
+import { multiplyMatrices as multiply, transformPoint } from "./svg/matrix.js";
 import { flattenSvgSubpaths, SvgVertexBudget } from "./svg/path.js";
 const MAX_SVG_BYTES = 256 * 1024;
 const MAX_SVG_ELEMENTS = 500;
@@ -89,22 +90,6 @@ function finite(value, fallback) {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : fail(`Invalid SVG number “${value}”.`);
 }
-function multiply(left, right) {
-    return [
-        left[0] * right[0] + left[2] * right[1],
-        left[1] * right[0] + left[3] * right[1],
-        left[0] * right[2] + left[2] * right[3],
-        left[1] * right[2] + left[3] * right[3],
-        left[0] * right[4] + left[2] * right[5] + left[4],
-        left[1] * right[4] + left[3] * right[5] + left[5],
-    ];
-}
-function transformPoint(matrix, point) {
-    return [
-        matrix[0] * point[0] + matrix[2] * point[1] + matrix[4],
-        matrix[1] * point[0] + matrix[3] * point[1] + matrix[5],
-    ];
-}
 function parseTransform(value) {
     if (value === undefined || value.trim() === "")
         return [1, 0, 0, 1, 0, 0];
@@ -280,7 +265,14 @@ function canvasTransform(values, width, height, box, origin) {
     return [appliedX, 0, 0, -appliedY, offsetX, offsetY];
 }
 function isPainted(color, opacity) {
-    return color !== "none" && color !== "transparent" && opacity > 0;
+    // Mirrored by the editor's core/document.ts: embedded CSS alpha also controls geometry.
+    const normalized = color.trim().toLowerCase();
+    if (normalized === "none" || normalized === "transparent" || !(opacity > 0))
+        return false;
+    if (/^#[0-9a-f]{4}(?:[0-9a-f]{4})?$/u.test(normalized))
+        return Number.parseInt(normalized.slice(normalized.length === 5 ? -1 : -2), 16) > 0;
+    const components = /^(?:rgb|hsl)a?\((.*)\)$/u.exec(normalized)?.[1]?.split(",");
+    return components?.length !== 4 || Number(components[3].trim().replace(/%$/u, "")) > 0;
 }
 function ellipsePoints(cx, cy, rx, ry, segments, budget) {
     if (rx <= 0 || ry <= 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metamesh/modeling",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Scoped solid modeling and pure geometry foundations for Node and browsers.",
   "license": "Apache-2.0",
   "repository": {