@pibbl/core 0.0.1

package/dist/lib/geometry/path-bend-guide.js

@@ -0,0 +1,282 @@
+import { ellipseParameters, singularArcPoints } from "./path-arc.js";
+import { bendSpanBounds, bendSpanPoint, bendSpans, splitBendSpan } from "./path-bend-spans.js";
+const MAX_GUIDE_WORK = 2e6;
+const MAX_GUIDE_LEAVES = 131072;
+const MAX_GUIDE_DEPTH = 48;
+const JOIN_ROUNDOFF = 512 * Number.EPSILON;
+function prepareBendGuide(path) {
+  const spans = [];
+  let moves = 0, closed = false, scale = 0;
+  for (const item of bendSpans(path)) {
+    if (item.type === "move") {
+      if (++moves > 1) throw new RangeError("Along Path requires exactly one guide contour.");
+      scale = Math.max(scale, ...item.point.map(Math.abs));
+    } else if (item.type === "close") closed = true;
+    else {
+      closed = false;
+      const bounds = bendSpanBounds(item.span);
+      scale = Math.max(scale, Math.abs(bounds.xmin), Math.abs(bounds.xmax), Math.abs(bounds.ymin), Math.abs(bounds.ymax));
+      if ("arc" in item.span && !ellipseParameters(item.span.arc)) {
+        const points = [bendSpanPoint(item.span, 0), ...singularArcPoints(item.span.arc)];
+        for (let i = 1; i < points.length; i++) append({ points: [points[i - 1], points[i]] });
+      } else append(item.span);
+    }
+  }
+  if (!spans.length) throw new RangeError("Along Path requires a guide of positive length.");
+  if (closed) sameTangent(tangent(spans.at(-1), true), tangent(spans[0], false));
+  return { spans, closed, scale };
+  function append(raw) {
+    const b = bendSpanBounds(raw);
+    if (Math.hypot(b.xmax - b.xmin, b.ymax - b.ymin) <= scale * Number.EPSILON * 32) return;
+    const span = straightSpan(raw);
+    const first = tangent(span, false), last = tangent(span, true);
+    if (spans.length) sameTangent(tangent(spans.at(-1), true), first);
+    if (![...first, ...last].every(Number.isFinite)) throw new RangeError("Guide limiting tangent is not finite.");
+    spans.push(span);
+  }
+}
+function measureBendGuide(prepared, tolerance, maxDisplacement, distanceFactor) {
+  let work = 0;
+  const charge = () => {
+    if (++work > MAX_GUIDE_WORK) throw new RangeError("Along Path exceeded its guide work budget.");
+  };
+  const roundoff = prepared.scale * Number.EPSILON * 128;
+  if (!Number.isFinite(roundoff) || roundoff >= tolerance / 16) throw new RangeError("Guide coordinates cannot support the requested tolerance.");
+  let pending = prepared.spans.map((span) => ({ span, depth: 0 }));
+  let leaves = [];
+  let target = tolerance / 32;
+  let length = 0, uncertainty = 0, error = Infinity;
+  for (let pass = 0; pass < 24; pass++) {
+    leaves = [];
+    const stack = [...pending].reverse();
+    while (stack.length) {
+      charge();
+      const { span, depth } = stack.pop();
+      const leaf = certifyLeaf(span, depth);
+      if (leaf && leaf.sag + maxDisplacement * leaf.normalError <= target) {
+        if (leaves.length >= MAX_GUIDE_LEAVES) throw new RangeError("Along Path exceeded its guide subdivision budget.");
+        leaves.push(leaf);
+      } else {
+        if (depth >= MAX_GUIDE_DEPTH) throw new RangeError("Guide has a cusp, reversal, or numerically uncertifiable tangent.");
+        const [left, right] = splitBendSpan(span);
+        stack.push({ span: right, depth: depth + 1 }, { span: left, depth: depth + 1 });
+      }
+    }
+    length = 0;
+    uncertainty = 0;
+    let compensation2 = 0, sag = 0, normalError = 0, normalSlope = 0, joinError = JOIN_ROUNDOFF;
+    let previous;
+    for (const leaf of leaves) {
+      if (previous) {
+        const a = previous.last.normal, b = leaf.first.normal;
+        if (a[0] * b[0] + a[1] * b[1] <= 0) throw new RangeError("Along Path guide reverses direction at an internal cusp.");
+        joinError = Math.max(joinError, norm(subtract(a, b)));
+      }
+      previous = leaf;
+      const next = leaf.chord - compensation2, sum = length + next;
+      compensation2 = sum - length - next;
+      length = sum;
+      uncertainty += leaf.excess;
+      normalSlope = Math.max(normalSlope, norm(subtract(leaf.last.normal, leaf.first.normal)) / leaf.chord);
+      sag = Math.max(sag, leaf.sag);
+      normalError = Math.max(normalError, leaf.normalError);
+    }
+    if (!(length > 0) || !Number.isFinite(length)) throw new RangeError("Guide length must be finite and positive.");
+    uncertainty += roundoff + length * Number.EPSILON * 128;
+    const distanceError = uncertainty * distanceFactor(length);
+    error = sag + maxDisplacement * (normalError + joinError) + (1 + maxDisplacement * normalSlope) * distanceError + roundoff;
+    if (Number.isFinite(error) && error <= tolerance / 4) break;
+    if (pass === 23) throw new RangeError("Along Path cannot certify its guide-distance and normal error.");
+    target /= 2;
+    pending = leaves.flatMap((leaf) => {
+      if (leaf.depth >= MAX_GUIDE_DEPTH) throw new RangeError("Guide measurement reached numerical nonprogress.");
+      const [left, right] = splitBendSpan(leaf.span);
+      return [{ span: left, depth: leaf.depth + 1 }, { span: right, depth: leaf.depth + 1 }];
+    });
+  }
+  const knots = [{ ...leaves[0].first, distance: 0 }];
+  let cumulative = 0, compensation = 0;
+  for (const leaf of leaves) {
+    const next = leaf.chord - compensation, sum = cumulative + next;
+    compensation = sum - cumulative - next;
+    cumulative = sum;
+    knots.push({ ...leaf.last, distance: cumulative });
+  }
+  if (prepared.closed) knots[knots.length - 1] = { ...knots[0], distance: length };
+  function field(distance, wrap) {
+    charge();
+    if (!Number.isFinite(distance)) throw new RangeError("Mapped guide distance overflowed.");
+    if (wrap) distance = (distance % length + length) % length;
+    if (distance < 0 || distance > length) {
+      const end = distance < 0 ? knots[0] : knots.at(-1);
+      const d = distance - end.distance;
+      return { normal: end.normal, point: [end.point[0] + d * end.normal[1], end.point[1] - d * end.normal[0]] };
+    }
+    if (distance === length) return knots.at(-1);
+    const i = index(distance), a = knots[i], b = knots[i + 1];
+    const u = (distance - a.distance) / (b.distance - a.distance);
+    return { point: lerp(a.point, b.point, u), normal: lerp(a.normal, b.normal, u) };
+  }
+  function index(distance) {
+    let low = 0, high = knots.length - 1;
+    while (low + 1 < high) {
+      const mid = Math.floor((low + high) / 2);
+      if (knots[mid].distance <= distance) low = mid;
+      else high = mid;
+    }
+    return low;
+  }
+  function envelope(low, high, wrap, visit) {
+    visit(low, field(low, wrap));
+    visit(high, field(high, wrap));
+    if (!wrap) {
+      for (let i = index(Math.max(0, low)); i < knots.length && knots[i].distance <= high; i++) {
+        if (knots[i].distance >= low) {
+          charge();
+          visit(knots[i].distance, knots[i]);
+        }
+      }
+    } else {
+      const firstLap = Math.floor(low / length), lastLap = Math.floor(high / length);
+      if (!Number.isSafeInteger(firstLap) || !Number.isSafeInteger(lastLap) || lastLap - firstLap > MAX_GUIDE_WORK) throw new RangeError("Too many guide laps to certify.");
+      for (let lap = firstLap; lap <= lastLap; lap++) {
+        charge();
+        const offset = lap * length;
+        for (let i = index(Math.max(0, low - offset)); i < knots.length && knots[i].distance + offset <= high; i++) {
+          const s = knots[i].distance + offset;
+          if (s >= low) {
+            charge();
+            visit(s, knots[i]);
+          }
+        }
+      }
+    }
+  }
+  return {
+    length,
+    uncertainty,
+    error,
+    field,
+    knots,
+    /** Conservative full-field residual, not a sampled flatness heuristic. */
+    chordError(low, high, s0, s1, d, ds, dds, dy, ddy, wrap) {
+      const first = field(s0, wrap), last = field(s1, wrap);
+      const delta = s1 - s0;
+      const v = delta === 0 ? [0, 0] : scaleVector(subtract(last.point, first.point), 1 / delta);
+      const q = delta === 0 ? [0, 0] : scaleVector(subtract(last.normal, first.normal), 1 / delta);
+      const baseNormal = (s) => add(first.normal, scaleVector(q, s - s0));
+      let positionResidual = 0, normalResidual = 0;
+      envelope(low, high, wrap, (s, value) => {
+        positionResidual = Math.max(positionResidual, norm(subtract(value.point, add(first.point, scaleVector(v, s - s0)))));
+        normalResidual = Math.max(normalResidual, norm(subtract(value.normal, baseNormal(s))));
+      });
+      const baseNormalSize = Math.max(norm(baseNormal(low)), norm(baseNormal(high)));
+      const polynomialError = ((norm(v) + d * norm(q)) * dds + baseNormalSize * ddy + 2 * norm(q) * ds * dy) / 8;
+      return error + polynomialError + positionResidual + d * normalResidual;
+    }
+  };
+}
+function certifyLeaf(span, depth) {
+  if ("arc" in span && Math.abs(span.arc.sweep) > Math.PI / 2) return void 0;
+  const a = bendSpanPoint(span, 0), b = bendSpanPoint(span, 1), chordVector = subtract(b, a), chord = norm(chordVector);
+  if (!(chord > 0) || !Number.isFinite(chord)) return void 0;
+  const axis = scaleVector(chordVector, 1 / chord);
+  let ratio = 0, minProjection = Infinity;
+  const hull = derivativeHull(span);
+  for (const vector of hull) {
+    const magnitude = norm(vector);
+    if (magnitude === 0) {
+      minProjection = 0;
+      continue;
+    }
+    const v = scaleVector(vector, 1 / magnitude);
+    const projection = v[0] * axis[0] + v[1] * axis[1];
+    if (!(projection > 0)) return void 0;
+    minProjection = Math.min(minProjection, projection * magnitude);
+    ratio = Math.max(ratio, Math.abs(v[0] * axis[1] - v[1] * axis[0]) / projection);
+  }
+  const hyp = Math.hypot(1, ratio);
+  const excess = chord * ratio * (ratio / (hyp + 1));
+  const eta = ratio * Math.sqrt(2 / (hyp * (hyp + 1)));
+  const first = normal(tangent(span, false)), last = normal(tangent(span, true));
+  let normalError = 2 * ratio / hyp;
+  if (minProjection > 0) {
+    let m, acceleration, jerk;
+    if ("points" in span) {
+      const degree = span.points.length - 1;
+      m = minProjection * degree;
+      const second = hull.slice(1).map((v, i) => scaleVector(subtract(v, hull[i]), degree * (degree - 1)));
+      acceleration = Math.max(0, ...second.map(norm));
+      jerk = Math.max(0, ...second.slice(1).map((v, i) => norm(subtract(v, second[i])) * (degree - 2)));
+    } else {
+      const h = Math.abs(span.arc.sweep), basis = Math.hypot(span.arc.ux, span.arc.uy) + Math.hypot(span.arc.vx, span.arc.vy);
+      m = minProjection * h;
+      acceleration = basis * h * h;
+      jerk = acceleration * h;
+    }
+    const lengthOverSpeed = (chord + excess) / m;
+    const error = (jerk / m + 4 * (acceleration / m) ** 2) * lengthOverSpeed ** 2 / 8;
+    if (Number.isFinite(error)) normalError = Math.min(normalError, error);
+  }
+  return { span, depth, first: { point: a, normal: first }, last: { point: b, normal: last }, chord, excess, sag: (chord + excess) * eta / 2, normalError };
+}
+function derivativeHull(span) {
+  if ("points" in span) return span.points.slice(1).map((point, i) => subtract(point, span.points[i]));
+  const a = span.arc;
+  return [a.startAngle, a.startAngle + a.sweep].map((theta) => [
+    Math.sign(a.sweep) * (-a.ux * Math.sin(theta) + a.vx * Math.cos(theta)),
+    Math.sign(a.sweep) * (-a.uy * Math.sin(theta) + a.vy * Math.cos(theta))
+  ]);
+}
+function tangent(span, end) {
+  const vectors = derivativeHull(span);
+  const vector = (end ? [...vectors].reverse() : vectors).find((v) => norm(v) > 0);
+  if (!vector) throw new RangeError("Guide has no limiting tangent.");
+  const length = norm(vector);
+  return scaleVector(vector, 1 / length);
+}
+function sameTangent(a, b) {
+  if (norm(subtract(a, b)) > JOIN_ROUNDOFF) throw new RangeError("Along Path requires smooth directed guide joins; corners and cusps are unsupported.");
+}
+function straightSpan(span) {
+  if (!("points" in span)) return span;
+  const a = span.points[0], b = span.points.at(-1), vector = subtract(b, a), length = norm(vector);
+  if (!(length > 0) || !Number.isFinite(length)) return span;
+  const direction = scaleVector(vector, 1 / length);
+  if (!span.points.every((p) => {
+    const v = subtract(p, a);
+    return v[0] * direction[1] - v[1] * direction[0] === 0;
+  })) return span;
+  const values = derivativeHull(span).map((v) => v[0] * direction[0] + v[1] * direction[1]);
+  let minimum = Math.min(values[0], values.at(-1));
+  if (values.length === 3) {
+    const denominator = values[0] - 2 * values[1] + values[2];
+    const t = (values[0] - values[1]) / denominator;
+    if (t > 0 && t < 1) minimum = Math.min(minimum, (1 - t) ** 2 * values[0] + 2 * t * (1 - t) * values[1] + t * t * values[2]);
+  }
+  if (minimum < -length * Number.EPSILON * 16) throw new RangeError("Guide reverses direction at a cusp.");
+  return { points: [a, b] };
+}
+function normal(v) {
+  return [-v[1], v[0]];
+}
+function norm(v) {
+  return Math.hypot(v[0], v[1]);
+}
+function add(a, b) {
+  return [a[0] + b[0], a[1] + b[1]];
+}
+function subtract(a, b) {
+  return [a[0] - b[0], a[1] - b[1]];
+}
+function scaleVector(a, scale) {
+  return [a[0] * scale, a[1] * scale];
+}
+function lerp(a, b, t) {
+  return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+}
+export {
+  measureBendGuide,
+  prepareBendGuide
+};
+//# sourceMappingURL=path-bend-guide.js.map

package/dist/lib/geometry/path-bend-guide.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/path-bend-guide.ts"],
+  "sourcesContent": ["import { ellipseParameters, singularArcPoints } from './path-arc.js';\nimport { bendSpanBounds, bendSpanPoint, bendSpans, splitBendSpan, type BendPoint, type BendSpan } from './path-bend-spans.js';\nimport { PathGeometry } from './path-geometry.js';\n\ninterface Field { readonly point: BendPoint; readonly normal: BendPoint }\ninterface Leaf {\n  readonly span: BendSpan; readonly depth: number;\n  readonly first: Field; readonly last: Field;\n  readonly chord: number; readonly excess: number;\n  readonly sag: number; readonly normalError: number;\n}\ninterface Knot extends Field { readonly distance: number }\nexport interface PreparedBendGuide {\n  readonly spans: readonly BendSpan[];\n  readonly closed: boolean;\n  readonly scale: number;\n}\n\n// Includes failed refinement and field-envelope visits. No resource survives a call.\nconst MAX_GUIDE_WORK = 2_000_000;\nconst MAX_GUIDE_LEAVES = 131_072;\nconst MAX_GUIDE_DEPTH = 48;\nconst JOIN_ROUNDOFF = 512 * Number.EPSILON;\n\n/** Validate all guide contours and joins, even if the source uses only part. */\nexport function prepareBendGuide(path: PathGeometry): PreparedBendGuide {\n  const spans: BendSpan[] = [];\n  let moves = 0, closed = false, scale = 0;\n  for (const item of bendSpans(path)) {\n    if (item.type === 'move') {\n      if (++moves > 1) throw new RangeError('Along Path requires exactly one guide contour.');\n      scale = Math.max(scale, ...item.point.map(Math.abs));\n    } else if (item.type === 'close') closed = true;\n    else {\n      closed = false;\n      const bounds = bendSpanBounds(item.span);\n      scale = Math.max(scale, Math.abs(bounds.xmin), Math.abs(bounds.xmax), Math.abs(bounds.ymin), Math.abs(bounds.ymax));\n      if ('arc' in item.span && !ellipseParameters(item.span.arc)) {\n        const points = [bendSpanPoint(item.span, 0), ...singularArcPoints(item.span.arc)];\n        for (let i = 1; i < points.length; i++) append({ points: [points[i - 1], points[i]] });\n      } else append(item.span);\n    }\n  }\n  if (!spans.length) throw new RangeError('Along Path requires a guide of positive length.');\n  if (closed) sameTangent(tangent(spans.at(-1)!, true), tangent(spans[0], false));\n  return { spans, closed, scale };\n\n  function append(raw: BendSpan) {\n    const b = bendSpanBounds(raw);\n    // Numerically coincident endpoints/control hulls carry no reliable direction.\n    if (Math.hypot(b.xmax - b.xmin, b.ymax - b.ymin) <= scale * Number.EPSILON * 32) return;\n    const span = straightSpan(raw);\n    const first = tangent(span, false), last = tangent(span, true);\n    if (spans.length) sameTangent(tangent(spans.at(-1)!, true), first);\n    if (![...first, ...last].every(Number.isFinite)) throw new RangeError('Guide limiting tangent is not finite.');\n    spans.push(span);\n  }\n}\n\n/**\n * A continuous piecewise-linear position/normal field with a certified error\n * against the true arc-length field. Interpolated normals are deliberately NOT\n * renormalized: this keeps the internal mapping bilinear within each leaf.\n */\nexport function measureBendGuide(\n  prepared: PreparedBendGuide,\n  tolerance: number,\n  maxDisplacement: number,\n  distanceFactor: (length: number) => number,\n) {\n  let work = 0;\n  const charge = () => { if (++work > MAX_GUIDE_WORK) throw new RangeError('Along Path exceeded its guide work budget.'); };\n  const roundoff = prepared.scale * Number.EPSILON * 128;\n  if (!Number.isFinite(roundoff) || roundoff >= tolerance / 16) throw new RangeError('Guide coordinates cannot support the requested tolerance.');\n  let pending = prepared.spans.map(span => ({ span, depth: 0 }));\n  let leaves: Leaf[] = [];\n  let target = tolerance / 32;\n  let length = 0, uncertainty = 0, error = Infinity;\n  for (let pass = 0; pass < 24; pass++) {\n    leaves = [];\n    const stack = [...pending].reverse();\n    while (stack.length) {\n      charge();\n      const { span, depth } = stack.pop()!;\n      const leaf = certifyLeaf(span, depth);\n      if (leaf && leaf.sag + maxDisplacement * leaf.normalError <= target) {\n        if (leaves.length >= MAX_GUIDE_LEAVES) throw new RangeError('Along Path exceeded its guide subdivision budget.');\n        leaves.push(leaf);\n      } else {\n        if (depth >= MAX_GUIDE_DEPTH) throw new RangeError('Guide has a cusp, reversal, or numerically uncertifiable tangent.');\n        const [left, right] = splitBendSpan(span);\n        stack.push({ span: right, depth: depth + 1 }, { span: left, depth: depth + 1 });\n      }\n    }\n    length = 0; uncertainty = 0;\n    let compensation = 0, sag = 0, normalError = 0, normalSlope = 0, joinError = JOIN_ROUNDOFF;\n    let previous: Leaf | undefined;\n    for (const leaf of leaves) {\n      // Original segment joins were validated before subdivision. Inside a\n      // polynomial/ellipse, the two limiting tangents at a split must agree or\n      // reverse at a cusp. Subtracted tiny control edges amplify roundoff, so\n      // do not reuse the original-join angular threshold here. Reject reversals\n      // and account for the shared-knot normal replacement in the error bound.\n      if (previous) {\n        const a = previous.last.normal, b = leaf.first.normal;\n        if (a[0] * b[0] + a[1] * b[1] <= 0) throw new RangeError('Along Path guide reverses direction at an internal cusp.');\n        joinError = Math.max(joinError, norm(subtract(a, b)));\n      }\n      previous = leaf;\n      // Compensated sums avoid accumulating an O(number-of-leaves) length bias.\n      const next = leaf.chord - compensation, sum = length + next;\n      compensation = (sum - length) - next; length = sum;\n      uncertainty += leaf.excess;\n      normalSlope = Math.max(normalSlope, norm(subtract(leaf.last.normal, leaf.first.normal)) / leaf.chord);\n      sag = Math.max(sag, leaf.sag); normalError = Math.max(normalError, leaf.normalError);\n    }\n    if (!(length > 0) || !Number.isFinite(length)) throw new RangeError('Guide length must be finite and positive.');\n    uncertainty += roundoff + length * Number.EPSILON * 128;\n    // phi maps chord distance to true arc distance and has inverse Lipschitz\n    // constant <=1. Its deviation from identity is bounded by total excess.\n    // distanceFactor includes fit/alignment and any unwrapped guide laps.\n    const distanceError = uncertainty * distanceFactor(length);\n    error = sag + maxDisplacement * (normalError + joinError) + (1 + maxDisplacement * normalSlope) * distanceError + roundoff;\n    if (Number.isFinite(error) && error <= tolerance / 4) break;\n    if (pass === 23) throw new RangeError('Along Path cannot certify its guide-distance and normal error.');\n    target /= 2;\n    pending = leaves.flatMap(leaf => {\n      if (leaf.depth >= MAX_GUIDE_DEPTH) throw new RangeError('Guide measurement reached numerical nonprogress.');\n      const [left, right] = splitBendSpan(leaf.span);\n      return [{ span: left, depth: leaf.depth + 1 }, { span: right, depth: leaf.depth + 1 }];\n    });\n  }\n  const knots: Knot[] = [{ ...leaves[0].first, distance: 0 }];\n  let cumulative = 0, compensation = 0;\n  for (const leaf of leaves) {\n    const next = leaf.chord - compensation, sum = cumulative + next;\n    compensation = (sum - cumulative) - next; cumulative = sum;\n    knots.push({ ...leaf.last, distance: cumulative });\n  }\n  // Joins are already checked. Sharing the endpoint field prevents tiny normal\n  // jumps at the closed seam from becoming artificial output edges.\n  if (prepared.closed) knots[knots.length - 1] = { ...knots[0], distance: length };\n\n  function field(distance: number, wrap: boolean): Field {\n    charge();\n    if (!Number.isFinite(distance)) throw new RangeError('Mapped guide distance overflowed.');\n    if (wrap) distance = ((distance % length) + length) % length;\n    if (distance < 0 || distance > length) {\n      const end = distance < 0 ? knots[0] : knots.at(-1)!;\n      const d = distance - end.distance;\n      return { normal: end.normal, point: [end.point[0] + d * end.normal[1], end.point[1] - d * end.normal[0]] };\n    }\n    if (distance === length) return knots.at(-1)!;\n    const i = index(distance), a = knots[i], b = knots[i + 1];\n    const u = (distance - a.distance) / (b.distance - a.distance);\n    return { point: lerp(a.point, b.point, u), normal: lerp(a.normal, b.normal, u) };\n  }\n  function index(distance: number): number {\n    let low = 0, high = knots.length - 1;\n    while (low + 1 < high) {\n      const mid = Math.floor((low + high) / 2);\n      if (knots[mid].distance <= distance) low = mid; else high = mid;\n    }\n    return low;\n  }\n  function envelope(low: number, high: number, wrap: boolean, visit: (distance: number, value: Field) => void) {\n    visit(low, field(low, wrap)); visit(high, field(high, wrap));\n    if (!wrap) {\n      for (let i = index(Math.max(0, low)); i < knots.length && knots[i].distance <= high; i++) {\n        if (knots[i].distance >= low) { charge(); visit(knots[i].distance, knots[i]); }\n      }\n    } else {\n      const firstLap = Math.floor(low / length), lastLap = Math.floor(high / length);\n      if (!Number.isSafeInteger(firstLap) || !Number.isSafeInteger(lastLap) || lastLap - firstLap > MAX_GUIDE_WORK) throw new RangeError('Too many guide laps to certify.');\n      for (let lap = firstLap; lap <= lastLap; lap++) {\n        charge();\n        const offset = lap * length;\n        for (let i = index(Math.max(0, low - offset)); i < knots.length && knots[i].distance + offset <= high; i++) {\n          const s = knots[i].distance + offset;\n          if (s >= low) { charge(); visit(s, knots[i]); }\n        }\n      }\n    }\n  }\n  return {\n    length, uncertainty, error, field, knots,\n    /** Conservative full-field residual, not a sampled flatness heuristic. */\n    chordError(low: number, high: number, s0: number, s1: number, d: number, ds: number, dds: number, dy: number, ddy: number, wrap: boolean): number {\n      const first = field(s0, wrap), last = field(s1, wrap);\n      const delta = s1 - s0;\n      const v = delta === 0 ? [0, 0] as const : scaleVector(subtract(last.point, first.point), 1 / delta);\n      const q = delta === 0 ? [0, 0] as const : scaleVector(subtract(last.normal, first.normal), 1 / delta);\n      const baseNormal = (s: number): BendPoint => add(first.normal, scaleVector(q, s - s0));\n      let positionResidual = 0, normalResidual = 0;\n      envelope(low, high, wrap, (s, value) => {\n        positionResidual = Math.max(positionResidual, norm(subtract(value.point, add(first.point, scaleVector(v, s - s0)))));\n        normalResidual = Math.max(normalResidual, norm(subtract(value.normal, baseNormal(s))));\n      });\n      const baseNormalSize = Math.max(norm(baseNormal(low)), norm(baseNormal(high)));\n      const polynomialError = ((norm(v) + d * norm(q)) * dds + baseNormalSize * ddy + 2 * norm(q) * ds * dy) / 8;\n      return error + polynomialError + positionResidual + d * normalResidual;\n    },\n  };\n}\n\nfunction certifyLeaf(span: BendSpan, depth: number): Leaf | undefined {\n  if ('arc' in span && Math.abs(span.arc.sweep) > Math.PI / 2) return undefined;\n  const a = bendSpanPoint(span, 0), b = bendSpanPoint(span, 1), chordVector = subtract(b, a), chord = norm(chordVector);\n  if (!(chord > 0) || !Number.isFinite(chord)) return undefined;\n  const axis = scaleVector(chordVector, 1 / chord);\n  let ratio = 0, minProjection = Infinity;\n  const hull = derivativeHull(span);\n  for (const vector of hull) {\n    const magnitude = norm(vector);\n    if (magnitude === 0) { minProjection = 0; continue; }\n    const v = scaleVector(vector, 1 / magnitude);\n    const projection = v[0] * axis[0] + v[1] * axis[1];\n    if (!(projection > 0)) return undefined;\n    minProjection = Math.min(minProjection, projection * magnitude);\n    ratio = Math.max(ratio, Math.abs(v[0] * axis[1] - v[1] * axis[0]) / projection);\n  }\n  const hyp = Math.hypot(1, ratio);\n  // All derivatives lie in a directed cone around the chord. Its minimum\n  // projection bounds length; its diameter bounds normal interpolation error.\n  const excess = chord * ratio * (ratio / (hyp + 1)); // chord*(hyp-1), without cancellation\n  const eta = ratio * Math.sqrt(2 / (hyp * (hyp + 1)));\n  const first = normal(tangent(span, false)), last = normal(tangent(span, true));\n  let normalError = 2 * ratio / hyp;\n  // On regular spans use the second derivative of N with respect to arc length.\n  // |N''| <= Q/m\u00B3 + 4A\u00B2/m\u2074, where m bounds speed below and A,Q bound the\n  // second/third parameter derivatives. The cone remains the fallback at\n  // removable stationary endpoints, where m can be zero but the normal exists.\n  if (minProjection > 0) {\n    let m: number, acceleration: number, jerk: number;\n    if ('points' in span) {\n      const degree = span.points.length - 1;\n      m = minProjection * degree;\n      const second = hull.slice(1).map((v, i) => scaleVector(subtract(v, hull[i]), degree * (degree - 1)));\n      acceleration = Math.max(0, ...second.map(norm));\n      jerk = Math.max(0, ...second.slice(1).map((v, i) => norm(subtract(v, second[i])) * (degree - 2)));\n    } else {\n      const h = Math.abs(span.arc.sweep), basis = Math.hypot(span.arc.ux, span.arc.uy) + Math.hypot(span.arc.vx, span.arc.vy);\n      m = minProjection * h; acceleration = basis * h * h; jerk = acceleration * h;\n    }\n    const lengthOverSpeed = (chord + excess) / m;\n    const error = (jerk / m + 4 * (acceleration / m) ** 2) * lengthOverSpeed ** 2 / 8;\n    if (Number.isFinite(error)) normalError = Math.min(normalError, error);\n  }\n  return { span, depth, first: { point: a, normal: first }, last: { point: b, normal: last }, chord, excess, sag: (chord + excess) * eta / 2, normalError };\n}\n\nfunction derivativeHull(span: BendSpan): readonly BendPoint[] {\n  if ('points' in span) return span.points.slice(1).map((point, i) => subtract(point, span.points[i]));\n  const a = span.arc;\n  return [a.startAngle, a.startAngle + a.sweep].map(theta => [\n    Math.sign(a.sweep) * (-a.ux * Math.sin(theta) + a.vx * Math.cos(theta)),\n    Math.sign(a.sweep) * (-a.uy * Math.sin(theta) + a.vy * Math.cos(theta)),\n  ]);\n}\nfunction tangent(span: BendSpan, end: boolean): BendPoint {\n  const vectors = derivativeHull(span);\n  const vector = (end ? [...vectors].reverse() : vectors).find(v => norm(v) > 0);\n  if (!vector) throw new RangeError('Guide has no limiting tangent.');\n  const length = norm(vector);\n  return scaleVector(vector, 1 / length);\n}\nfunction sameTangent(a: BendPoint, b: BendPoint) {\n  if (norm(subtract(a, b)) > JOIN_ROUNDOFF) throw new RangeError('Along Path requires smooth directed guide joins; corners and cusps are unsupported.');\n}\n\nfunction straightSpan(span: BendSpan): BendSpan {\n  if (!('points' in span)) return span;\n  const a = span.points[0], b = span.points.at(-1)!, vector = subtract(b, a), length = norm(vector);\n  if (!(length > 0) || !Number.isFinite(length)) return span;\n  const direction = scaleVector(vector, 1 / length);\n  if (!span.points.every(p => {\n    const v = subtract(p, a);\n    return v[0] * direction[1] - v[1] * direction[0] === 0;\n  })) return span;\n  const values = derivativeHull(span).map(v => v[0] * direction[0] + v[1] * direction[1]);\n  let minimum = Math.min(values[0], values.at(-1)!);\n  if (values.length === 3) {\n    const denominator = values[0] - 2 * values[1] + values[2];\n    const t = (values[0] - values[1]) / denominator;\n    if (t > 0 && t < 1) minimum = Math.min(minimum, (1 - t) ** 2 * values[0] + 2 * t * (1 - t) * values[1] + t * t * values[2]);\n  }\n  if (minimum < -length * Number.EPSILON * 16) throw new RangeError('Guide reverses direction at a cusp.');\n  return { points: [a, b] };\n}\nfunction normal(v: BendPoint): BendPoint { return [-v[1], v[0]]; }\nfunction norm(v: BendPoint): number { return Math.hypot(v[0], v[1]); }\nfunction add(a: BendPoint, b: BendPoint): BendPoint { return [a[0] + b[0], a[1] + b[1]]; }\nfunction subtract(a: BendPoint, b: BendPoint): BendPoint { return [a[0] - b[0], a[1] - b[1]]; }\nfunction scaleVector(a: BendPoint, scale: number): BendPoint { return [a[0] * scale, a[1] * scale]; }\nfunction lerp(a: BendPoint, b: BendPoint, t: number): BendPoint { return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]; }\n"],
+  "mappings": "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",
+  "names": ["compensation"]
+}

package/dist/lib/geometry/path-bend-spans.d.ts

@@ -0,0 +1,31 @@
+import { type ArcSegment } from './path-arc.js';
+import { PathGeometry } from './path-geometry.js';
+/** Private continuous source spans; bounds use the span's local parameter [0,1]. */
+export type BendPoint = readonly [number, number];
+export type BendSpan = {
+    readonly points: readonly BendPoint[];
+} | {
+    readonly arc: ArcSegment;
+};
+export interface BendBounds {
+    readonly xmin: number;
+    readonly xmax: number;
+    readonly ymin: number;
+    readonly ymax: number;
+    readonly dx: number;
+    readonly dy: number;
+    readonly ddx: number;
+    readonly ddy: number;
+}
+export declare function bendSpans(path: PathGeometry): Generator<{
+    type: 'move';
+    point: BendPoint;
+} | {
+    type: 'span';
+    span: BendSpan;
+} | {
+    type: 'close';
+}>;
+export declare function bendSpanPoint(span: BendSpan, t: number): BendPoint;
+export declare function splitBendSpan(span: BendSpan): readonly [BendSpan, BendSpan];
+export declare function bendSpanBounds(span: BendSpan): BendBounds;

package/dist/lib/geometry/path-bend-spans.js

@@ -0,0 +1,109 @@
+import { arcPoint } from "./path-arc.js";
+function* bendSpans(path) {
+  let current = [0, 0], start = current;
+  for (const segment of path) {
+    switch (segment.type) {
+      case "move":
+        current = start = [segment.x, segment.y];
+        yield { type: "move", point: current };
+        break;
+      case "line": {
+        const end = [segment.x, segment.y];
+        yield { type: "span", span: { points: [current, end] } };
+        current = end;
+        break;
+      }
+      case "quadratic": {
+        const end = [segment.x, segment.y];
+        yield { type: "span", span: { points: [current, [segment.cpx, segment.cpy], end] } };
+        current = end;
+        break;
+      }
+      case "cubic": {
+        const end = [segment.x, segment.y];
+        yield { type: "span", span: { points: [current, [segment.cp1x, segment.cp1y], [segment.cp2x, segment.cp2y], end] } };
+        current = end;
+        break;
+      }
+      case "arc": {
+        const first = arcPoint(segment, segment.startAngle);
+        if (current[0] !== first[0] || current[1] !== first[1]) {
+          yield { type: "span", span: { points: [current, first] } };
+        }
+        yield { type: "span", span: { arc: segment } };
+        current = arcPoint(segment, segment.startAngle + segment.sweep);
+        break;
+      }
+      case "close":
+        yield { type: "span", span: { points: [current, start] } };
+        yield { type: "close" };
+        current = start;
+        break;
+    }
+  }
+}
+function bendSpanPoint(span, t) {
+  if ("arc" in span) return arcPoint(span.arc, span.arc.startAngle + span.arc.sweep * t);
+  let points = span.points;
+  while (points.length > 1) {
+    points = points.slice(1).map((b, i) => [
+      (1 - t) * points[i][0] + t * b[0],
+      (1 - t) * points[i][1] + t * b[1]
+    ]);
+  }
+  return points[0];
+}
+function splitBendSpan(span) {
+  if ("arc" in span) {
+    const arc = span.arc, sweep = arc.sweep / 2;
+    return [{ arc: { ...arc, sweep } }, { arc: { ...arc, startAngle: arc.startAngle + sweep, sweep } }];
+  }
+  let row = span.points;
+  const left = [row[0]], right = [row.at(-1)];
+  while (row.length > 1) {
+    row = row.slice(1).map((b, i) => [row[i][0] / 2 + b[0] / 2, row[i][1] / 2 + b[1] / 2]);
+    left.push(row[0]);
+    right.push(row.at(-1));
+  }
+  return [{ points: left }, { points: right.reverse() }];
+}
+function bendSpanBounds(span) {
+  if ("arc" in span) {
+    const a = span.arc;
+    const [xmin, xmax] = arcRange(a.cx, a.ux, a.vx, a.startAngle, a.sweep);
+    const [ymin, ymax] = arcRange(a.cy, a.uy, a.vy, a.startAngle, a.sweep);
+    const dx = Math.hypot(a.ux, a.vx) * Math.abs(a.sweep);
+    const dy = Math.hypot(a.uy, a.vy) * Math.abs(a.sweep);
+    return { xmin, xmax, ymin, ymax, dx, dy, ddx: dx * Math.abs(a.sweep), ddy: dy * Math.abs(a.sweep) };
+  }
+  const p = span.points, n = p.length - 1;
+  const xs = p.map((point) => point[0]), ys = p.map((point) => point[1]);
+  const first = (axis) => Math.max(0, ...p.slice(1).map((b, i) => Math.abs(n * (b[axis] - p[i][axis]))));
+  const second = (axis) => Math.max(0, ...p.slice(2).map((b, i) => Math.abs(n * (n - 1) * (b[axis] - p[i + 1][axis] - (p[i + 1][axis] - p[i][axis])))));
+  return {
+    xmin: Math.min(...xs),
+    xmax: Math.max(...xs),
+    ymin: Math.min(...ys),
+    ymax: Math.max(...ys),
+    dx: first(0),
+    dy: first(1),
+    ddx: second(0),
+    ddy: second(1)
+  };
+}
+function arcRange(center, u, v, start, sweep) {
+  const values = [center + u * Math.cos(start) + v * Math.sin(start), center + u * Math.cos(start + sweep) + v * Math.sin(start + sweep)];
+  const low = Math.min(start, start + sweep), high = Math.max(start, start + sweep);
+  const phase = Math.atan2(v, u);
+  for (let k = Math.ceil((low - phase) / Math.PI); k <= Math.floor((high - phase) / Math.PI); k++) {
+    values.push(center + (k % 2 === 0 ? 1 : -1) * Math.hypot(u, v));
+  }
+  return [Math.min(...values), Math.max(...values)];
+}
+export {
+  bendSpanBounds,
+  bendSpanPoint,
+  bendSpans,
+  splitBendSpan
+};
+//# sourceMappingURL=path-bend-spans.js.map

package/dist/lib/geometry/path-bend-spans.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/path-bend-spans.ts"],
+  "sourcesContent": ["import { arcPoint, type ArcSegment } from './path-arc.js';\nimport { PathGeometry } from './path-geometry.js';\n\n/** Private continuous source spans; bounds use the span's local parameter [0,1]. */\nexport type BendPoint = readonly [number, number];\nexport type BendSpan = { readonly points: readonly BendPoint[] } | { readonly arc: ArcSegment };\nexport interface BendBounds {\n  readonly xmin: number; readonly xmax: number;\n  readonly ymin: number; readonly ymax: number;\n  readonly dx: number; readonly dy: number;\n  readonly ddx: number; readonly ddy: number;\n}\n\nexport function* bendSpans(path: PathGeometry): Generator<\n  { type: 'move'; point: BendPoint } | { type: 'span'; span: BendSpan } | { type: 'close' }\n> {\n  let current: BendPoint = [0, 0], start = current;\n  for (const segment of path) {\n    switch (segment.type) {\n      case 'move':\n        current = start = [segment.x, segment.y];\n        yield { type: 'move', point: current };\n        break;\n      case 'line': {\n        const end: BendPoint = [segment.x, segment.y];\n        yield { type: 'span', span: { points: [current, end] } };\n        current = end;\n        break;\n      }\n      case 'quadratic': {\n        const end: BendPoint = [segment.x, segment.y];\n        yield { type: 'span', span: { points: [current, [segment.cpx, segment.cpy], end] } };\n        current = end;\n        break;\n      }\n      case 'cubic': {\n        const end: BendPoint = [segment.x, segment.y];\n        yield { type: 'span', span: { points: [current, [segment.cp1x, segment.cp1y], [segment.cp2x, segment.cp2y], end] } };\n        current = end;\n        break;\n      }\n      case 'arc': {\n        const first = arcPoint(segment, segment.startAngle);\n        if (current[0] !== first[0] || current[1] !== first[1]) {\n          yield { type: 'span', span: { points: [current, first] } };\n        }\n        yield { type: 'span', span: { arc: segment } };\n        current = arcPoint(segment, segment.startAngle + segment.sweep);\n        break;\n      }\n      case 'close':\n        yield { type: 'span', span: { points: [current, start] } };\n        yield { type: 'close' };\n        current = start;\n        break;\n    }\n  }\n}\n\nexport function bendSpanPoint(span: BendSpan, t: number): BendPoint {\n  if ('arc' in span) return arcPoint(span.arc, span.arc.startAngle + span.arc.sweep * t);\n  let points = span.points;\n  while (points.length > 1) {\n    points = points.slice(1).map((b, i) => [\n      (1 - t) * points[i][0] + t * b[0], (1 - t) * points[i][1] + t * b[1],\n    ]);\n  }\n  return points[0];\n}\n\nexport function splitBendSpan(span: BendSpan): readonly [BendSpan, BendSpan] {\n  if ('arc' in span) {\n    const arc = span.arc, sweep = arc.sweep / 2;\n    return [{ arc: { ...arc, sweep } }, { arc: { ...arc, startAngle: arc.startAngle + sweep, sweep } }];\n  }\n  let row = span.points;\n  const left = [row[0]], right = [row.at(-1)!];\n  while (row.length > 1) {\n    row = row.slice(1).map((b, i) => [row[i][0] / 2 + b[0] / 2, row[i][1] / 2 + b[1] / 2]);\n    left.push(row[0]); right.push(row.at(-1)!);\n  }\n  return [{ points: left }, { points: right.reverse() }];\n}\n\nexport function bendSpanBounds(span: BendSpan): BendBounds {\n  if ('arc' in span) {\n    const a = span.arc;\n    const [xmin, xmax] = arcRange(a.cx, a.ux, a.vx, a.startAngle, a.sweep);\n    const [ymin, ymax] = arcRange(a.cy, a.uy, a.vy, a.startAngle, a.sweep);\n    const dx = Math.hypot(a.ux, a.vx) * Math.abs(a.sweep);\n    const dy = Math.hypot(a.uy, a.vy) * Math.abs(a.sweep);\n    return { xmin, xmax, ymin, ymax, dx, dy, ddx: dx * Math.abs(a.sweep), ddy: dy * Math.abs(a.sweep) };\n  }\n  const p = span.points, n = p.length - 1;\n  const xs = p.map(point => point[0]), ys = p.map(point => point[1]);\n  const first = (axis: number) => Math.max(0, ...p.slice(1).map((b, i) => Math.abs(n * (b[axis] - p[i][axis]))));\n  const second = (axis: number) => Math.max(0, ...p.slice(2).map((b, i) => Math.abs(n * (n - 1) * ((b[axis] - p[i + 1][axis]) - (p[i + 1][axis] - p[i][axis])))));\n  return {\n    xmin: Math.min(...xs), xmax: Math.max(...xs), ymin: Math.min(...ys), ymax: Math.max(...ys),\n    dx: first(0), dy: first(1), ddx: second(0), ddy: second(1),\n  };\n}\n\nfunction arcRange(center: number, u: number, v: number, start: number, sweep: number): readonly [number, number] {\n  const values = [center + u * Math.cos(start) + v * Math.sin(start), center + u * Math.cos(start + sweep) + v * Math.sin(start + sweep)];\n  const low = Math.min(start, start + sweep), high = Math.max(start, start + sweep);\n  const phase = Math.atan2(v, u);\n  for (let k = Math.ceil((low - phase) / Math.PI); k <= Math.floor((high - phase) / Math.PI); k++) {\n    values.push(center + (k % 2 === 0 ? 1 : -1) * Math.hypot(u, v));\n  }\n  return [Math.min(...values), Math.max(...values)];\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/lib/geometry/path-bending.d.ts

@@ -0,0 +1,90 @@
+import type { ArcBendTransformOptions, BendTransformOptions } from "./transform-bend.js";
+import { PathGeometry } from './path-geometry.js';
+export interface PathBendFrame {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * Circular guide geometry used when bending a path along an arc.
+ *
+ * @see {@link ArcBendTransformOptions}
+ */
+export interface PathBendArc {
+    /** Horizontal coordinate of the center. See {@link PathBendArc}. */
+    readonly cx: number;
+    /** Vertical coordinate of the center. See {@link PathBendArc}. */
+    readonly cy: number;
+    /** Radius in the coordinate system of this geometry or effect. See {@link PathBendArc}. */
+    readonly radius: number;
+    /** Angle at which the arc or slice begins. See {@link PathBendArc}. */
+    readonly startAngle: number;
+    /** Angular extent of the arc. See {@link PathBendArc}. */
+    readonly sweep: number;
+}
+/**
+ * Placement of the source along the beginning, center, or end of a bending guide.
+ *
+ * @see {@link BendTransformOptions}
+ */
+export type PathBendAlign = 'start' | 'center' | 'end';
+/**
+ * The source baseline used for bending: an edge, center, or explicit coordinate.
+ *
+ * @see {@link BendTransformOptions}
+ */
+export type PathBendBaseline = 'center' | 'top' | 'bottom' | number;
+/**
+ * Whether bending preserves source length or stretches it to the guide.
+ *
+ * @see {@link BendTransformOptions}
+ */
+export type PathBendFit = 'none' | 'stretch';
+/**
+ * Policy for source geometry extending beyond a bending guide.
+ *
+ * @see {@link BendTransformOptions}
+ */
+export type PathBendOverflow = 'error' | 'extend' | 'wrap';
+/**
+ * Source bounds, guide alignment, baseline, fitting, overflow, and approximation limits for path bending.
+ *
+ * @see {@link PathBendAlign}
+ * @see {@link PathBendBaseline}
+ * @see {@link PathBendFit}
+ * @see {@link PathBendOverflow}
+ */
+export interface PathBendOptions {
+    /**
+     * Source coordinate frame used to normalize the geometry before bending. See
+     * {@link PathBendFrame}.
+     */
+    readonly source: PathBendFrame;
+    /** Placement of the source length along the guide. See {@link PathBendAlign}. */
+    readonly align?: PathBendAlign;
+    /** Source baseline mapped onto the guide. See {@link PathBendBaseline}. */
+    readonly baseline?: PathBendBaseline;
+    /** Policy for fitting content within its available box. See {@link PathBendFit}. */
+    readonly fit?: PathBendFit;
+    /** Offset along the guide. See {@link PathBendOptions}. */
+    readonly offset?: number;
+    /** Offset perpendicular to the guide. See {@link PathBendOptions}. */
+    readonly normalOffset?: number;
+    /**
+     * Policy for geometry extending beyond the guide's available length. See
+     * {@link PathBendOverflow}.
+     */
+    readonly overflow?: PathBendOverflow;
+    /** Positive maximum geometric approximation error. See {@link PathBendOptions}. */
+    readonly tolerance: number;
+    /** Upper bound on the number of output path segments. See {@link PathBendOptions}. */
+    readonly maxSegments?: number;
+}
+export interface BendPathAlongArcOptions extends PathBendOptions {
+    readonly arc: PathBendArc;
+}
+/** Bends continuous geometry along an analytic circle; returns independent line geometry. */
+export declare function bendPathAlongArc(source: PathGeometry, options: Readonly<BendPathAlongArcOptions>): PathGeometry;
+/** Bends geometry by distance along one smooth guide contour. */
+export declare function bendPathAlongPath(source: PathGeometry, guide: PathGeometry, options: Readonly<PathBendOptions>): PathGeometry;