@weasel-js/geom 1.10.1 → 1.11.1

package/dist/nd/index.d.ts

@@ -1,30 +1,95 @@
+export { P as PORT_REACH, c as cubicAt, p as portControls, a as portCurvePoints } from '../portCurve-C5HDWuuV.js';
+
+/** Affine subspaces ("flats") over plain number arrays, in any dimension:
+ *  the points, lines and planes a snap resolves against. */
+type Vec = readonly number[];
+/** The affine subspace `at + span(dirs)`. `dirs` need not be orthonormal or
+ *  independent; a zero or repeated direction adds nothing. */
+interface Flat {
+    at: Vec;
+    dirs: readonly Vec[];
+}
+/** The flat's dimension: the rank of its directions. */
+declare function flatDim(f: Flat): number;
+/** The point of `f` nearest `p`. */
+declare function closestOnFlat(f: Flat, p: Vec): Vec;
+/** The nearest pair of points, one on each flat. Parallel flats have many
+ *  such pairs; this returns one of them. */
+declare function closestBetweenFlats(a: Flat, b: Flat): {
+    onA: Vec;
+    onB: Vec;
+};
+/** `a ∩ b`, or null when they miss each other by more than `eps`. */
+declare function intersectFlats(a: Flat, b: Flat, eps?: number): Flat | null;
+
+/** The snap resolver: every gesture's snap, in any dimension, as one search
+ *  over affine constraints on the move `δ`. */
+
+/** A `fallback` candidate holds only the axes no `target` claims. */
+type SnapTier = 'target' | 'fallback';
+/** What a probe stands for on the subject; sources match probes by role. */
+type ProbeRole = 'origin' | 'box' | 'geometry' | 'pointer';
+/** A point on the subject that should land on a locus. `role` says which
+ *  sources may match it. */
+interface SnapProbe {
+    id: string;
+    at: Vec;
+    role: ProbeRole;
+}
+/** One probe paired with one locus. `M` is the mark payload, opaque here. */
+interface SnapCandidate<M> {
+    /** `SnapProbe.id`. */
+    probe: string;
+    locus: Flat;
+    /** One interval per locus dir, in multiples of that dir. A solution
+     *  outside it fails the candidate. */
+    span?: readonly (readonly [number, number])[];
+    source: string;
+    /** Stable tiebreak: lower wins when everything else is equal. */
+    order: number;
+    tier: SnapTier;
+    reachPx: number;
+    /** When any required candidate exists, the result includes one of them,
+     *  whatever its reach. */
+    required?: boolean;
+    mark?: M;
+}
+/** One frame's snap: the probes, the input subspace, the raw move, and the candidates. */
+interface SnapProblem<M> {
+    probes: readonly SnapProbe[];
+    /** `H`, the subspace of δ-space the result stays inside. */
+    input: Flat;
+    /** The unsnapped move. */
+    delta0: Vec;
+    candidates: readonly SnapCandidate<M>[];
+    /** World to screen pixels. A non-finite result puts that position out of reach. */
+    toScreen(world: Vec): Vec;
+    /** Candidates kept per probe, nearest first, besides the required ones,
+     *  which are all kept. Default 24. */
+    poolSize?: number;
+    /** World-space tolerance for "on the locus". Default 1e-6. */
+    eps?: number;
+}
+/** The move `resolveSnap` chose and the candidates it meets. */
+interface SnapResolution<M> {
+    /** `closestOnFlat(input, delta0)` when nothing snaps. */
+    delta: Vec;
+    members: readonly SnapCandidate<M>[];
+    /** Every in-reach candidate the result meets: the ones whose marks show. */
+    satisfied: readonly SnapCandidate<M>[];
+    /** How many dimensions of `H` the result pins. */
+    codim: number;
+}
+/** The move nearest `delta0` within `H` that meets the best-ranked set of
+ *  candidates in reach, or `delta0` projected into `H` when none is. */
+declare function resolveSnap<M>(problem: SnapProblem<M>): SnapResolution<M>;
+
 /**
- * The cubic control points that make a curve leave a port along its normal and
- * arrive at the next against that port's normal — what makes a routed edge read
- * as plugged into a box rather than aimed at it.
- *
- * The rule is stated once, over loose components, and published as is from
- * `./nd`; the 2D barrel and `./3d` each wrap it in their own currency. Every
- * operation here is closed on the plane z = 0, so a planar problem answered
- * through the 3D wrapper returns the same numbers as through the 2D one, not an
- * approximation of them.
- */
-/** How far a control point reaches toward the other end, as a fraction of the
- *  straight-line distance between the two. */
-declare const PORT_REACH = 0.4;
-/**
- * `[c1, c2]` for the cubic from `a` to `b`.
- *
- * A null normal falls back to a plain lerp along the chord, which is what makes
- * an unported waypoint curve smoothly instead of kinking. The two ends are not
- * symmetric: `outNormal` points the way the curve departs, while `inNormal`
- * points out of the receiving port, so `c2` is pushed *along* it to arrive
- * against it.
+ * The line through `about` whose direction, measured in the plane `basis`
+ * spans (as an angle from `basis[0]` toward `basis[1]`), is the multiple of
+ * `step` nearest the direction from `about` to `toward`: a constrained
+ * gesture's input subspace, in any dimension. `basis` is orthonormal.
  */
-declare function portControls(a: readonly number[], b: readonly number[], outNormal: readonly number[] | null | undefined, inNormal: readonly number[] | null | undefined, reach?: number): [number[], number[]];
-/** A port curve sampled into `samples` points, excluding its start. */
-declare function portCurvePoints(a: readonly number[], b: readonly number[], outNormal: readonly number[] | null | undefined, inNormal: readonly number[] | null | undefined, samples: number, reach?: number): number[][];
-/** A cubic evaluated at `t`, component-wise, in whatever dimension it was given. */
-declare function cubicAt(p0: readonly number[], p1: readonly number[], p2: readonly number[], p3: readonly number[], t: number): number[];
+declare function stepLine(about: Vec, toward: Vec, basis: readonly [Vec, Vec], step: number): Flat;
 
-export { PORT_REACH, cubicAt, portControls, portCurvePoints };
+export { type Flat, type ProbeRole, type SnapCandidate, type SnapProbe, type SnapProblem, type SnapResolution, type SnapTier, type Vec, closestBetweenFlats, closestOnFlat, flatDim, intersectFlats, resolveSnap, stepLine };

package/dist/nd/index.js

@@ -1,3 +1,300 @@
 export { PORT_REACH, cubicAt, portControls, portCurvePoints } from '../chunk-YQADYJJ7.js';
+
+// src/snap/flat.ts
+var RANK_TOL = 1e-6;
+function dotv(a, b) {
+  let s = 0;
+  for (let i = 0; i < a.length; i++) s += a[i] * b[i];
+  return s;
+}
+function normv(a) {
+  return Math.sqrt(dotv(a, a));
+}
+function isFiniteVec(a) {
+  return a.every(Number.isFinite);
+}
+function orthonormalize(vecs, start = []) {
+  const basis = start.map((q) => q.slice());
+  const out = [];
+  for (const d of vecs) {
+    const n0 = normv(d);
+    if (!(n0 > 0) || !isFiniteVec(d)) continue;
+    const v = d.slice();
+    for (let pass = 0; pass < 2; pass++) {
+      for (const q of basis) {
+        const k = dotv(v, q);
+        for (let i = 0; i < v.length; i++) v[i] -= k * q[i];
+      }
+    }
+    const n = normv(v);
+    if (n <= RANK_TOL * n0) continue;
+    for (let i = 0; i < v.length; i++) v[i] /= n;
+    basis.push(v);
+    out.push(v);
+  }
+  return out;
+}
+function complement(basis, n) {
+  const axes = [];
+  for (let i = 0; i < n; i++) axes.push(Array.from({ length: n }, (_, j) => i === j ? 1 : 0));
+  return orthonormalize(axes, basis);
+}
+function flatDim(f) {
+  return orthonormalize(f.dirs).length;
+}
+function closestOnFlat(f, p) {
+  const out = f.at.slice();
+  for (const q of orthonormalize(f.dirs)) {
+    let k = 0;
+    for (let i = 0; i < q.length; i++) k += q[i] * (p[i] - f.at[i]);
+    for (let i = 0; i < out.length; i++) out[i] += k * q[i];
+  }
+  return out;
+}
+function solveLeastSquares(cols, rhs) {
+  const k = cols.length;
+  const m = cols.map((a) => [...cols.map((b) => dotv(a, b)), dotv(a, rhs)]);
+  const len2 = m.map((r, i) => r[i]);
+  const kept = [];
+  for (let col = 0; col < k; col++) {
+    if (!(m[col][col] > RANK_TOL * RANK_TOL * len2[col])) continue;
+    for (let r = col + 1; r < k; r++) {
+      const f = m[r][col] / m[col][col];
+      for (let c = col; c <= k; c++) m[r][c] -= f * m[col][c];
+    }
+    kept.push(col);
+  }
+  const x = new Array(k).fill(0);
+  for (let p = kept.length - 1; p >= 0; p--) {
+    const col = kept[p];
+    let s = m[col][k];
+    for (let c = col + 1; c < k; c++) s -= m[col][c] * x[c];
+    x[col] = s / m[col][col];
+  }
+  return x;
+}
+function closestBetweenFlats(a, b) {
+  const qa = orthonormalize(a.dirs);
+  const qb = orthonormalize(b.dirs);
+  const d = b.at.map((v, i) => v - a.at[i]);
+  const x = solveLeastSquares([...qa, ...qb.map((q) => q.map((v) => -v))], d);
+  const onA = a.at.slice();
+  const onB = b.at.slice();
+  qa.forEach((q, j) => q.forEach((v, i) => {
+    onA[i] += x[j] * v;
+  }));
+  qb.forEach((q, j) => q.forEach((v, i) => {
+    onB[i] += x[qa.length + j] * v;
+  }));
+  return { onA, onB };
+}
+function intersectFlats(a, b, eps = 1e-6) {
+  const { onA, onB } = closestBetweenFlats(a, b);
+  let gap2 = 0;
+  for (let i = 0; i < onA.length; i++) gap2 += (onA[i] - onB[i]) ** 2;
+  if (!(Math.sqrt(gap2) <= eps) || !isFiniteVec(onA)) return null;
+  const n = a.at.length;
+  const normals = orthonormalize([
+    ...complement(orthonormalize(a.dirs), n),
+    ...complement(orthonormalize(b.dirs), n)
+  ]);
+  return { at: onA, dirs: complement(normals, n) };
+}
+
+// src/snap/resolve.ts
+var DEFAULT_POOL = 24;
+var DEFAULT_EPS = 1e-6;
+var SAME_PX = 1e-9;
+var plus = (a, b) => a.map((v, i) => v + b[i]);
+var minus = (a, b) => a.map((v, i) => v - b[i]);
+var isFiniteVec2 = (a) => a.every(Number.isFinite);
+function distance(a, b) {
+  let s = 0;
+  for (let i = 0; i < a.length; i++) s += (a[i] - b[i]) ** 2;
+  return Math.sqrt(s);
+}
+function makeMeasure(problem, base, eps) {
+  const home = /* @__PURE__ */ new Map();
+  return {
+    eps,
+    move(probeId, probe, delta) {
+      let h = home.get(probeId);
+      if (!h) home.set(probeId, h = problem.toScreen(plus(probe, base)));
+      const d = distance(problem.toScreen(plus(probe, delta)), h);
+      return Number.isFinite(d) ? d : NaN;
+    }
+  };
+}
+function spanHolds(c, world, eps) {
+  if (!c.span) return true;
+  const u = solveLeastSquares(c.locus.dirs, minus(world, c.locus.at));
+  return c.span.every(([lo, hi], i) => u[i] >= lo - eps && u[i] <= hi + eps);
+}
+function meets(m, c, probe, delta) {
+  const measured = m.move(c.probe, probe, delta);
+  if (!c.required && (Number.isNaN(measured) || !(measured <= c.reachPx))) return null;
+  const px = Number.isNaN(measured) ? Infinity : measured;
+  return spanHolds(c, plus(probe, delta), m.eps) ? px : null;
+}
+function liveCandidates(problem, m) {
+  const probes = new Map(problem.probes.map((p) => [p.id, p.at]));
+  const live = [];
+  for (const c of problem.candidates) {
+    const probe = probes.get(c.probe);
+    if (!probe || !isFiniteVec2(probe) || !isFiniteVec2(c.locus.at) || !c.locus.dirs.every(isFiniteVec2)) continue;
+    const within = intersectFlats(problem.input, { at: minus(c.locus.at, probe), dirs: c.locus.dirs }, m.eps);
+    if (!within) continue;
+    const px = meets(m, c, probe, closestOnFlat(within, problem.delta0));
+    if (px !== null) live.push({ c, probe, within, px });
+  }
+  return live;
+}
+function pool(live, size) {
+  const byProbe = /* @__PURE__ */ new Map();
+  for (const l of live) {
+    const list = byProbe.get(l.c.probe) ?? [];
+    list.push(l);
+    byProbe.set(l.c.probe, list);
+  }
+  const out = [];
+  for (const list of byProbe.values()) {
+    list.sort((a, b) => Math.abs(a.px - b.px) > SAME_PX ? a.px - b.px : a.c.order - b.c.order);
+    out.push(...list.filter((l, i) => i < size || l.c.required));
+  }
+  return out;
+}
+function compareOrders(a, b) {
+  const oa = a.map((l) => l.c.order).sort((x, y) => x - y);
+  const ob = b.map((l) => l.c.order).sort((x, y) => x - y);
+  for (let i = 0; i < Math.min(oa.length, ob.length); i++) if (oa[i] !== ob[i]) return oa[i] - ob[i];
+  return oa.length - ob.length;
+}
+function compareCombos(a, b) {
+  if (a.codim !== b.codim) return b.codim - a.codim;
+  if (a.targetCodim !== b.targetCodim) return b.targetCodim - a.targetCodim;
+  if (Math.abs(a.px - b.px) > SAME_PX) return a.px - b.px;
+  return compareOrders(a.members, b.members);
+}
+function extend(parent, l, input, delta0, m) {
+  const hDim = flatDim(input);
+  const flat = intersectFlats(parent.flat, l.within, m.eps);
+  if (!flat) return null;
+  const dim = flatDim(flat);
+  if (dim >= parent.dim) return null;
+  const delta = closestOnFlat(flat, delta0);
+  if (!isFiniteVec2(delta)) return null;
+  const members = [...parent.members, l];
+  for (const mem of members) if (meets(m, mem.c, mem.probe, delta) === null) return null;
+  const targetFlat = l.c.tier === "target" ? intersectFlats(parent.targetFlat, l.within, m.eps) ?? flat : parent.targetFlat;
+  const kept = prune(members, input, dim, flatDim(targetFlat), m.eps);
+  let px = 0;
+  for (const mem of kept) {
+    const p = meets(m, mem.c, mem.probe, delta);
+    if (p === null) return null;
+    px = Math.max(px, p);
+  }
+  return {
+    members: kept,
+    flat,
+    dim,
+    targetFlat,
+    delta,
+    px,
+    codim: hDim - dim,
+    targetCodim: hDim - flatDim(targetFlat)
+  };
+}
+function flatsOf(members, input, eps) {
+  let flat = input;
+  let target = input;
+  for (const mem of members) {
+    flat = intersectFlats(flat, mem.within, eps);
+    if (!flat) return null;
+    if (mem.c.tier === "target") target = intersectFlats(target, mem.within, eps) ?? flat;
+  }
+  return { dim: flatDim(flat), targetDim: flatDim(target) };
+}
+function prune(members, input, dim, targetDim, eps) {
+  let kept = members;
+  for (let i = 0; i < kept.length && kept.length > 1; ) {
+    const rest = kept.filter((_, j) => j !== i);
+    const f = flatsOf(rest, input, eps);
+    if (f && f.dim === dim && f.targetDim === targetDim) kept = rest;
+    else i++;
+  }
+  return kept;
+}
+function search(candidates, root, delta0, m) {
+  const best = { any: root, required: null };
+  const consider = (c) => {
+    if (compareCombos(c, best.any) < 0) best.any = c;
+    if (c.members.some((l) => l.c.required) && (!best.required || compareCombos(c, best.required) < 0)) {
+      best.required = c;
+    }
+  };
+  const visit = (start, parent) => {
+    for (let i = start; i < candidates.length; i++) {
+      const next = extend(parent, candidates[i], root.flat, delta0, m);
+      if (!next) continue;
+      consider(next);
+      if (next.dim > 0) visit(i + 1, next);
+    }
+  };
+  visit(0, root);
+  return best.required ?? best.any;
+}
+function satisfiedBy(problem, delta, m) {
+  const probes = new Map(problem.probes.map((p) => [p.id, p.at]));
+  return problem.candidates.filter((c) => {
+    const probe = probes.get(c.probe);
+    if (!probe) return false;
+    const world = plus(probe, delta);
+    if (!(distance(closestOnFlat(c.locus, world), world) <= m.eps)) return false;
+    return meets(m, c, probe, delta) !== null;
+  });
+}
+function resolveSnap(problem) {
+  const { input, delta0 } = problem;
+  let base = closestOnFlat(input, delta0);
+  if (!isFiniteVec2(base)) base = isFiniteVec2(input.at) ? input.at : input.at.map(() => 0);
+  const m = makeMeasure(problem, base, problem.eps ?? DEFAULT_EPS);
+  const hDim = flatDim(input);
+  const root = {
+    members: [],
+    flat: input,
+    dim: hDim,
+    targetFlat: input,
+    delta: base,
+    codim: 0,
+    targetCodim: 0,
+    px: 0
+  };
+  const live = pool(liveCandidates(problem, m), problem.poolSize ?? DEFAULT_POOL);
+  const win = search(live, root, delta0, m);
+  return {
+    delta: win.delta,
+    members: win.members.map((l) => l.c),
+    satisfied: satisfiedBy(problem, win.delta, m),
+    codim: win.codim
+  };
+}
+
+// src/snap/stepLine.ts
+function stepLine(about, toward, basis, step) {
+  const [u, v] = basis;
+  let a = 0;
+  let b = 0;
+  for (let i = 0; i < about.length; i++) {
+    const d = toward[i] - about[i];
+    a += d * u[i];
+    b += d * v[i];
+  }
+  const theta = a === 0 && b === 0 ? 0 : Math.round(Math.atan2(b, a) / step) * step;
+  const c = Math.cos(theta);
+  const s = Math.sin(theta);
+  return { at: about, dirs: [u.map((x, i) => x * c + v[i] * s)] };
+}
+
+export { closestBetweenFlats, closestOnFlat, flatDim, intersectFlats, resolveSnap, stepLine };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/nd/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}
+{"version":3,"sources":["../../src/snap/flat.ts","../../src/snap/resolve.ts","../../src/snap/stepLine.ts"],"names":["isFiniteVec"],"mappings":"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","file":"index.js","sourcesContent":["/** Affine subspaces (\"flats\") over plain number arrays, in any dimension:\n *  the points, lines and planes a snap resolves against. */\n\nexport type Vec = readonly number[];\n\n/** The affine subspace `at + span(dirs)`. `dirs` need not be orthonormal or\n *  independent; a zero or repeated direction adds nothing. */\nexport interface Flat {\n  at: Vec;\n  dirs: readonly Vec[];\n}\n\n/** A direction left with less than this fraction of its length after the\n *  ones before it are taken out counts as dependent on them. The solve's\n *  pivots are those leftover lengths squared, so it shares this one value.\n *  Squaring loses angles below about 1e-8 rad to rounding; at 1e-8 the two\n *  verdicts part, so this sits two decades clear. */\nconst RANK_TOL = 1e-6;\n\nfunction dotv(a: Vec, b: Vec): number {\n  let s = 0;\n  for (let i = 0; i < a.length; i++) s += a[i] * b[i];\n  return s;\n}\n\nfunction normv(a: Vec): number {\n  return Math.sqrt(dotv(a, a));\n}\n\nfunction isFiniteVec(a: Vec): boolean {\n  return a.every(Number.isFinite);\n}\n\n/** An orthonormal basis of `span(vecs)`, built by Gram-Schmidt with a second\n *  pass for stability. Non-finite and dependent vectors are dropped. */\nexport function orthonormalize(vecs: readonly Vec[], start: readonly Vec[] = []): number[][] {\n  const basis: number[][] = start.map((q) => q.slice());\n  const out: number[][] = [];\n  for (const d of vecs) {\n    const n0 = normv(d);\n    if (!(n0 > 0) || !isFiniteVec(d)) continue;\n    const v = d.slice();\n    for (let pass = 0; pass < 2; pass++) {\n      for (const q of basis) {\n        const k = dotv(v, q);\n        for (let i = 0; i < v.length; i++) v[i] -= k * q[i];\n      }\n    }\n    const n = normv(v);\n    if (n <= RANK_TOL * n0) continue;\n    for (let i = 0; i < v.length; i++) v[i] /= n;\n    basis.push(v);\n    out.push(v);\n  }\n  return out;\n}\n\n/** An orthonormal basis of the orthogonal complement of the orthonormal `basis` in R^n. */\nfunction complement(basis: readonly Vec[], n: number): number[][] {\n  const axes: number[][] = [];\n  for (let i = 0; i < n; i++) axes.push(Array.from({ length: n }, (_, j) => (i === j ? 1 : 0)));\n  return orthonormalize(axes, basis);\n}\n\n/** The flat's dimension: the rank of its directions. */\nexport function flatDim(f: Flat): number {\n  return orthonormalize(f.dirs).length;\n}\n\n/** The point of `f` nearest `p`. */\nexport function closestOnFlat(f: Flat, p: Vec): Vec {\n  const out = f.at.slice();\n  for (const q of orthonormalize(f.dirs)) {\n    let k = 0;\n    for (let i = 0; i < q.length; i++) k += q[i] * (p[i] - f.at[i]);\n    for (let i = 0; i < out.length; i++) out[i] += k * q[i];\n  }\n  return out;\n}\n\n/**\n * The `x` minimizing `|Σ x_j cols_j − rhs|`, through the normal equations.\n * A column within `RANK_TOL` of the span of the kept ones before it is\n * dropped, the same verdict `orthonormalize` reaches, and its unknown is zero.\n */\nexport function solveLeastSquares(cols: readonly Vec[], rhs: Vec): number[] {\n  const k = cols.length;\n  const m = cols.map((a) => [...cols.map((b) => dotv(a, b)), dotv(a, rhs)]);\n  const len2 = m.map((r, i) => r[i]);\n  const kept: number[] = [];\n  for (let col = 0; col < k; col++) {\n    if (!(m[col][col] > RANK_TOL * RANK_TOL * len2[col])) continue;\n    for (let r = col + 1; r < k; r++) {\n      const f = m[r][col] / m[col][col];\n      for (let c = col; c <= k; c++) m[r][c] -= f * m[col][c];\n    }\n    kept.push(col);\n  }\n  const x = new Array<number>(k).fill(0);\n  for (let p = kept.length - 1; p >= 0; p--) {\n    const col = kept[p];\n    let s = m[col][k];\n    for (let c = col + 1; c < k; c++) s -= m[col][c] * x[c];\n    x[col] = s / m[col][col];\n  }\n  return x;\n}\n\n/** The nearest pair of points, one on each flat. Parallel flats have many\n *  such pairs; this returns one of them. */\nexport function closestBetweenFlats(a: Flat, b: Flat): { onA: Vec; onB: Vec } {\n  const qa = orthonormalize(a.dirs);\n  const qb = orthonormalize(b.dirs);\n  const d = b.at.map((v, i) => v - a.at[i]);\n  const x = solveLeastSquares([...qa, ...qb.map((q) => q.map((v) => -v))], d);\n  const onA = a.at.slice();\n  const onB = b.at.slice();\n  qa.forEach((q, j) => q.forEach((v, i) => { onA[i] += x[j] * v; }));\n  qb.forEach((q, j) => q.forEach((v, i) => { onB[i] += x[qa.length + j] * v; }));\n  return { onA, onB };\n}\n\n/** `a ∩ b`, or null when they miss each other by more than `eps`. */\nexport function intersectFlats(a: Flat, b: Flat, eps = 1e-6): Flat | null {\n  const { onA, onB } = closestBetweenFlats(a, b);\n  let gap2 = 0;\n  for (let i = 0; i < onA.length; i++) gap2 += (onA[i] - onB[i]) ** 2;\n  if (!(Math.sqrt(gap2) <= eps) || !isFiniteVec(onA)) return null;\n  const n = a.at.length;\n  const normals = orthonormalize([\n    ...complement(orthonormalize(a.dirs), n),\n    ...complement(orthonormalize(b.dirs), n),\n  ]);\n  return { at: onA, dirs: complement(normals, n) };\n}\n","/** The snap resolver: every gesture's snap, in any dimension, as one search\n *  over affine constraints on the move `δ`. */\n\nimport { closestOnFlat, flatDim, intersectFlats, solveLeastSquares, type Flat, type Vec } from './flat';\n\n/** A `fallback` candidate holds only the axes no `target` claims. */\nexport type SnapTier = 'target' | 'fallback';\n/** What a probe stands for on the subject; sources match probes by role. */\nexport type ProbeRole = 'origin' | 'box' | 'geometry' | 'pointer';\n\n/** A point on the subject that should land on a locus. `role` says which\n *  sources may match it. */\nexport interface SnapProbe {\n  id: string;\n  at: Vec;\n  role: ProbeRole;\n}\n\n/** One probe paired with one locus. `M` is the mark payload, opaque here. */\nexport interface SnapCandidate<M> {\n  /** `SnapProbe.id`. */\n  probe: string;\n  locus: Flat;\n  /** One interval per locus dir, in multiples of that dir. A solution\n   *  outside it fails the candidate. */\n  span?: readonly (readonly [number, number])[];\n  source: string;\n  /** Stable tiebreak: lower wins when everything else is equal. */\n  order: number;\n  tier: SnapTier;\n  reachPx: number;\n  /** When any required candidate exists, the result includes one of them,\n   *  whatever its reach. */\n  required?: boolean;\n  mark?: M;\n}\n\n/** One frame's snap: the probes, the input subspace, the raw move, and the candidates. */\nexport interface SnapProblem<M> {\n  probes: readonly SnapProbe[];\n  /** `H`, the subspace of δ-space the result stays inside. */\n  input: Flat;\n  /** The unsnapped move. */\n  delta0: Vec;\n  candidates: readonly SnapCandidate<M>[];\n  /** World to screen pixels. A non-finite result puts that position out of reach. */\n  toScreen(world: Vec): Vec;\n  /** Candidates kept per probe, nearest first, besides the required ones,\n   *  which are all kept. Default 24. */\n  poolSize?: number;\n  /** World-space tolerance for \"on the locus\". Default 1e-6. */\n  eps?: number;\n}\n\n/** The move `resolveSnap` chose and the candidates it meets. */\nexport interface SnapResolution<M> {\n  /** `closestOnFlat(input, delta0)` when nothing snaps. */\n  delta: Vec;\n  members: readonly SnapCandidate<M>[];\n  /** Every in-reach candidate the result meets: the ones whose marks show. */\n  satisfied: readonly SnapCandidate<M>[];\n  /** How many dimensions of `H` the result pins. */\n  codim: number;\n}\n\n/** A candidate that can be met on its own: its probe, and `H ∩ C` in δ-space. */\ninterface Live<M> {\n  c: SnapCandidate<M>;\n  probe: Vec;\n  within: Flat;\n  px: number;\n}\n\ninterface Combo<M> {\n  members: Live<M>[];\n  flat: Flat;\n  dim: number;\n  targetFlat: Flat;\n  delta: Vec;\n  codim: number;\n  targetCodim: number;\n  px: number;\n}\n\nconst DEFAULT_POOL = 24;\nconst DEFAULT_EPS = 1e-6;\n/** Screen displacements closer than this rank as equal, so order decides. */\nconst SAME_PX = 1e-9;\n\nconst plus = (a: Vec, b: Vec): Vec => a.map((v, i) => v + b[i]);\nconst minus = (a: Vec, b: Vec): Vec => a.map((v, i) => v - b[i]);\nconst isFiniteVec = (a: Vec): boolean => a.every(Number.isFinite);\n\nfunction distance(a: Vec, b: Vec): number {\n  let s = 0;\n  for (let i = 0; i < a.length; i++) s += (a[i] - b[i]) ** 2;\n  return Math.sqrt(s);\n}\n\n/** What the resolver needs to measure a candidate against a trial δ. */\ninterface Measure {\n  /** Screen pixels the probe moves going from δ0 (projected into `H`) to\n   *  `delta`; NaN when either end has no finite screen position. */\n  move(probeId: string, probe: Vec, delta: Vec): number;\n  eps: number;\n}\n\nfunction makeMeasure<M>(problem: SnapProblem<M>, base: Vec, eps: number): Measure {\n  const home = new Map<string, Vec>();\n  return {\n    eps,\n    move(probeId, probe, delta) {\n      let h = home.get(probeId);\n      if (!h) home.set(probeId, (h = problem.toScreen(plus(probe, base))));\n      const d = distance(problem.toScreen(plus(probe, delta)), h);\n      return Number.isFinite(d) ? d : NaN;\n    },\n  };\n}\n\nfunction spanHolds<M>(c: SnapCandidate<M>, world: Vec, eps: number): boolean {\n  if (!c.span) return true;\n  const u = solveLeastSquares(c.locus.dirs, minus(world, c.locus.at));\n  return c.span.every(([lo, hi], i) => u[i] >= lo - eps && u[i] <= hi + eps);\n}\n\n/** The probe's screen move under `delta`, or null when it is out of reach or off the span. */\nfunction meets<M>(m: Measure, c: SnapCandidate<M>, probe: Vec, delta: Vec): number | null {\n  const measured = m.move(c.probe, probe, delta);\n  if (!c.required && (Number.isNaN(measured) || !(measured <= c.reachPx))) return null;\n  const px = Number.isNaN(measured) ? Infinity : measured;\n  return spanHolds(c, plus(probe, delta), m.eps) ? px : null;\n}\n\nfunction liveCandidates<M>(problem: SnapProblem<M>, m: Measure): Live<M>[] {\n  const probes = new Map(problem.probes.map((p) => [p.id, p.at]));\n  const live: Live<M>[] = [];\n  for (const c of problem.candidates) {\n    const probe = probes.get(c.probe);\n    if (!probe || !isFiniteVec(probe) || !isFiniteVec(c.locus.at) || !c.locus.dirs.every(isFiniteVec)) continue;\n    const within = intersectFlats(problem.input, { at: minus(c.locus.at, probe), dirs: c.locus.dirs }, m.eps);\n    if (!within) continue;\n    const px = meets(m, c, probe, closestOnFlat(within, problem.delta0));\n    if (px !== null) live.push({ c, probe, within, px });\n  }\n  return live;\n}\n\nfunction pool<M>(live: Live<M>[], size: number): Live<M>[] {\n  const byProbe = new Map<string, Live<M>[]>();\n  for (const l of live) {\n    const list = byProbe.get(l.c.probe) ?? [];\n    list.push(l);\n    byProbe.set(l.c.probe, list);\n  }\n  const out: Live<M>[] = [];\n  for (const list of byProbe.values()) {\n    list.sort((a, b) => (Math.abs(a.px - b.px) > SAME_PX ? a.px - b.px : a.c.order - b.c.order));\n    out.push(...list.filter((l, i) => i < size || l.c.required));\n  }\n  return out;\n}\n\nfunction compareOrders<M>(a: Live<M>[], b: Live<M>[]): number {\n  const oa = a.map((l) => l.c.order).sort((x, y) => x - y);\n  const ob = b.map((l) => l.c.order).sort((x, y) => x - y);\n  for (let i = 0; i < Math.min(oa.length, ob.length); i++) if (oa[i] !== ob[i]) return oa[i] - ob[i];\n  return oa.length - ob.length;\n}\n\n/** Negative when `a` ranks ahead of `b`. */\nfunction compareCombos<M>(a: Combo<M>, b: Combo<M>): number {\n  if (a.codim !== b.codim) return b.codim - a.codim;\n  if (a.targetCodim !== b.targetCodim) return b.targetCodim - a.targetCodim;\n  if (Math.abs(a.px - b.px) > SAME_PX) return a.px - b.px;\n  return compareOrders(a.members, b.members);\n}\n\n/** `parent` plus `l`, or null when `l` adds no constraint or breaks a member's reach or span. */\nfunction extend<M>(parent: Combo<M>, l: Live<M>, input: Flat, delta0: Vec, m: Measure): Combo<M> | null {\n  const hDim = flatDim(input);\n  const flat = intersectFlats(parent.flat, l.within, m.eps);\n  if (!flat) return null;\n  const dim = flatDim(flat);\n  if (dim >= parent.dim) return null;\n  const delta = closestOnFlat(flat, delta0);\n  if (!isFiniteVec(delta)) return null;\n  const members = [...parent.members, l];\n  for (const mem of members) if (meets(m, mem.c, mem.probe, delta) === null) return null;\n  const targetFlat = l.c.tier === 'target'\n    ? intersectFlats(parent.targetFlat, l.within, m.eps) ?? flat\n    : parent.targetFlat;\n  const kept = prune(members, input, dim, flatDim(targetFlat), m.eps);\n  let px = 0;\n  for (const mem of kept) {\n    const p = meets(m, mem.c, mem.probe, delta);\n    if (p === null) return null;\n    px = Math.max(px, p);\n  }\n  return {\n    members: kept, flat, dim, targetFlat, delta, px,\n    codim: hDim - dim,\n    targetCodim: hDim - flatDim(targetFlat),\n  };\n}\n\n/** The flat `members` pin inside `input`, and the one their target-tier members pin. */\nfunction flatsOf<M>(members: readonly Live<M>[], input: Flat, eps: number): { dim: number; targetDim: number } | null {\n  let flat: Flat | null = input;\n  let target: Flat = input;\n  for (const mem of members) {\n    flat = intersectFlats(flat, mem.within, eps);\n    if (!flat) return null;\n    if (mem.c.tier === 'target') target = intersectFlats(target, mem.within, eps) ?? flat;\n  }\n  return { dim: flatDim(flat), targetDim: flatDim(target) };\n}\n\n/** `members` less every one the rest already imply, oldest first, so a\n *  redundant member neither shows in `members` nor decides a tie on order. */\nfunction prune<M>(members: Live<M>[], input: Flat, dim: number, targetDim: number, eps: number): Live<M>[] {\n  let kept = members;\n  for (let i = 0; i < kept.length && kept.length > 1;) {\n    const rest = kept.filter((_, j) => j !== i);\n    const f = flatsOf(rest, input, eps);\n    if (f && f.dim === dim && f.targetDim === targetDim) kept = rest;\n    else i++;\n  }\n  return kept;\n}\n\n/** The best combination; when any can include a required candidate, the best of those. */\nfunction search<M>(candidates: Live<M>[], root: Combo<M>, delta0: Vec, m: Measure): Combo<M> {\n  const best: { any: Combo<M>; required: Combo<M> | null } = { any: root, required: null };\n  const consider = (c: Combo<M>) => {\n    if (compareCombos(c, best.any) < 0) best.any = c;\n    if (c.members.some((l) => l.c.required) && (!best.required || compareCombos(c, best.required) < 0)) {\n      best.required = c;\n    }\n  };\n  const visit = (start: number, parent: Combo<M>) => {\n    for (let i = start; i < candidates.length; i++) {\n      const next = extend(parent, candidates[i], root.flat, delta0, m);\n      if (!next) continue;\n      consider(next);\n      if (next.dim > 0) visit(i + 1, next);\n    }\n  };\n  visit(0, root);\n  return best.required ?? best.any;\n}\n\nfunction satisfiedBy<M>(problem: SnapProblem<M>, delta: Vec, m: Measure): SnapCandidate<M>[] {\n  const probes = new Map(problem.probes.map((p) => [p.id, p.at]));\n  return problem.candidates.filter((c) => {\n    const probe = probes.get(c.probe);\n    if (!probe) return false;\n    const world = plus(probe, delta);\n    if (!(distance(closestOnFlat(c.locus, world), world) <= m.eps)) return false;\n    return meets(m, c, probe, delta) !== null;\n  });\n}\n\n/** The move nearest `delta0` within `H` that meets the best-ranked set of\n *  candidates in reach, or `delta0` projected into `H` when none is. */\nexport function resolveSnap<M>(problem: SnapProblem<M>): SnapResolution<M> {\n  const { input, delta0 } = problem;\n  let base = closestOnFlat(input, delta0);\n  if (!isFiniteVec(base)) base = isFiniteVec(input.at) ? input.at : input.at.map(() => 0);\n  const m = makeMeasure(problem, base, problem.eps ?? DEFAULT_EPS);\n  const hDim = flatDim(input);\n  const root: Combo<M> = {\n    members: [], flat: input, dim: hDim, targetFlat: input, delta: base, codim: 0, targetCodim: 0, px: 0,\n  };\n  const live = pool(liveCandidates(problem, m), problem.poolSize ?? DEFAULT_POOL);\n  const win = search(live, root, delta0, m);\n  return {\n    delta: win.delta,\n    members: win.members.map((l) => l.c),\n    satisfied: satisfiedBy(problem, win.delta, m),\n    codim: win.codim,\n  };\n}\n","import type { Flat, Vec } from './flat';\n\n/**\n * The line through `about` whose direction, measured in the plane `basis`\n * spans (as an angle from `basis[0]` toward `basis[1]`), is the multiple of\n * `step` nearest the direction from `about` to `toward`: a constrained\n * gesture's input subspace, in any dimension. `basis` is orthonormal.\n */\nexport function stepLine(about: Vec, toward: Vec, basis: readonly [Vec, Vec], step: number): Flat {\n  const [u, v] = basis;\n  let a = 0;\n  let b = 0;\n  for (let i = 0; i < about.length; i++) {\n    const d = toward[i] - about[i];\n    a += d * u[i];\n    b += d * v[i];\n  }\n  const theta = a === 0 && b === 0 ? 0 : Math.round(Math.atan2(b, a) / step) * step;\n  const c = Math.cos(theta);\n  const s = Math.sin(theta);\n  return { at: about, dirs: [u.map((x, i) => x * c + v[i] * s)] };\n}\n"]}

package/dist/path-BW8d_2RY.d.ts

@@ -0,0 +1,157 @@
+/** A 2D point, the shape the point-taking path helpers read and return. */
+interface Point {
+    x: number;
+    y: number;
+}
+/** Point on the cubic Bezier (p0, p1, p2, p3) at parameter t. The point-shaped
+ *  face of geom's `cubicEvalAt`. */
+declare function cubicPointAt(p0: Point, p1: Point, p2: Point, p3: Point, t: number): Point;
+/** De Casteljau subdivision of a cubic at parameter t. The point-shaped face
+ *  of geom's `splitCubicAt`; `left[3]` and `right[0]` are the point at t. */
+declare function splitCubicAtT(p0: Point, p1: Point, p2: Point, p3: Point, t: number): {
+    left: [Point, Point, Point, Point];
+    right: [Point, Point, Point, Point];
+};
+
+/** The six `corner-shape` keywords, from most convex to most concave. */
+type CornerKeyword = 'square' | 'squircle' | 'round' | 'bevel' | 'scoop' | 'notch';
+/** A corner's shape: a keyword, or a finite `superellipse()` parameter. */
+type CornerShape = CornerKeyword | number;
+/** The keywords in the order cycling through them steps. */
+declare const CORNER_KEYWORDS: readonly CornerKeyword[];
+/** The `superellipse()` parameter of `shape`. */
+declare function cornerShapeK(shape: CornerShape): number;
+/** The keyword whose parameter is exactly `k`, or null. */
+declare function cornerKeywordOf(k: number): CornerKeyword | null;
+/** Whether `v` is a keyword or a finite number. */
+declare function isCornerShape(v: unknown): v is CornerShape;
+/** The keyword after `shape` in {@link CORNER_KEYWORDS}, wrapping; from a
+ *  number, the first keyword less convex than it. */
+declare function nextCornerShape(shape: CornerShape): CornerKeyword;
+/** Largest distance, in units of the corner's setback, the fitted cubics may
+ *  stray from the true superellipse. */
+declare const CORNER_FIT_TOLERANCE = 0.001;
+/** The cut a corner shape spans: from `start` to `end`, the two points where
+ *  it leaves the edges, around `outer`, the corner the edges meet at. */
+interface CornerShapeFrame {
+    start: Point;
+    end: Point;
+    outer: Point;
+}
+/** One piece of a corner's outline, continuing from where the last ended. */
+type CornerPiece = {
+    kind: 'line';
+    to: Point;
+} | {
+    kind: 'cubic';
+    c1: Point;
+    c2: Point;
+    to: Point;
+};
+/** The center the convex curves are spanned from: across the cut from `outer`. */
+declare function cornerCenter(frame: CornerShapeFrame): Point;
+/**
+ * The outline of a corner of parameter `k` across `frame`, from its start to
+ * its end. Exact at `k = 0` (a line), `±1` (the cubic quarter arc the kit
+ * draws circles with) and `±∞` (two lines, through the outer corner or the
+ * center); fitted with cubics within `tolerance` of the setback elsewhere.
+ */
+declare function cornerShapePieces(k: number, frame: CornerShapeFrame, tolerance?: number): CornerPiece[];
+/** The point on the true curve of parameter `k` across `frame` at `s`, from
+ *  0 at its start to 1 at its end. Finite `k` only. */
+declare function cornerShapePoint(k: number, frame: CornerShapeFrame, s: number): Point;
+
+/**
+ * Per-anchor corner specs: the stored half of corner shapes. A path carries
+ * them in `PolygonPath.corners`, indexed by flat anchor index, and every
+ * reader of its geometry sees them expanded (`resolveCorners`).
+ */
+
+/** The corner at one anchor: its shape, and its setback, how far along each
+ *  edge from the anchor the cut starts. A `round` corner between edges at a
+ *  right angle is a circle of that radius. */
+interface CornerSpec {
+    shape: CornerShape;
+    radius: number;
+}
+/** The corner cut at flat anchor `index`, or null. A zero radius cuts nothing. */
+declare function cornerAt(path: PolygonPath, index: number): CornerSpec | null;
+/** The spec stored at flat anchor `index`, radius zero included: a shape
+ *  picked before any radius is dragged out. */
+declare function cornerSpecAt(path: PolygonPath, index: number): CornerSpec | null;
+/** Whether any anchor of `path` carries a corner with a radius. */
+declare function hasCorners(path: {
+    kind: string;
+    corners?: PolygonPath['corners'];
+}): boolean;
+/** `corners` without trailing empty slots, or undefined when none is left. */
+declare function compactCorners(corners: readonly (CornerSpec | null | undefined)[]): (CornerSpec | null)[] | undefined;
+/** `path` without its corner specs: the bare anchors the specs decorate. */
+declare function withoutCorners(path: PolygonPath): PolygonPath;
+/** `path` with the corner at flat anchor `index` set to `spec`, or cleared
+ *  when `spec` is null. A zero radius keeps the shape and cuts nothing.
+ *  Never mutates `path`. */
+declare function withCorner(path: PolygonPath, index: number, spec: CornerSpec | null): PolygonPath;
+/** `path` with every corner radius multiplied by `factor`, as a uniform
+ *  scale of its geometry would carry them. */
+declare function scaleCorners(path: PolygonPath, factor: number): PolygonPath;
+/**
+ * The corners of a path `t` of the way from `a` to `b`, which share their
+ * anchors. A corner whose shape both ends agree on, or that one end leaves
+ * sharp, grows its radius between them; one whose shape changes takes the
+ * nearer end's.
+ */
+declare function lerpCorners(a: PolygonPath['corners'], b: PolygonPath['corners'], t: number): (CornerSpec | null)[] | undefined;
+
+/**
+ * Path data model: the vector-graphics primitive every weasel package uses as
+ * its canonical shape. An SVG-style command stream covers lines, polygons,
+ * beziers and multi-contour shapes (the inner hole of an "O") under one type.
+ *
+ * Storage: command codes in a `Uint8Array`, parameters in a `Float32Array`.
+ * Each command consumes a fixed number of coords (`PATH_CMD_LENGTHS`); walkers
+ * step both arrays in lockstep.
+ */
+
+/** Fill rule used by polygon path hit-testing and `ctx.fill()`. */
+type PathFillRule = 'nonzero' | 'evenodd';
+/** Whether a fill closes an open subpath with a straight edge back to its
+ *  start, as SVG and canvas do (`'close'`), or leaves it unfilled (`'none'`). */
+type PathOpenFill = 'close' | 'none';
+/**
+ * Polygon path with arbitrary contours and optional bezier segments.
+ * Multi-contour: each `M` opens a new subpath; `Z` closes the current one.
+ * An open subpath (no `Z`) strokes as a polyline; `openFill` says whether it
+ * fills.
+ */
+interface PolygonPath {
+    kind: 'polygon';
+    commands: Uint8Array;
+    coords: Float32Array;
+    fillRule: PathFillRule;
+    /** Absent, the engine default: see `setDefaultOpenFill`. */
+    openFill?: PathOpenFill;
+    /**
+     * Corner shapes, indexed by flat anchor index (`enumerateAnchors` order):
+     * the anchor at each non-null slot is cut in a `corner-shape`
+     * (`cornerShape.ts`). The commands and coords hold the bare anchors; `resolveCorners`
+     * expands the specs into the geometry everything draws, hits, and bounds.
+     */
+    corners?: readonly (CornerSpec | null)[];
+}
+/**
+ * Axis-aligned rectangle. Fast path for the (very common) case where the
+ * shape is just a rect — preserves O(1) bounds and hit-test, avoids the
+ * polygon kernel entirely.
+ */
+interface RectPath {
+    kind: 'rect';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Canonical path shape — either an axis-aligned rect (fast path) or a polygon command stream. */
+type Path = PolygonPath | RectPath;
+
+export { withoutCorners as A, type CornerSpec as C, type PolygonPath as P, type RectPath as R, type Path as a, type Point as b, type PathOpenFill as c, type PathFillRule as d, type CornerPiece as e, CORNER_FIT_TOLERANCE as f, CORNER_KEYWORDS as g, type CornerKeyword as h, type CornerShape as i, type CornerShapeFrame as j, compactCorners as k, cornerAt as l, cornerCenter as m, cornerKeywordOf as n, cornerShapeK as o, cornerShapePieces as p, cornerShapePoint as q, cornerSpecAt as r, cubicPointAt as s, hasCorners as t, isCornerShape as u, lerpCorners as v, nextCornerShape as w, scaleCorners as x, splitCubicAtT as y, withCorner as z };