@weasel-js/labkit 1.0.1 → 1.0.3

package/dist/{chunk-ISEK5LXT.js → chunk-3WPOGKUP.js}

@@ -3,12 +3,7 @@ import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import earcut from 'earcut';
 import polygonClipping from 'polygon-clipping';
 
-// ../core/dist/chunk-PZ5AY32C.js
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+// ../core/dist/chunk-TR3HZN34.js
 
 // ../gestures/dist/index.js
 var GESTURE_DESCRIPTORS = [
@@ -22,7 +17,12 @@ var GESTURE_DESCRIPTORS = [
   { name: "keyHeld", hasTarget: false, arg: { name: "key", values: "free" } },
   { name: "contextMenu", hasTarget: true },
   { name: "longPress", hasTarget: true },
-  { name: "multiTouchTap", hasTarget: false, arg: { name: "fingers", values: ["2", "3", "4"] } }
+  { name: "multiTouchTap", hasTarget: false, arg: { name: "fingers", values: ["2", "3", "4"] } },
+  // The arg is the MIME-glob filter. No default: a spec with no `types`
+  // matches any payload, which is what an omitted arg slot means for a
+  // `'free'` arg.
+  { name: "drop", hasTarget: false, arg: { name: "types", values: "free" } },
+  { name: "paste", hasTarget: false, arg: { name: "types", values: "free" } }
 ];
 var BY_NAME = new Map(
   GESTURE_DESCRIPTORS.map((d) => [d.name, d])
@@ -50,176 +50,11 @@ var RESERVED_ID_NAMES = /* @__PURE__ */ new Set([
   "engaged"
 ]);
 var VALID_MOD_NAMES = ["mod", "shift", "alt", "ctrl", "meta"];
-var RESERVED_SIGILS = /* @__PURE__ */ new Set(["!", "@", "#", "$", "%", "^", "&"]);
-var ACTIVE_SIGILS = /* @__PURE__ */ new Set(["+", "?"]);
-var MOD_NAME_SET = new Set(VALID_MOD_NAMES);
-function parseRoute(input) {
-  const trimmed = input.trim();
-  if (!trimmed.startsWith("[")) {
-    throw new Error(`invalid route (phase brackets required): ${input}`);
-  }
-  const closeIdx = trimmed.indexOf("]");
-  if (closeIdx < 0) throw new Error(`invalid route (unclosed phase bracket): ${input}`);
-  const phaseListRaw = trimmed.slice(1, closeIdx).trim();
-  const phases = parsePhaseList(phaseListRaw, input);
-  let rest = trimmed.slice(closeIdx + 1).trim();
-  const gestureMatch = /^([A-Za-z]+)/.exec(rest);
-  if (!gestureMatch) throw new Error(`invalid route (no gesture name): ${input}`);
-  const gestureName = gestureMatch[1];
-  if (!isKnownGestureName(gestureName)) {
-    throw new Error(`invalid route (unknown gesture "${gestureName}"): ${input}`);
-  }
-  rest = rest.slice(gestureMatch[0].length).trimStart();
-  const desc = getGestureDescriptor(gestureName);
-  let arg;
-  if (rest.startsWith("(")) {
-    const closeArg = rest.indexOf(")");
-    if (closeArg < 0) throw new Error(`invalid route (unbalanced arg parens): ${input}`);
-    const argRaw = rest.slice(1, closeArg);
-    if (!desc.arg) throw new Error(`invalid route (${gestureName} has no arg): ${input}`);
-    if (argRaw !== "*" && desc.arg.values !== "free" && !desc.arg.values.includes(argRaw)) {
-      throw new Error(`invalid route ("${argRaw}" not in ${desc.arg.values.join("|")}): ${input}`);
-    }
-    arg = argRaw;
-    rest = rest.slice(closeArg + 1).trimStart();
-  } else if (desc.arg) {
-    arg = desc.arg.default ?? "*";
-  }
-  let target;
-  if (rest.startsWith("=>")) {
-    if (!desc.hasTarget) throw new Error(`invalid route (${gestureName} has no target): ${input}`);
-    rest = rest.slice(2).trimStart();
-    const tgtMatch = /^([^\s+?!@#$%^&]+)/.exec(rest);
-    if (!tgtMatch) throw new Error(`invalid route (missing target after "=>"): ${input}`);
-    target = tgtMatch[1];
-    rest = rest.slice(tgtMatch[0].length).trimStart();
-  } else if (desc.hasTarget) {
-    target = "*";
-  }
-  const modifiers = {};
-  while (rest.length > 0) {
-    const ch = rest[0];
-    if (RESERVED_SIGILS.has(ch)) {
-      throw new Error(`invalid route ("${ch}" is reserved for future use): ${input}`);
-    }
-    if (!ACTIVE_SIGILS.has(ch)) {
-      throw new Error(`invalid route (unexpected "${ch}" at "${rest}"): ${input}`);
-    }
-    const sigil = ch;
-    rest = rest.slice(1);
-    const nameMatch = /^([a-z]+)/.exec(rest);
-    if (!nameMatch) throw new Error(`invalid route (sigil "${sigil}" without modifier name): ${input}`);
-    const name = nameMatch[1];
-    if (!MOD_NAME_SET.has(name)) {
-      throw new Error(`invalid route (unknown modifier "${name}"): ${input}`);
-    }
-    if (modifiers[name] !== void 0) {
-      throw new Error(`invalid route (duplicate modifier "${name}"): ${input}`);
-    }
-    modifiers[name] = sigil === "+" ? "required" : "optional";
-    rest = rest.slice(nameMatch[0].length).trimStart();
-  }
-  return { phases, gesture: gestureName, arg, target, modifiers };
-}
-function parsePhaseList(raw, input) {
-  if (raw === "") throw new Error(`invalid route (empty phase list): ${input}`);
-  const tokens = raw.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
-  if (tokens.length === 0) throw new Error(`invalid route (empty phase list): ${input}`);
-  return tokens.map((t) => parsePhaseAtom(t, input));
-}
-var VALID_PHASES = /* @__PURE__ */ new Set(["initial", "engaged", "*"]);
-function parsePhaseAtom(raw, input) {
-  const parts = raw.split(":");
-  if (parts.length > 2) {
-    throw new Error(`invalid route (phase atom "${raw}" has multiple ":"): ${input}`);
-  }
-  if (parts.length === 1) {
-    const phase2 = parts[0];
-    if (!VALID_PHASES.has(phase2)) {
-      throw new Error(`invalid route (unknown phase "${phase2}" in "${raw}"): ${input}`);
-    }
-    return { channel: "&", phase: phase2 };
-  }
-  const channel = parts[0];
-  const phase = parts[1];
-  if (channel === "") {
-    throw new Error(`invalid route (empty channel before ":" in "${raw}"): ${input}`);
-  }
-  if (!VALID_PHASES.has(phase)) {
-    throw new Error(`invalid route (unknown phase "${phase}" in "${raw}"): ${input}`);
-  }
-  if (channel !== "&" && channel !== "*") {
-    if (RESERVED_ID_NAMES.has(channel)) {
-      throw new Error(`invalid route (channel "${channel}" is a reserved phase keyword): ${input}`);
-    }
-    if (RESERVED_ID_PREFIXES.has(channel[0])) {
-      throw new Error(`invalid route (channel "${channel}" starts with reserved sigil "${channel[0]}"): ${input}`);
-    }
-  }
-  return { channel, phase };
-}
+new Set(VALID_MOD_NAMES);
 function formatPhaseAtom(a) {
   if (a.channel === "&") return a.phase;
   return `${a.channel}:${a.phase}`;
 }
-function collapseShiftPairs(routes) {
-  if (routes.length < 2) return [...routes];
-  const parsed = routes.map((r) => ({ raw: r, p: parseRoute(r) }));
-  const consumed = /* @__PURE__ */ new Set();
-  const out = [];
-  for (let i = 0; i < parsed.length; i++) {
-    if (consumed.has(i)) continue;
-    const a = parsed[i];
-    let twinIndex = -1;
-    for (let j = i + 1; j < parsed.length; j++) {
-      if (consumed.has(j)) continue;
-      const b = parsed[j];
-      if (isShiftTwin(a.p, b.p)) {
-        twinIndex = j;
-        break;
-      }
-    }
-    if (twinIndex < 0) {
-      out.push(a.raw);
-      continue;
-    }
-    consumed.add(twinIndex);
-    const folded = {
-      ...a.p,
-      modifiers: { ...withoutShift(a.p.modifiers), shift: "optional" }
-    };
-    out.push(formatRoute(folded));
-  }
-  return out;
-}
-function isShiftTwin(a, b) {
-  if (a.gesture !== b.gesture) return false;
-  if (a.arg !== b.arg) return false;
-  if (a.target !== b.target) return false;
-  if (!samePhases(a.phases, b.phases)) return false;
-  const aShift = a.modifiers.shift;
-  const bShift = b.modifiers.shift;
-  const aHas = aShift === "required";
-  const bHas = bShift === "required";
-  if (!(aHas !== bHas)) return false;
-  if (aShift === "optional" || bShift === "optional") return false;
-  for (const name of VALID_MOD_NAMES) {
-    if (name === "shift") continue;
-    if (a.modifiers[name] !== b.modifiers[name]) return false;
-  }
-  return true;
-}
-function samePhases(a, b) {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    if (a[i].channel !== b[i].channel || a[i].phase !== b[i].phase) return false;
-  }
-  return true;
-}
-function withoutShift(m) {
-  const { shift: _shift, ...rest } = m;
-  return rest;
-}
 var MOD_ORDER = ["mod", "shift", "alt", "ctrl", "meta"];
 function formatRoute(r) {
   const desc = getGestureDescriptor(r.gesture);
@@ -240,122 +75,6 @@ function formatRoute(r) {
   return out;
 }
 new Set(VALID_MOD_NAMES);
-var MOD_NAMES = {
-  mod: "Mod",
-  shift: "Shift",
-  alt: "Alt",
-  ctrl: "Ctrl",
-  meta: "Meta"
-};
-var MOD_ORDER2 = ["mod", "shift", "alt", "ctrl", "meta"];
-var ROUTE_TERMS = {
-  idle: "Not in the middle of a drag or other synchronous operation.",
-  "mid-gesture": "In the middle of a drag or other synchronous operation."
-};
-var ROUTE_FIELD_DEFINITIONS = {
-  phases: "Which lifecycle stage(s) a channel must be in for this route to fire. `initial` = the channel is idle; `engaged` = the channel is mid-gesture. The channel is the binding's own tool (`&`), any tool (`*`), or a named tool id.",
-  gesture: "The class of input event that triggers this route \u2014 click, drag, double-tap, keyDown/keyUp, wheel, contextMenu, or multiTouchTap.",
-  arg: "Sub-class of the gesture. Direction for wheel (up / down / *), key name for keyDown / keyUp, finger count for multiTouchTap. Other gestures have no arg slot.",
-  target: "Which hit-test result the gesture must land on. `*` matches any target; `empty` matches the empty canvas; otherwise the value names a specific hit-target kind.",
-  modifiers: "Modifier keys the user must hold (`+key`) or may optionally hold (`?key`) for this route to match. Unlisted modifiers must not be held."
-};
-function term(label) {
-  return { kind: "term", label, definition: ROUTE_TERMS[label] };
-}
-function joinAnd(parts) {
-  if (parts.length === 0) return "";
-  if (parts.length === 1) return parts[0];
-  if (parts.length === 2) return `${parts[0]} and ${parts[1]}`;
-  return `${parts.slice(0, -1).join(", ")}, and ${parts[parts.length - 1]}`;
-}
-function partitionModifiers(mods2) {
-  const required = [];
-  const optional = [];
-  for (const name of MOD_ORDER2) {
-    const req = mods2[name];
-    if (req === "required") required.push(MOD_NAMES[name]);
-    else if (req === "optional") optional.push(MOD_NAMES[name]);
-  }
-  return { required, optional };
-}
-function phaseAtomParts({ channel, phase }) {
-  const subject = channel === "&" ? "the tool" : channel === "*" ? "any tool" : `the ${channel} tool`;
-  if (phase === "initial") return [`${subject} is `, term("idle")];
-  if (phase === "engaged") return [`${subject} is `, term("mid-gesture")];
-  return [`${subject} is in any phase`];
-}
-function phasesParts(phases) {
-  if (phases.length === 1) return phaseAtomParts(phases[0]);
-  const out = [];
-  phases.forEach((p, i) => {
-    if (i > 0) out.push(" or ");
-    out.push(...phaseAtomParts(p));
-  });
-  return out;
-}
-function targetClause(target, hasTarget) {
-  if (!hasTarget || target === void 0) return "";
-  if (target === "*") return " anywhere";
-  if (target === "empty") return " on empty canvas";
-  return ` on a ${target}`;
-}
-function actionClause(parsed, required) {
-  const desc = getGestureDescriptor(parsed.gesture);
-  const modPrefix = required.length > 0 ? `${joinAnd(required)}-` : "";
-  const target = targetClause(parsed.target, desc.hasTarget);
-  switch (parsed.gesture) {
-    case "keyDown":
-    case "keyUp":
-    case "keyHeld": {
-      const verb = parsed.gesture === "keyDown" ? "presses" : parsed.gesture === "keyUp" ? "releases" : "holds";
-      const key = parsed.arg ?? "any key";
-      return required.length > 0 ? `the user holds ${joinAnd(required)} and ${verb} ${key}` : `the user ${verb} ${key}`;
-    }
-    case "wheel": {
-      const direction = parsed.arg === "up" ? " up" : parsed.arg === "down" ? " down" : "";
-      return `the user ${modPrefix}scrolls${direction}`;
-    }
-    case "multiTouchTap":
-      return `the user taps with ${parsed.arg ?? "multiple"} fingers`;
-    case "contextMenu":
-      return `the user ${modPrefix}opens the context menu${target}`;
-    case "longPress":
-      return `the user ${modPrefix}presses and holds${target}`;
-    case "click":
-      return `the user ${modPrefix}clicks${target}`;
-    case "pointerDown":
-      return `the user ${modPrefix}presses${target}`;
-    case "dblTap":
-      return `the user ${modPrefix}double-taps${target}`;
-    case "drag":
-      return `the user ${modPrefix}drags${target}`;
-  }
-}
-function describeRouteParts(parsed, opts = {}) {
-  const { capitalize = true, period = true } = opts;
-  const { required, optional } = partitionModifiers(parsed.modifiers);
-  const action = actionClause(parsed, required);
-  const optClause = optional.length > 0 ? ` (${joinAnd(optional)} optional)` : "";
-  const parts = [];
-  const head = `fires when ${action}, while `;
-  parts.push(capitalize ? head.charAt(0).toUpperCase() + head.slice(1) : head);
-  parts.push(...phasesParts(parsed.phases));
-  if (optClause) parts.push(optClause);
-  if (period) parts.push(".");
-  return mergeAdjacentStrings(parts);
-}
-function describeRoute(parsed, opts = {}) {
-  return describeRouteParts(parsed, opts).map((p) => typeof p === "string" ? p : p.label).join("");
-}
-function mergeAdjacentStrings(parts) {
-  const out = [];
-  for (const p of parts) {
-    const last = out[out.length - 1];
-    if (typeof p === "string" && typeof last === "string") out[out.length - 1] = last + p;
-    else out.push(p);
-  }
-  return out;
-}
 function canonicalModifiers(mods2) {
   return Object.entries(mods2).sort(([a], [b]) => a.localeCompare(b)).map(([name, req]) => `${name}=${req}`).join("&");
 }
@@ -568,144 +287,8 @@ function matchSpec(e, spec, isMac, phaseCtx) {
   }
 }
 var EMPTY_ENGAGED = /* @__PURE__ */ new Set();
-var routing_exports = {};
-__export(routing_exports, {
-  GESTURE_DESCRIPTORS: () => GESTURE_DESCRIPTORS,
-  PREDICATE_TARGET: () => PREDICATE_TARGET,
-  RESERVED_ID_NAMES: () => RESERVED_ID_NAMES,
-  RESERVED_ID_PREFIXES: () => RESERVED_ID_PREFIXES,
-  ROUTE_FIELD_DEFINITIONS: () => ROUTE_FIELD_DEFINITIONS,
-  ROUTE_TERMS: () => ROUTE_TERMS,
-  buildRouteRegistry: () => buildRouteRegistry,
-  canonicalModifiers: () => canonicalModifiers,
-  collapseShiftPairs: () => collapseShiftPairs,
-  defineTool: () => defineTool,
-  defineViewportTool: () => defineViewportTool,
-  describeRoute: () => describeRoute,
-  describeRouteParts: () => describeRouteParts,
-  findConflicts: () => findConflicts,
-  findScopedConflicts: () => findScopedConflicts,
-  formatConflict: () => formatConflict,
-  formatPhaseAtom: () => formatPhaseAtom,
-  formatRoute: () => formatRoute,
-  getGestureDescriptor: () => getGestureDescriptor,
-  isKnownGestureName: () => isKnownGestureName,
-  parseRoute: () => parseRoute,
-  reportRouteConflicts: () => reportRouteConflicts
-});
-function validateId(id, kind) {
-  if (id.length === 0) {
-    throw new Error(`weasel: ${kind} id may not be empty`);
-  }
-  if (RESERVED_ID_PREFIXES.has(id[0])) {
-    throw new Error(
-      `weasel: ${kind} id "${id}" starts with reserved sigil "${id[0]}" (reserved set: ${[...RESERVED_ID_PREFIXES].join(" ")})`
-    );
-  }
-  if (RESERVED_ID_NAMES.has(id)) {
-    throw new Error(
-      `weasel: ${kind} id "${id}" collides with a reserved phase keyword (reserved: ${[...RESERVED_ID_NAMES].join(", ")})`
-    );
-  }
-}
-function defineTool(def) {
-  validateId(def.id, "tool");
-  const resolveCursor = (ctx) => {
-    if (def.cursor == null) return "";
-    return typeof def.cursor === "function" ? def.cursor(ctx) : def.cursor;
-  };
-  return {
-    id: def.id,
-    eligibility: {
-      focus: true,
-      capabilities: def.capabilities,
-      ...def.hotkey ? { offhand: def.hotkey } : {}
-    },
-    actions: def.actions,
-    def,
-    presentation: def.presentation,
-    keybinding: def.keybinding,
-    onActivate: def.onActivate,
-    onDeactivate: def.onDeactivate,
-    initScratch: def.initScratch ?? (() => null),
-    cursor: resolveCursor,
-    bindings: def.bindings,
-    overlay: def.overlay
-  };
-}
-function defineViewportTool(def) {
-  return defineTool(def);
-}
-var PREDICATE_TARGET = "predicate";
-var SPEC_KIND_TO_GESTURE = {
-  key: "keyDown",
-  "key-held": "keyHeld",
-  wheel: "wheel",
-  click: "click",
-  doubleClick: "dblTap",
-  contextMenu: "contextMenu",
-  longPress: "longPress",
-  drag: "drag",
-  pointerDown: "pointerDown",
-  multiTouch: void 0,
-  multiTouchTap: "multiTouchTap",
-  drop: void 0,
-  paste: void 0
-};
-function buildRouteRegistry(tools) {
-  const out = [];
-  for (const tool of tools) {
-    for (const binding of tool.bindings ?? []) {
-      const entry = entryFor(tool.id, binding.spec, binding.actionId);
-      if (entry) out.push(entry);
-    }
-  }
-  return out;
-}
-function entryFor(toolId, spec, actionId) {
-  const gesture = SPEC_KIND_TO_GESTURE[spec.kind];
-  if (!gesture || !isKnownGestureName(gesture)) return null;
-  const descriptor = getGestureDescriptor(gesture);
-  return {
-    toolId,
-    actionId,
-    gesture,
-    phase: phaseOf("phase" in spec ? spec.phase : void 0),
-    modifiers: parseModSpec("mods" in spec ? spec.mods : void 0),
-    arg: descriptor.arg ? argOf(spec, descriptor.arg.default) : void 0,
-    target: descriptor.hasTarget ? targetOf("target" in spec ? spec.target : void 0) : void 0,
-    spec
-  };
-}
-function phaseOf(phase) {
-  if (phase === void 0 || phase === "*") return "any";
-  if (phase === "initial" || phase === "engaged") return phase;
-  const distinct = new Set(phase.map((atom) => atom.phase));
-  if (distinct.size !== 1) return "any";
-  const only = [...distinct][0];
-  return only === "initial" || only === "engaged" ? only : "any";
-}
-function parseModSpec(mods) {
-  if (!mods) return {};
-  const out = {};
-  for (const [name, req] of Object.entries(mods)) {
-    if (req === true) out[name] = "required";
-    else if (req === "optional") out[name] = "optional";
-  }
-  return out;
-}
-function targetOf(target) {
-  if (target === void 0) return void 0;
-  return typeof target === "string" ? target : PREDICATE_TARGET;
-}
-function argOf(spec, fallback) {
-  if ("key" in spec) {
-    return Array.isArray(spec.key) ? spec.key.join("|") : spec.key;
-  }
-  if ("fingers" in spec) return String(spec.fingers);
-  if ("direction" in spec) return spec.direction ?? fallback;
-  return fallback;
-}
+
+// ../core/dist/chunk-TR3HZN34.js
 var DepRegistryContext = createContext(null);
 function DepRegistryProvider({ children }) {
   const sourcesRef = useRef(/* @__PURE__ */ new Map());
@@ -955,6 +538,77 @@ function ActionsProvider({ children }) {
 function useActionsRegistry() {
   return useContext(ActionsContext);
 }
+var PREDICATE_TARGET = "predicate";
+var SPEC_KIND_TO_GESTURE = {
+  key: "keyDown",
+  "key-held": "keyHeld",
+  wheel: "wheel",
+  click: "click",
+  doubleClick: "dblTap",
+  contextMenu: "contextMenu",
+  longPress: "longPress",
+  drag: "drag",
+  pointerDown: "pointerDown",
+  multiTouch: void 0,
+  multiTouchTap: "multiTouchTap",
+  drop: "drop",
+  paste: "paste"
+};
+function buildRouteRegistry(tools) {
+  const out = [];
+  for (const tool of tools) {
+    for (const binding of tool.bindings ?? []) {
+      const entry = entryFor(tool.id, binding.spec, binding.actionId);
+      if (entry) out.push(entry);
+    }
+  }
+  return out;
+}
+function entryFor(toolId, spec, actionId) {
+  const gesture = SPEC_KIND_TO_GESTURE[spec.kind];
+  if (!gesture || !isKnownGestureName(gesture)) return null;
+  const descriptor = getGestureDescriptor(gesture);
+  return {
+    toolId,
+    actionId,
+    gesture,
+    phase: phaseOf("phase" in spec ? spec.phase : void 0),
+    modifiers: parseModSpec("mods" in spec ? spec.mods : void 0),
+    arg: descriptor.arg ? argOf(spec, descriptor.arg.default) : void 0,
+    target: descriptor.hasTarget ? targetOf("target" in spec ? spec.target : void 0) : void 0,
+    spec
+  };
+}
+function phaseOf(phase) {
+  if (phase === void 0 || phase === "*") return "any";
+  if (phase === "initial" || phase === "engaged") return phase;
+  const distinct = new Set(phase.map((atom) => atom.phase));
+  if (distinct.size !== 1) return "any";
+  const only = [...distinct][0];
+  return only === "initial" || only === "engaged" ? only : "any";
+}
+function parseModSpec(mods) {
+  if (!mods) return {};
+  const out = {};
+  for (const [name, req] of Object.entries(mods)) {
+    if (req === true) out[name] = "required";
+    else if (req === "optional") out[name] = "optional";
+  }
+  return out;
+}
+function targetOf(target) {
+  if (target === void 0) return void 0;
+  return typeof target === "string" ? target : PREDICATE_TARGET;
+}
+function argOf(spec, fallback) {
+  if ("key" in spec) {
+    return Array.isArray(spec.key) ? spec.key.join("|") : spec.key;
+  }
+  if ("fingers" in spec) return String(spec.fingers);
+  if ("direction" in spec) return spec.direction ?? fallback;
+  if ("types" in spec) return spec.types?.length ? spec.types.join("|") : fallback;
+  return fallback;
+}
 function findConflicts(tools) {
   const entries = buildRouteRegistry(tools);
   const groups = /* @__PURE__ */ new Map();
@@ -1045,7 +699,7 @@ function reportRouteConflicts(scopes, warn = (m) => console.warn(m)) {
   return conflicts;
 }
 
-// ../geom/dist/chunk-K5JJ6WRB.js
+// ../geom/dist/chunk-UULRZUHO.js
 function cubicEvalAt(x0, y0, x1, y1, x2, y2, x3, y3, t) {
   const u = 1 - t;
   const a = u * u * u, b = 3 * u * u * t, c = 3 * u * t * t, d = t * t * t;
@@ -1161,7 +815,7 @@ function transformCoords(coords, m) {
   return out;
 }
 
-// ../core/dist/chunk-6SHZHXXR.js
+// ../core/dist/chunk-U45SODC2.js
 function resolveUnit(v, unitSystem) {
   if (typeof v === "number") return v;
   if (!unitSystem) {
@@ -1909,7 +1563,7 @@ function createDeleteOp(args) {
 }
 registerOpFactory("delete", (args) => createDeleteOp(args));
 
-// ../core/dist/chunk-UB6A6L77.js
+// ../core/dist/chunk-3KGMJMOS.js
 function createTransformOp(args) {
   const { id, from, to, label, coalesceKey = `transform:${id}` } = args;
   return {
@@ -1990,7 +1644,7 @@ function snap(strategy, opts = {}) {
   };
 }
 
-// ../core/dist/chunk-Z3KNFTTS.js
+// ../core/dist/chunk-3JYFAQIB.js
 function lockAspectWithModifier(opts = {}) {
   const { key = "shift" } = opts;
   return {
@@ -2186,7 +1840,7 @@ function materializePaste(adapter, snapshot, opts) {
   return { ops, newIds, created };
 }
 
-// ../core/dist/chunk-IO5Z75X4.js
+// ../core/dist/chunk-HGF5X6MZ.js
 var counter = 0;
 var registry = /* @__PURE__ */ new Map();
 function getTexture(id) {
@@ -2344,7 +1998,7 @@ function chunks(params) {
   return build({ tile: "chunks", ...params });
 }
 
-// ../font/dist/index.js
+// ../font/dist/chunk-3RSTZDXH.js
 var subscribers = /* @__PURE__ */ new Set();
 var generation = 0;
 function glyphGeneration() {
@@ -2687,17 +2341,17 @@ function dynamicPageTextureId(page) {
   return `weasel-dyn-sdf-page-${page}`;
 }
 var uploadedVersions = /* @__PURE__ */ new WeakMap();
-function syncDynamicPageTexture(cache7, pageIndex) {
+function syncDynamicPageTexture(cache8, pageIndex) {
   const page = pages[pageIndex];
   if (!page) return false;
   const id = dynamicPageTextureId(pageIndex);
-  let seen = uploadedVersions.get(cache7);
+  let seen = uploadedVersions.get(cache8);
   if (!seen) {
     seen = /* @__PURE__ */ new Map();
-    uploadedVersions.set(cache7, seen);
+    uploadedVersions.set(cache8, seen);
   }
-  if (!cache7.has(id)) {
-    cache7.uploadR8(id, PAGE_SIZE, PAGE_SIZE, page.data);
+  if (!cache8.has(id)) {
+    cache8.uploadR8(id, PAGE_SIZE, PAGE_SIZE, page.data);
     seen.set(pageIndex, page.version);
     return true;
   }
@@ -2710,7 +2364,7 @@ function syncDynamicPageTexture(cache7, pageIndex) {
       const src = (patch.y + row) * PAGE_SIZE + patch.x;
       tight.set(page.data.subarray(src, src + patch.w), row * patch.w);
     }
-    cache7.subImageR8(id, patch.x, patch.y, patch.w, patch.h, tight);
+    cache8.subImageR8(id, patch.x, patch.y, patch.w, patch.h, tight);
   }
   seen.set(pageIndex, page.version);
   return true;
@@ -2988,6 +2642,8 @@ function warnOnce(key, message) {
   warned.add(key);
   console.warn(message);
 }
+
+// ../font/dist/index.js
 var TEXT_VERT_SRC = (
   /* glsl */
   `#version 300 es
@@ -3084,7 +2740,7 @@ var TEXT_SDF_UNIFORMS = [
 ];
 var TEXT_SDF_ATTRIBUTES = ["a_position", "a_uv", "a_baselineY"];
 
-// ../modes/dist/chunk-KILROWYB.js
+// ../modes/dist/chunk-YAJYQMBG.js
 var NORMAL = {
   allows: [
     "creates-selection",
@@ -3477,7 +3133,7 @@ function serialToEntry(se, custom, logger) {
   };
 }
 
-// ../core/dist/chunk-FVNWK7U3.js
+// ../core/dist/chunk-SMCZRSYB.js
 function worldToScreen(worldX, worldY, view) {
   return [view.panX + worldX * view.zoom.x, view.panY + worldY * view.zoom.y];
 }
@@ -3791,6 +3447,8 @@ var GLMeshCache = class {
   gl;
   aPositionLoc;
   map = /* @__PURE__ */ new WeakMap();
+  /** Meshes this context has drawn at least once; see `uploadRecurring`. */
+  seen = /* @__PURE__ */ new WeakSet();
   finalizer;
   pendingDeletes = [];
   /** Transient resources allocated this frame; freed at end of render(). */
@@ -3815,6 +3473,19 @@ var GLMeshCache = class {
     this.transientThisFrame.push({ vao: handle.vao, vbo, ibo });
     return handle;
   }
+  /**
+   * Upload a Mesh that may or may not recur across frames. Its first sight in
+   * *this* context takes `uploadTransient`; every later one takes the
+   * persistent handle. One transient upload to find out is cheaper than
+   * stranding a persistent VAO on a mesh that never returns, whose release
+   * would wait on GC. The transient upload does not populate the persistent
+   * map, so steady-state reuse begins on the third frame.
+   */
+  uploadRecurring(mesh) {
+    if (this.seen.has(mesh)) return this.handleFor(mesh);
+    this.seen.add(mesh);
+    return this.uploadTransient(mesh);
+  }
   /**
    * Free all transient resources allocated since the last call. Called by
    * the renderer at the end of each `render()`. Safe under context loss.
@@ -4881,619 +4552,19 @@ function getMesh(path) {
   cache.set(path, mesh);
   return mesh;
 }
-function extractPolylines(path, opts = {}) {
-  if (path.kind === "rect") return [extractRect(path)];
-  return extractPolygon(path, opts);
+var UNDERLINE_OFFSET = 0.1;
+var STRIKETHROUGH_OFFSET = -0.3;
+var DECORATION_THICKNESS = 0.05;
+function fillKey(p) {
+  if ("color" in p) return `s:${p.color}:${p.opacity ?? 1}`;
+  return `nx:${Math.random()}`;
 }
-function extractRect(p) {
-  const { x, y, width: w, height: h } = p;
-  return {
-    points: [x, y, x + w, y, x + w, y + h, x, y + h],
-    closed: true,
-    anchorA: new Uint32Array([0, 1, 2, 3]),
-    anchorB: new Uint32Array([0, 1, 2, 3]),
-    anchorT: new Float32Array([0, 0, 0, 0])
-  };
-}
-function extractPolygon(p, opts) {
-  const tolerance = opts.flattenTolerance ?? DEFAULT_FLATTEN_TOLERANCE;
-  const { commands, coords } = p;
-  const out = [];
-  let anchorCounter = 0;
-  let pts = null;
-  let aA = null;
-  let aB = null;
-  let aT = null;
-  let current = null;
-  let coordIdx = 0;
-  let prevX = 0;
-  let prevY = 0;
-  let prevAnchor = -1;
-  const beginContour = () => {
-    pts = [];
-    aA = [];
-    aB = [];
-    aT = [];
-    const next = { points: pts, closed: false };
-    out.push(next);
-    return next;
-  };
-  const dropDuplicateClosingPoint = () => {
-    if (!pts || !aA || !aB || !aT) return;
-    const n = pts.length / 2;
-    if (n < 2) return;
-    if (pts[0] !== pts[(n - 1) * 2] || pts[1] !== pts[(n - 1) * 2 + 1]) return;
-    pts.length -= 2;
-    aA.length -= 1;
-    aB.length -= 1;
-    aT.length -= 1;
-  };
-  const commit = (target) => {
-    if (!pts || !aA || !aB || !aT) return;
-    target.anchorA = new Uint32Array(aA);
-    target.anchorB = new Uint32Array(aB);
-    target.anchorT = new Float32Array(aT);
-  };
-  for (let cmdIdx = 0; cmdIdx < commands.length; cmdIdx++) {
-    const cmd = commands[cmdIdx];
-    switch (cmd) {
-      case PATH_M2: {
-        if (current) commit(current);
-        current = beginContour();
-        prevX = coords[coordIdx];
-        prevY = coords[coordIdx + 1];
-        pts.push(prevX, prevY);
-        aA.push(anchorCounter);
-        aB.push(anchorCounter);
-        aT.push(0);
-        prevAnchor = anchorCounter;
-        anchorCounter++;
-        coordIdx += 2;
-        break;
-      }
-      case PATH_L2: {
-        prevX = coords[coordIdx];
-        prevY = coords[coordIdx + 1];
-        pts.push(prevX, prevY);
-        aA.push(anchorCounter);
-        aB.push(anchorCounter);
-        aT.push(0);
-        prevAnchor = anchorCounter;
-        anchorCounter++;
-        coordIdx += 2;
-        break;
-      }
-      case PATH_Q2: {
-        const cx = coords[coordIdx], cy = coords[coordIdx + 1];
-        const ex = coords[coordIdx + 2], ey = coords[coordIdx + 3];
-        const targetAnchor = anchorCounter;
-        const segStart = pts.length / 2;
-        const arcAccum = [];
-        const total = flattenQuadraticWithArcLen(prevX, prevY, cx, cy, ex, ey, tolerance, pts, arcAccum);
-        for (let k = 0; k < arcAccum.length; k++) {
-          aA.push(prevAnchor);
-          aB.push(targetAnchor);
-          aT.push(total > 0 ? arcAccum[k] / total : 0);
-        }
-        const lastIdx = segStart + arcAccum.length - 1;
-        aA[lastIdx] = targetAnchor;
-        aB[lastIdx] = targetAnchor;
-        aT[lastIdx] = 0;
-        prevX = ex;
-        prevY = ey;
-        prevAnchor = targetAnchor;
-        anchorCounter++;
-        coordIdx += 4;
-        break;
-      }
-      case PATH_C2: {
-        const c1x = coords[coordIdx], c1y = coords[coordIdx + 1];
-        const c2x = coords[coordIdx + 2], c2y = coords[coordIdx + 3];
-        const ex = coords[coordIdx + 4], ey = coords[coordIdx + 5];
-        const targetAnchor = anchorCounter;
-        const segStart = pts.length / 2;
-        const arcAccum = [];
-        const total = flattenCubicWithArcLen(prevX, prevY, c1x, c1y, c2x, c2y, ex, ey, tolerance, pts, arcAccum);
-        for (let k = 0; k < arcAccum.length; k++) {
-          aA.push(prevAnchor);
-          aB.push(targetAnchor);
-          aT.push(total > 0 ? arcAccum[k] / total : 0);
-        }
-        const lastIdx = segStart + arcAccum.length - 1;
-        aA[lastIdx] = targetAnchor;
-        aB[lastIdx] = targetAnchor;
-        aT[lastIdx] = 0;
-        prevX = ex;
-        prevY = ey;
-        prevAnchor = targetAnchor;
-        anchorCounter++;
-        coordIdx += 6;
-        break;
-      }
-      case PATH_Z2: {
-        if (current) {
-          current.closed = true;
-          dropDuplicateClosingPoint();
-        }
-        break;
-      }
-      default:
-        throw new Error(`extractPolylines: unknown command code ${cmd}`);
-    }
-  }
-  if (current) commit(current);
-  return out;
-}
-var EMPTY_MESH = {
-  vertices: new Float32Array(0),
-  indices: new Uint32Array(0),
-  anchorA: new Uint32Array(0),
-  anchorB: new Uint32Array(0),
-  anchorT: new Float32Array(0)
-};
-function tessellateStroke(path, stroke, opts = {}) {
-  const width = stroke.width ?? 1;
-  if (width <= 0) return EMPTY_MESH;
-  const join = stroke.join ?? "miter";
-  const cap = stroke.cap ?? "butt";
-  const align = stroke.align ?? "center";
-  const miterLimit = stroke.miterLimit ?? DEFAULT_MITER_LIMIT;
-  const varyingThreshold = stroke.varyingWidthJoinThreshold ?? DEFAULT_VARYING_WIDTH_JOIN_THRESHOLD;
-  let workingPath = path;
-  if (path.kind === "rect" && align !== "center") {
-    const aligned = alignedStrokeRect(path, align, width);
-    workingPath = {
-      kind: "rect",
-      x: aligned.x,
-      y: aligned.y,
-      width: aligned.width,
-      height: aligned.height
-    };
-  }
-  const polylines = extractPolylines(workingPath, opts);
-  if (stroke.vertexWidths && stroke.vertexWidths.length > 0) {
-    for (const pl of polylines) populatePolylineWidths(pl, stroke.vertexWidths, width);
-  }
-  const dash = stroke.dash ?? [];
-  const verts = [];
-  const idx = [];
-  const anchorA = [];
-  const anchorB = [];
-  const anchorT = [];
-  for (const pl of polylines) {
-    const subs = dash.length > 0 ? splitForDash(pl, dash) : [pl];
-    for (const sub2 of subs) {
-      expandPolyline(sub2, width, join, cap, miterLimit, varyingThreshold, verts, idx, anchorA, anchorB, anchorT);
-    }
-  }
-  return {
-    vertices: new Float32Array(verts),
-    indices: new Uint32Array(idx),
-    anchorA: new Uint32Array(anchorA),
-    anchorB: new Uint32Array(anchorB),
-    anchorT: new Float32Array(anchorT)
-  };
-}
-function expandPolyline(pl, width, join, cap, miterLimit, varyingThreshold, verts, idx, anchorA, anchorB, anchorT) {
-  const half = width / 2;
-  const pts = pl.points;
-  const ptCount = pts.length / 2;
-  const segCount = ptCount - 1;
-  if (segCount < 1) return;
-  const plA = pl.anchorA ?? new Uint32Array(ptCount);
-  const plB = pl.anchorB ?? new Uint32Array(ptCount);
-  const plT = pl.anchorT ?? new Float32Array(ptCount);
-  const plHalf = pl.widths ? pl.widths.map((w) => w / 2) : null;
-  const segs = [];
-  const segSrcIdx = [];
-  for (let s = 0; s < segCount; s++) {
-    const ha = plHalf ? plHalf[s] : half;
-    const hb = plHalf ? plHalf[s + 1] : half;
-    const seg = makeSeg(pts[s * 2], pts[s * 2 + 1], pts[(s + 1) * 2], pts[(s + 1) * 2 + 1], ha, hb);
-    if (seg) {
-      segs.push(seg);
-      segSrcIdx.push(s);
-    }
-  }
-  let closerSrcIdx = -1;
-  if (pl.closed && segs.length >= 1) {
-    const last = segs[segs.length - 1];
-    const first = segs[0];
-    const haCloser = plHalf ? plHalf[ptCount - 1] : half;
-    const hbCloser = plHalf ? plHalf[0] : half;
-    const closer = makeSeg(last.bx, last.by, first.ax, first.ay, haCloser, hbCloser);
-    if (closer) {
-      segs.push(closer);
-      closerSrcIdx = ptCount - 1;
-      segSrcIdx.push(closerSrcIdx);
-    }
-  }
-  if (segs.length === 0) return;
-  const segBaseIdx = [];
-  for (let s = 0; s < segs.length; s++) {
-    const seg = segs[s];
-    const startSrc = segSrcIdx[s];
-    const endSrc = s === segs.length - 1 && pl.closed && closerSrcIdx >= 0 ? 0 : startSrc + 1;
-    const base = verts.length / 2;
-    segBaseIdx.push(base);
-    const nxA = seg.nxUnit * seg.halfA, nyA = seg.nyUnit * seg.halfA;
-    const nxB = seg.nxUnit * seg.halfB, nyB = seg.nyUnit * seg.halfB;
-    verts.push(seg.ax + nxA, seg.ay + nyA);
-    anchorA.push(plA[startSrc]);
-    anchorB.push(plB[startSrc]);
-    anchorT.push(plT[startSrc]);
-    verts.push(seg.ax - nxA, seg.ay - nyA);
-    anchorA.push(plA[startSrc]);
-    anchorB.push(plB[startSrc]);
-    anchorT.push(plT[startSrc]);
-    verts.push(seg.bx + nxB, seg.by + nyB);
-    anchorA.push(plA[endSrc]);
-    anchorB.push(plB[endSrc]);
-    anchorT.push(plT[endSrc]);
-    verts.push(seg.bx - nxB, seg.by - nyB);
-    anchorA.push(plA[endSrc]);
-    anchorB.push(plB[endSrc]);
-    anchorT.push(plT[endSrc]);
-    idx.push(base, base + 1, base + 2, base + 1, base + 3, base + 2);
-  }
-  const joinCount = pl.closed ? segs.length : segs.length - 1;
-  for (let j = 0; j < joinCount; j++) {
-    emitJoin(segs, segBaseIdx, j, join, miterLimit, varyingThreshold, verts, idx, anchorA, anchorB, anchorT, segSrcIdx, plA, plB, plT);
-  }
-  if (!pl.closed && cap !== "butt") {
-    const first = segs[0];
-    const firstBase = segBaseIdx[0];
-    emitCap(first, firstBase + 0, firstBase + 1, false, first.halfA, cap, verts, idx, anchorA, anchorB, anchorT, plA[0], plB[0], plT[0]);
-    const last = segs[segs.length - 1];
-    const lastBase = segBaseIdx[segs.length - 1];
-    const lastSrc = segSrcIdx[segs.length - 1] + 1;
-    emitCap(last, lastBase + 2, lastBase + 3, true, last.halfB, cap, verts, idx, anchorA, anchorB, anchorT, plA[lastSrc], plB[lastSrc], plT[lastSrc]);
-  }
-}
-function populatePolylineWidths(pl, vertexWidths, fallbackWidth) {
-  const ptCount = pl.points.length / 2;
-  if (ptCount === 0) return;
-  const aA = pl.anchorA ?? new Uint32Array(ptCount);
-  const aB = pl.anchorB ?? new Uint32Array(ptCount);
-  const aT = pl.anchorT ?? new Float32Array(ptCount);
-  const widths = new Float32Array(ptCount);
-  const read2 = (i) => {
-    const v = vertexWidths[i];
-    return typeof v === "number" && isFinite(v) && v > 0 ? v : fallbackWidth;
-  };
-  for (let i = 0; i < ptCount; i++) {
-    const a = aA[i], b = aB[i], t = aT[i];
-    if (a === b) {
-      widths[i] = read2(a);
-    } else {
-      const wa = read2(a);
-      const wb = read2(b);
-      widths[i] = wa + (wb - wa) * t;
-    }
-  }
-  pl.widths = widths;
-}
-var ROUND_CAP_STEP_RAD = 10 * Math.PI / 180;
-function emitCap(seg, leftIdx, rightIdx, atEnd, half, cap, verts, idx, anchorA, anchorB, anchorT, endA, endB, endT) {
-  const sign2 = atEnd ? 1 : -1;
-  const dx = (seg.bx - seg.ax) / seg.len * sign2;
-  const dy = (seg.by - seg.ay) / seg.len * sign2;
-  const cx = atEnd ? seg.bx : seg.ax;
-  const cy = atEnd ? seg.by : seg.ay;
-  const nx = seg.nxUnit * half;
-  const ny = seg.nyUnit * half;
-  if (cap === "square") {
-    const ox = cx + dx * half;
-    const oy = cy + dy * half;
-    const lOut = verts.length / 2;
-    verts.push(ox + nx, oy + ny);
-    anchorA.push(endA);
-    anchorB.push(endB);
-    anchorT.push(endT);
-    const rOut = verts.length / 2;
-    verts.push(ox - nx, oy - ny);
-    anchorA.push(endA);
-    anchorB.push(endB);
-    anchorT.push(endT);
-    if (atEnd) {
-      idx.push(leftIdx, lOut, rOut, leftIdx, rOut, rightIdx);
-    } else {
-      idx.push(leftIdx, rOut, lOut, leftIdx, rightIdx, rOut);
-    }
-    return;
-  }
-  if (cap === "round") {
-    const pivotIdx = verts.length / 2;
-    verts.push(cx, cy);
-    anchorA.push(endA);
-    anchorB.push(endB);
-    anchorT.push(endT);
-    const startAngle = Math.atan2(ny, nx);
-    const sweep = atEnd ? -Math.PI : Math.PI;
-    const steps = Math.max(1, Math.ceil(Math.abs(sweep) / ROUND_CAP_STEP_RAD));
-    const stepAngle = sweep / steps;
-    let prevIdx = leftIdx;
-    for (let i = 1; i < steps; i++) {
-      const ang = startAngle + i * stepAngle;
-      const fx = cx + Math.cos(ang) * half;
-      const fy = cy + Math.sin(ang) * half;
-      const newIdx = verts.length / 2;
-      verts.push(fx, fy);
-      anchorA.push(endA);
-      anchorB.push(endB);
-      anchorT.push(endT);
-      if (atEnd) idx.push(prevIdx, newIdx, pivotIdx);
-      else idx.push(prevIdx, pivotIdx, newIdx);
-      prevIdx = newIdx;
-    }
-    if (atEnd) idx.push(prevIdx, rightIdx, pivotIdx);
-    else idx.push(prevIdx, pivotIdx, rightIdx);
-  }
-}
-function splitForDash(pl, dash) {
-  const out = [];
-  const plA = pl.anchorA ?? new Uint32Array(pl.points.length / 2);
-  const plB = pl.anchorB ?? new Uint32Array(pl.points.length / 2);
-  const plT = pl.anchorT ?? new Float32Array(pl.points.length / 2);
-  let dashIdx = 0;
-  let dashRemaining = dash[0];
-  let onPhase = true;
-  let curPts = onPhase ? [pl.points[0], pl.points[1]] : null;
-  let curA = onPhase ? [plA[0]] : null;
-  let curB = onPhase ? [plB[0]] : null;
-  let curT = onPhase ? [plT[0]] : null;
-  const flushAndAdvance = () => {
-    if (curPts && curPts.length >= 4) {
-      out.push({
-        points: curPts,
-        closed: false,
-        anchorA: new Uint32Array(curA),
-        anchorB: new Uint32Array(curB),
-        anchorT: new Float32Array(curT)
-      });
-    }
-    curPts = null;
-    curA = null;
-    curB = null;
-    curT = null;
-    dashIdx = (dashIdx + 1) % dash.length;
-    dashRemaining = dash[dashIdx];
-    onPhase = !onPhase;
-  };
-  let prevX = pl.points[0], prevY = pl.points[1];
-  const ptCount = pl.points.length / 2;
-  const segCount = pl.closed ? ptCount : ptCount - 1;
-  for (let i = 0; i < segCount; i++) {
-    const nextIdx = (i + 1) % ptCount;
-    const cx = pl.points[nextIdx * 2], cy = pl.points[nextIdx * 2 + 1];
-    const startA = plA[i], startB = plB[i], startT = plT[i];
-    const endA = plA[nextIdx], endB = plB[nextIdx], endT = plT[nextIdx];
-    const segFullDx = cx - prevX, segFullDy = cy - prevY;
-    const segFullLen = Math.hypot(segFullDx, segFullDy);
-    let segDx = segFullDx, segDy = segFullDy;
-    let segLen = segFullLen;
-    let traveled = 0;
-    while (segLen > 1e-9) {
-      if (segLen <= dashRemaining) {
-        if (onPhase && curPts) {
-          curPts.push(cx, cy);
-          curA.push(endA);
-          curB.push(endB);
-          curT.push(endT);
-        }
-        dashRemaining -= segLen;
-        prevX = cx;
-        prevY = cy;
-        traveled = segFullLen;
-        segLen = 0;
-        if (dashRemaining <= 1e-9) {
-          flushAndAdvance();
-          if (onPhase) {
-            curPts = [prevX, prevY];
-            curA = [endA];
-            curB = [endB];
-            curT = [endT];
-          }
-        }
-      } else {
-        const tConsume = dashRemaining / segLen;
-        const ix = prevX + segDx * tConsume;
-        const iy = prevY + segDy * tConsume;
-        traveled += dashRemaining;
-        const frac = traveled / segFullLen;
-        let mA, mB, mT;
-        if (startA === endA && startB === endB) {
-          mA = startA;
-          mB = startB;
-          mT = startT + (endT - startT) * frac;
-        } else {
-          if (frac < 0.5) {
-            mA = startA;
-            mB = startB;
-            mT = startT;
-          } else {
-            mA = endA;
-            mB = endB;
-            mT = endT;
-          }
-        }
-        if (onPhase && curPts) {
-          curPts.push(ix, iy);
-          curA.push(mA);
-          curB.push(mB);
-          curT.push(mT);
-        }
-        prevX = ix;
-        prevY = iy;
-        segDx = cx - prevX;
-        segDy = cy - prevY;
-        segLen = Math.hypot(segDx, segDy);
-        flushAndAdvance();
-        if (onPhase) {
-          curPts = [prevX, prevY];
-          curA = [mA];
-          curB = [mB];
-          curT = [mT];
-        }
-      }
-    }
-  }
-  if (curPts && curPts.length >= 4) {
-    out.push({
-      points: curPts,
-      closed: false,
-      anchorA: new Uint32Array(curA),
-      anchorB: new Uint32Array(curB),
-      anchorT: new Float32Array(curT)
-    });
-  }
-  return out;
-}
-function makeSeg(ax, ay, bx, by, halfA, halfB) {
-  const dx = bx - ax, dy = by - ay;
-  const len = Math.hypot(dx, dy);
-  if (len === 0) return null;
-  return {
-    ax,
-    ay,
-    bx,
-    by,
-    nxUnit: -dy / len,
-    nyUnit: dx / len,
-    halfA,
-    halfB,
-    len
-  };
-}
-var DEFAULT_MITER_LIMIT = 10;
-var DEFAULT_VARYING_WIDTH_JOIN_THRESHOLD = 1.5;
-function emitJoin(segs, segBaseIdx, j, join, miterLimit, varyingThreshold, verts, idx, anchorA, anchorB, anchorT, segSrcIdx, plA, plB, plT) {
-  const a = segs[j];
-  const b = segs[(j + 1) % segs.length];
-  const aBase = segBaseIdx[j];
-  const bBase = segBaseIdx[(j + 1) % segs.length];
-  const adx = a.bx - a.ax, ady = a.by - a.ay;
-  const bdx = b.bx - b.ax, bdy = b.by - b.ay;
-  const cross = adx * bdy - ady * bdx;
-  if (cross === 0) return;
-  const onPositive = cross > 0;
-  const aOuterEnd = onPositive ? aBase + 3 : aBase + 2;
-  const bOuterStart = onPositive ? bBase + 1 : bBase + 0;
-  const nextSeg = (j + 1) % segs.length;
-  const cornerSrc = segSrcIdx[nextSeg];
-  const cornerA = plA[cornerSrc];
-  const cornerB = plB[cornerSrc];
-  const cornerT = plT[cornerSrc];
-  const halfAtCorner = a.halfB;
-  const taperA = Math.max(a.halfA, a.halfB) / Math.max(1e-9, Math.min(a.halfA, a.halfB));
-  const taperB = Math.max(b.halfA, b.halfB) / Math.max(1e-9, Math.min(b.halfA, b.halfB));
-  const forceBevelForVarying = taperA > varyingThreshold || taperB > varyingThreshold;
-  if (join === "bevel" || forceBevelForVarying) {
-    emitBevel(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);
-    return;
-  }
-  if (join === "miter") {
-    const aOX = verts[aOuterEnd * 2], aOY = verts[aOuterEnd * 2 + 1];
-    const bOX = verts[bOuterStart * 2], bOY = verts[bOuterStart * 2 + 1];
-    const apex = lineLineIntersect(aOX, aOY, adx, ady, bOX, bOY, -bdx, -bdy);
-    if (!apex) {
-      emitBevel(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);
-      return;
-    }
-    const miterLen = Math.hypot(apex[0] - a.bx, apex[1] - a.by);
-    if (miterLen > miterLimit * halfAtCorner) {
-      emitBevel(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);
-      return;
-    }
-    const apexIdx = verts.length / 2;
-    verts.push(apex[0], apex[1]);
-    anchorA.push(cornerA);
-    anchorB.push(cornerB);
-    anchorT.push(cornerT);
-    const jIdx = verts.length / 2;
-    verts.push(a.bx, a.by);
-    anchorA.push(cornerA);
-    anchorB.push(cornerB);
-    anchorT.push(cornerT);
-    if (onPositive) {
-      idx.push(aOuterEnd, apexIdx, bOuterStart);
-      idx.push(aOuterEnd, bOuterStart, jIdx);
-    } else {
-      idx.push(aOuterEnd, bOuterStart, apexIdx);
-      idx.push(aOuterEnd, jIdx, bOuterStart);
-    }
-    return;
-  }
-  if (join === "round") {
-    emitRoundJoin(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);
-    return;
-  }
-}
-var ROUND_STEP_RAD = 10 * Math.PI / 180;
-function emitRoundJoin(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT) {
-  const cx = a.bx, cy = a.by;
-  const pivotIdx = verts.length / 2;
-  verts.push(cx, cy);
-  anchorA.push(cornerA);
-  anchorB.push(cornerB);
-  anchorT.push(cornerT);
-  const startX = verts[aOuterEnd * 2] - cx;
-  const startY = verts[aOuterEnd * 2 + 1] - cy;
-  const endX = verts[bOuterStart * 2] - cx;
-  const endY = verts[bOuterStart * 2 + 1] - cy;
-  const r = Math.hypot(startX, startY);
-  const startAngle = Math.atan2(startY, startX);
-  const endAngle = Math.atan2(endY, endX);
-  let sweep = endAngle - startAngle;
-  if (onPositive && sweep < 0) sweep += 2 * Math.PI;
-  else if (!onPositive && sweep > 0) sweep -= 2 * Math.PI;
-  const steps = Math.max(1, Math.ceil(Math.abs(sweep) / ROUND_STEP_RAD));
-  const stepAngle = sweep / steps;
-  let prevIdx = aOuterEnd;
-  for (let i = 1; i < steps; i++) {
-    const ang = startAngle + i * stepAngle;
-    const fx = cx + Math.cos(ang) * r;
-    const fy = cy + Math.sin(ang) * r;
-    const newIdx = verts.length / 2;
-    verts.push(fx, fy);
-    anchorA.push(cornerA);
-    anchorB.push(cornerB);
-    anchorT.push(cornerT);
-    if (onPositive) idx.push(prevIdx, pivotIdx, newIdx);
-    else idx.push(prevIdx, newIdx, pivotIdx);
-    prevIdx = newIdx;
-  }
-  if (onPositive) idx.push(prevIdx, pivotIdx, bOuterStart);
-  else idx.push(prevIdx, bOuterStart, pivotIdx);
-}
-function emitBevel(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT) {
-  const jIdx = verts.length / 2;
-  verts.push(a.bx, a.by);
-  anchorA.push(cornerA);
-  anchorB.push(cornerB);
-  anchorT.push(cornerT);
-  if (onPositive) idx.push(aOuterEnd, jIdx, bOuterStart);
-  else idx.push(aOuterEnd, bOuterStart, jIdx);
-}
-function lineLineIntersect(apx, apy, adx, ady, bpx, bpy, bdx, bdy) {
-  const denom = adx * bdy - ady * bdx;
-  if (Math.abs(denom) < 1e-9) return null;
-  const t = ((bpx - apx) * bdy - (bpy - apy) * bdx) / denom;
-  return [apx + t * adx, apy + t * ady];
-}
-var UNDERLINE_OFFSET = 0.1;
-var STRIKETHROUGH_OFFSET = -0.3;
-var DECORATION_THICKNESS = 0.05;
-function fillKey(p) {
-  if ("color" in p) return `s:${p.color}:${p.opacity ?? 1}`;
-  return `nx:${Math.random()}`;
-}
-function sameFill(a, b) {
-  if (a === b) return true;
-  if ("color" in a && "color" in b) {
-    return a.color === b.color && (a.opacity ?? 1) === (b.opacity ?? 1);
-  }
-  return false;
+function sameFill(a, b) {
+  if (a === b) return true;
+  if ("color" in a && "color" in b) {
+    return a.color === b.color && (a.opacity ?? 1) === (b.opacity ?? 1);
+  }
+  return false;
 }
 function strokeKey(s) {
   if (!s) return "-";
@@ -5643,496 +4714,1096 @@ function layoutRuns(runs, opts) {
         prevFontSize = run.fontSize;
         continue;
       }
-      const glyphFont = hit.font;
-      const glyphScale = run.fontSize / glyphFont.info.size;
-      let kerningBefore = 0;
-      if (prevCp !== void 0 && prevFont !== void 0 && prevFontSize !== void 0) {
-        const kAtlas = prevFont.kerningMap.get(prevCp)?.get(cp) ?? 0;
-        kerningBefore = kAtlas * (prevFontSize / prevFont.info.size);
+      const glyphFont = hit.font;
+      const glyphScale = run.fontSize / glyphFont.info.size;
+      let kerningBefore = 0;
+      if (prevCp !== void 0 && prevFont !== void 0 && prevFontSize !== void 0) {
+        const kAtlas = prevFont.kerningMap.get(prevCp)?.get(cp) ?? 0;
+        kerningBefore = kAtlas * (prevFontSize / prevFont.info.size);
+      }
+      entries.push({
+        run,
+        font: glyphFont,
+        glyph: hit.glyph,
+        cp,
+        advance: hit.glyph.xadvance * glyphScale,
+        tracking,
+        kerningBefore,
+        isSpace,
+        isNewline: false,
+        resolved: hit.resolved,
+        fontSize: run.fontSize
+      });
+      prevCp = cp;
+      prevFont = glyphFont;
+      prevFontSize = run.fontSize;
+    }
+  }
+  const lines = [];
+  let cur = { entries: [], width: 0, height: 0 };
+  function commitLine() {
+    lines.push(cur);
+    cur = { entries: [], width: 0, height: 0 };
+  }
+  let i = 0;
+  while (i < entries.length) {
+    const e = entries[i];
+    if (e.isNewline) {
+      if (cur.entries.length === 0) {
+        cur.height = Math.max(cur.height, e.fontSize * opts.lineHeight);
+        cur.blank = e;
+      }
+      commitLine();
+      i++;
+      continue;
+    }
+    if (e.isSpace) {
+      if (cur.entries.length > 0) {
+        cur.entries.push(e);
+        cur.width += e.kerningBefore + e.advance + e.tracking;
+        cur.height = Math.max(cur.height, e.fontSize * opts.lineHeight);
+      }
+      i++;
+      continue;
+    }
+    let j = i;
+    let wordWidth = 0;
+    while (j < entries.length && !entries[j].isSpace && !entries[j].isNewline) {
+      const w = entries[j];
+      wordWidth += w.kerningBefore + w.advance + w.tracking;
+      j++;
+    }
+    if (Number.isFinite(opts.maxWidth) && cur.width + wordWidth > opts.maxWidth && cur.entries.length > 0) {
+      commitLine();
+    }
+    for (let k = i; k < j; k++) {
+      const w = entries[k];
+      const kerningBefore = cur.entries.length === 0 ? 0 : w.kerningBefore;
+      cur.entries.push({ ...w, kerningBefore });
+      cur.width += kerningBefore + w.advance + w.tracking;
+      cur.height = Math.max(cur.height, w.fontSize * opts.lineHeight);
+    }
+    i = j;
+  }
+  if (cur.entries.length > 0) commitLine();
+  function outlineFor(e) {
+    const min = opts.outlineMinSize;
+    if (min === void 0 || e.fontSize < min) return null;
+    if (e.resolved.synthetic.bold) return null;
+    const r = e.resolved.resolved;
+    return glyphOutline(r.family, r.weight, r.style, e.cp);
+  }
+  const decorations = [];
+  let span = null;
+  function flushSpan() {
+    const s = span;
+    span = null;
+    if (!s || s.x1 <= s.x0) return;
+    const thickness = s.fontSize * DECORATION_THICKNESS;
+    if (s.underline) {
+      const y0 = s.baselineY + s.fontSize * UNDERLINE_OFFSET;
+      decorations.push({ kind: "underline", x0: s.x0, y0, x1: s.x1, y1: y0 + thickness, fill: s.fill });
+    }
+    if (s.strikethrough) {
+      const y0 = s.baselineY + s.fontSize * STRIKETHROUGH_OFFSET;
+      decorations.push({ kind: "strikethrough", x0: s.x0, y0, x1: s.x1, y1: y0 + thickness, fill: s.fill });
+    }
+  }
+  const lineBoxes = [];
+  let penY = 0;
+  let maxLineWidth = 0;
+  const finiteWidth = Number.isFinite(opts.maxWidth) ? opts.maxWidth : 0;
+  for (const line of lines) {
+    const alignShift = (() => {
+      if (opts.align === "left") return 0;
+      if (!Number.isFinite(opts.maxWidth)) {
+        return opts.align === "center" ? -line.width / 2 : -line.width;
+      }
+      const slack = finiteWidth - line.width;
+      return opts.align === "center" ? slack / 2 : slack;
+    })();
+    const lineX0 = alignShift;
+    const baselineSource = line.entries[0] ?? line.blank;
+    const lineBaselineY = baselineSource ? penY + baselineSource.font.common.base * (baselineSource.fontSize / baselineSource.font.info.size) : penY;
+    let penX = lineX0;
+    for (const e of line.entries) {
+      penX += e.kerningBefore;
+      const step = e.advance + e.tracking;
+      const scale2 = e.fontSize / e.font.info.size;
+      const baselineY = penY + e.font.common.base * scale2;
+      if (e.run.underline || e.run.strikethrough) {
+        if (span !== null && span.underline === e.run.underline && span.strikethrough === e.run.strikethrough && span.fontSize === e.fontSize && span.baselineY === baselineY && sameFill(span.fill, e.run.fill)) {
+          span.x1 = penX + step;
+        } else {
+          flushSpan();
+          span = {
+            underline: e.run.underline,
+            strikethrough: e.run.strikethrough,
+            fill: e.run.fill,
+            fontSize: e.fontSize,
+            baselineY,
+            x0: penX,
+            x1: penX + step
+          };
+        }
+      } else {
+        flushSpan();
+      }
+      const outlineD = outlineFor(e);
+      if (outlineD !== null) {
+        const group2 = getOrCreateGroup(ctx, e.run, e.resolved, 0, "outline");
+        group2.glyphs.push({
+          d: outlineD,
+          key: `${e.resolved.resolved.family}|${e.resolved.resolved.weight}|${e.resolved.resolved.style}|${e.cp}`,
+          x: penX,
+          baselineY,
+          // Em space is unit-scale, so world units per em is just the size.
+          scale: e.fontSize
+        });
+        penX += step;
+        continue;
+      }
+      if (e.advance === 0 || e.glyph.width === 0 || e.glyph.page < 0) {
+        penX += step;
+        continue;
       }
-      entries.push({
-        run,
-        font: glyphFont,
-        glyph: hit.glyph,
-        cp,
-        advance: hit.glyph.xadvance * glyphScale,
-        tracking,
-        kerningBefore,
-        isSpace,
-        isNewline: false,
-        resolved: hit.resolved,
-        fontSize: run.fontSize
-      });
-      prevCp = cp;
-      prevFont = glyphFont;
-      prevFontSize = run.fontSize;
+      const group = getOrCreateGroup(ctx, e.run, e.resolved, e.glyph.page);
+      const atlasW = e.font.common.scaleW;
+      const atlasH = e.font.common.scaleH;
+      const qx0 = penX + e.glyph.xoffset * scale2;
+      const qy0 = penY + e.glyph.yoffset * scale2;
+      const qx1 = qx0 + e.glyph.width * scale2;
+      const qy1 = qy0 + e.glyph.height * scale2;
+      const u0 = e.glyph.x / atlasW;
+      const v0 = e.glyph.y / atlasH;
+      const u1 = (e.glyph.x + e.glyph.width) / atlasW;
+      const v1 = (e.glyph.y + e.glyph.height) / atlasH;
+      group.quads.push({ x0: qx0, y0: qy0, x1: qx1, y1: qy1, u0, v0, u1, v1, baselineY });
+      penX += step;
     }
+    flushSpan();
+    lineBoxes.push({
+      x0: lineX0,
+      y0: penY,
+      x1: lineX0 + line.width,
+      y1: penY + line.height,
+      baselineY: lineBaselineY
+    });
+    maxLineWidth = Math.max(maxLineWidth, line.width);
+    penY += line.height;
   }
-  const lines = [];
-  let cur = { entries: [], width: 0, height: 0 };
-  function commitLine() {
-    lines.push(cur);
-    cur = { entries: [], width: 0, height: 0 };
+  return {
+    groups: [...ctx.groups.values()],
+    decorations,
+    lines: lineBoxes,
+    bounds: { width: maxLineWidth, height: penY }
+  };
+}
+var LAYOUT_CACHE_VARIANT_LIMIT = 8;
+var cache2 = /* @__PURE__ */ new WeakMap();
+function outlineBucket(runs, min) {
+  if (min === void 0) return -1;
+  const sizes = /* @__PURE__ */ new Set();
+  for (const r of runs) sizes.add(r.fontSize);
+  let n = 0;
+  for (const size of sizes) if (size >= min) n++;
+  return n;
+}
+function variantKey2(runs, opts) {
+  return `${opts.maxWidth}|${opts.lineHeight}|${opts.align}|${outlineBucket(runs, opts.outlineMinSize)}`;
+}
+function cachedLayoutRuns(runs, opts) {
+  const fonts = glyphGeneration();
+  let entry = cache2.get(runs);
+  if (entry === void 0) {
+    entry = { generation: fonts, byVariant: /* @__PURE__ */ new Map() };
+    cache2.set(runs, entry);
+  } else if (entry.generation !== fonts) {
+    entry.generation = fonts;
+    entry.byVariant.clear();
   }
+  const key = variantKey2(runs, opts);
+  const hit = entry.byVariant.get(key);
+  if (hit !== void 0) return hit;
+  const laid = layoutRuns(runs, opts);
+  if (entry.byVariant.size >= LAYOUT_CACHE_VARIANT_LIMIT) entry.byVariant.clear();
+  entry.byVariant.set(key, laid);
+  return laid;
+}
+function verticalAlignOffset(align, boxHeight, textHeight) {
+  if (align === void 0 || align === "top" || boxHeight === void 0) return 0;
+  const slack = boxHeight - textHeight;
+  return align === "center" ? slack / 2 : slack;
+}
+var NUM_RE = /[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g;
+function tokenize(d) {
+  const out = [];
   let i = 0;
-  while (i < entries.length) {
-    const e = entries[i];
-    if (e.isNewline) {
-      if (cur.entries.length === 0) {
-        cur.height = Math.max(cur.height, e.fontSize * opts.lineHeight);
-        cur.blank = e;
-      }
-      commitLine();
+  while (i < d.length) {
+    const ch = d[i];
+    if (/[A-Za-z]/.test(ch)) {
+      let j = i + 1;
+      while (j < d.length && !/[A-Za-z]/.test(d[j])) j++;
+      const argSlice = d.slice(i + 1, j);
+      out.push({ cmd: ch, args: readNumbers(argSlice) });
+      i = j;
+    } else {
       i++;
+    }
+  }
+  return out;
+}
+function readNumbers(s) {
+  const out = [];
+  let m;
+  NUM_RE.lastIndex = 0;
+  while ((m = NUM_RE.exec(s)) !== null) {
+    const n = Number(m[0]);
+    if (Number.isFinite(n)) out.push(n);
+  }
+  return out;
+}
+var ARG_COUNTS = {
+  M: 2,
+  L: 2,
+  H: 1,
+  V: 1,
+  C: 6,
+  S: 4,
+  Q: 4,
+  T: 2,
+  A: 7,
+  Z: 0
+};
+function pathFromD(d, onWarn) {
+  const tokens = tokenize(d);
+  const b = new PathBuilder();
+  const st = {
+    x: 0,
+    y: 0,
+    startX: 0,
+    startY: 0,
+    lastCubicCtrl: null,
+    lastQuadCtrl: null
+  };
+  for (const { cmd, args } of tokens) {
+    const upper = cmd.toUpperCase();
+    const relative = cmd !== upper;
+    const argCount = ARG_COUNTS[upper];
+    if (argCount === void 0) {
       continue;
     }
-    if (e.isSpace) {
-      if (cur.entries.length > 0) {
-        cur.entries.push(e);
-        cur.width += e.kerningBefore + e.advance + e.tracking;
-        cur.height = Math.max(cur.height, e.fontSize * opts.lineHeight);
-      }
-      i++;
+    if (upper === "Z") {
+      b.close();
+      st.x = st.startX;
+      st.y = st.startY;
+      st.lastCubicCtrl = null;
+      st.lastQuadCtrl = null;
       continue;
     }
-    let j = i;
-    let wordWidth = 0;
-    while (j < entries.length && !entries[j].isSpace && !entries[j].isNewline) {
-      const w = entries[j];
-      wordWidth += w.kerningBefore + w.advance + w.tracking;
-      j++;
+    const groups = argCount === 0 ? 1 : Math.floor(args.length / argCount);
+    for (let g = 0; g < groups; g++) {
+      const a = args.slice(g * argCount, (g + 1) * argCount);
+      const effectiveUpper = upper === "M" && g > 0 ? "L" : upper;
+      runCommand(effectiveUpper, relative, a, st, b);
+    }
+  }
+  return b.build();
+}
+function runCommand(upper, relative, a, st, b) {
+  const rx = relative ? st.x : 0;
+  const ry = relative ? st.y : 0;
+  switch (upper) {
+    case "M": {
+      const x = a[0] + rx;
+      const y = a[1] + ry;
+      b.moveTo(x, y);
+      st.x = x;
+      st.y = y;
+      st.startX = x;
+      st.startY = y;
+      st.lastCubicCtrl = null;
+      st.lastQuadCtrl = null;
+      return;
+    }
+    case "L": {
+      const x = a[0] + rx;
+      const y = a[1] + ry;
+      b.lineTo(x, y);
+      st.x = x;
+      st.y = y;
+      st.lastCubicCtrl = null;
+      st.lastQuadCtrl = null;
+      return;
+    }
+    case "H": {
+      const x = a[0] + (relative ? st.x : 0);
+      b.lineTo(x, st.y);
+      st.x = x;
+      st.lastCubicCtrl = null;
+      st.lastQuadCtrl = null;
+      return;
+    }
+    case "V": {
+      const y = a[0] + (relative ? st.y : 0);
+      b.lineTo(st.x, y);
+      st.y = y;
+      st.lastCubicCtrl = null;
+      st.lastQuadCtrl = null;
+      return;
+    }
+    case "C": {
+      const x1 = a[0] + rx, y1 = a[1] + ry;
+      const x2 = a[2] + rx, y2 = a[3] + ry;
+      const x = a[4] + rx, y = a[5] + ry;
+      b.curveTo(x1, y1, x2, y2, x, y);
+      st.x = x;
+      st.y = y;
+      st.lastCubicCtrl = { x: x2, y: y2 };
+      st.lastQuadCtrl = null;
+      return;
+    }
+    case "S": {
+      const ref = st.lastCubicCtrl ?? { x: st.x, y: st.y };
+      const x1 = 2 * st.x - ref.x;
+      const y1 = 2 * st.y - ref.y;
+      const x2 = a[0] + rx, y2 = a[1] + ry;
+      const x = a[2] + rx, y = a[3] + ry;
+      b.curveTo(x1, y1, x2, y2, x, y);
+      st.x = x;
+      st.y = y;
+      st.lastCubicCtrl = { x: x2, y: y2 };
+      st.lastQuadCtrl = null;
+      return;
+    }
+    case "Q": {
+      const x1 = a[0] + rx, y1 = a[1] + ry;
+      const x = a[2] + rx, y = a[3] + ry;
+      b.quadTo(x1, y1, x, y);
+      st.x = x;
+      st.y = y;
+      st.lastQuadCtrl = { x: x1, y: y1 };
+      st.lastCubicCtrl = null;
+      return;
     }
-    if (Number.isFinite(opts.maxWidth) && cur.width + wordWidth > opts.maxWidth && cur.entries.length > 0) {
-      commitLine();
+    case "T": {
+      const ref = st.lastQuadCtrl ?? { x: st.x, y: st.y };
+      const x1 = 2 * st.x - ref.x;
+      const y1 = 2 * st.y - ref.y;
+      const x = a[0] + rx, y = a[1] + ry;
+      b.quadTo(x1, y1, x, y);
+      st.x = x;
+      st.y = y;
+      st.lastQuadCtrl = { x: x1, y: y1 };
+      st.lastCubicCtrl = null;
+      return;
     }
-    for (let k = i; k < j; k++) {
-      const w = entries[k];
-      const kerningBefore = cur.entries.length === 0 ? 0 : w.kerningBefore;
-      cur.entries.push({ ...w, kerningBefore });
-      cur.width += kerningBefore + w.advance + w.tracking;
-      cur.height = Math.max(cur.height, w.fontSize * opts.lineHeight);
+    case "A": {
+      const rxA = Math.abs(a[0]);
+      const ryA = Math.abs(a[1]);
+      const xRot = a[2];
+      const largeArc = a[3] !== 0;
+      const sweep = a[4] !== 0;
+      const ex = a[5] + rx;
+      const ey = a[6] + ry;
+      arcToCubics(st.x, st.y, ex, ey, rxA, ryA, xRot, largeArc, sweep, b);
+      st.x = ex;
+      st.y = ey;
+      st.lastCubicCtrl = null;
+      st.lastQuadCtrl = null;
+      return;
     }
-    i = j;
+    default:
+      return;
   }
-  if (cur.entries.length > 0) commitLine();
-  function outlineFor(e) {
-    const min = opts.outlineMinSize;
-    if (min === void 0 || e.fontSize < min) return null;
-    if (e.resolved.synthetic.bold) return null;
-    const r = e.resolved.resolved;
-    return glyphOutline(r.family, r.weight, r.style, e.cp);
+}
+function arcToCubics(x1, y1, x2, y2, rx, ry, xAxisRotationDeg, largeArc, sweep, b) {
+  if (x1 === x2 && y1 === y2) return;
+  if (rx === 0 || ry === 0) {
+    b.lineTo(x2, y2);
+    return;
   }
-  const decorations = [];
-  let span = null;
-  function flushSpan() {
-    const s = span;
-    span = null;
-    if (!s || s.x1 <= s.x0) return;
-    const thickness = s.fontSize * DECORATION_THICKNESS;
-    if (s.underline) {
-      const y0 = s.baselineY + s.fontSize * UNDERLINE_OFFSET;
-      decorations.push({ kind: "underline", x0: s.x0, y0, x1: s.x1, y1: y0 + thickness, fill: s.fill });
-    }
-    if (s.strikethrough) {
-      const y0 = s.baselineY + s.fontSize * STRIKETHROUGH_OFFSET;
-      decorations.push({ kind: "strikethrough", x0: s.x0, y0, x1: s.x1, y1: y0 + thickness, fill: s.fill });
-    }
+  const phi = xAxisRotationDeg * Math.PI / 180;
+  const cosPhi = Math.cos(phi);
+  const sinPhi = Math.sin(phi);
+  const dx = (x1 - x2) / 2;
+  const dy = (y1 - y2) / 2;
+  const x1p = cosPhi * dx + sinPhi * dy;
+  const y1p = -sinPhi * dx + cosPhi * dy;
+  let rxs = rx * rx;
+  let rys = ry * ry;
+  const x1ps = x1p * x1p;
+  const y1ps = y1p * y1p;
+  const lambda = x1ps / rxs + y1ps / rys;
+  let rxFixed = rx;
+  let ryFixed = ry;
+  if (lambda > 1) {
+    const sqrtLambda = Math.sqrt(lambda);
+    rxFixed = sqrtLambda * rx;
+    ryFixed = sqrtLambda * ry;
+    rxs = rxFixed * rxFixed;
+    rys = ryFixed * ryFixed;
   }
-  const lineBoxes = [];
-  let penY = 0;
-  let maxLineWidth = 0;
-  const finiteWidth = Number.isFinite(opts.maxWidth) ? opts.maxWidth : 0;
-  for (const line of lines) {
-    const alignShift = (() => {
-      if (opts.align === "left") return 0;
-      if (!Number.isFinite(opts.maxWidth)) {
-        return opts.align === "center" ? -line.width / 2 : -line.width;
-      }
-      const slack = finiteWidth - line.width;
-      return opts.align === "center" ? slack / 2 : slack;
-    })();
-    const lineX0 = alignShift;
-    const baselineSource = line.entries[0] ?? line.blank;
-    const lineBaselineY = baselineSource ? penY + baselineSource.font.common.base * (baselineSource.fontSize / baselineSource.font.info.size) : penY;
-    let penX = lineX0;
-    for (const e of line.entries) {
-      penX += e.kerningBefore;
-      const step = e.advance + e.tracking;
-      const scale2 = e.fontSize / e.font.info.size;
-      const baselineY = penY + e.font.common.base * scale2;
-      if (e.run.underline || e.run.strikethrough) {
-        if (span !== null && span.underline === e.run.underline && span.strikethrough === e.run.strikethrough && span.fontSize === e.fontSize && span.baselineY === baselineY && sameFill(span.fill, e.run.fill)) {
-          span.x1 = penX + step;
-        } else {
-          flushSpan();
-          span = {
-            underline: e.run.underline,
-            strikethrough: e.run.strikethrough,
-            fill: e.run.fill,
-            fontSize: e.fontSize,
-            baselineY,
-            x0: penX,
-            x1: penX + step
-          };
+  const sign2 = largeArc === sweep ? -1 : 1;
+  const num = rxs * rys - rxs * y1ps - rys * x1ps;
+  const den = rxs * y1ps + rys * x1ps;
+  const factor = sign2 * Math.sqrt(Math.max(0, num / den));
+  const cxp = factor * (rxFixed * y1p) / ryFixed;
+  const cyp = factor * -(ryFixed * x1p) / rxFixed;
+  const cx = cosPhi * cxp - sinPhi * cyp + (x1 + x2) / 2;
+  const cy = sinPhi * cxp + cosPhi * cyp + (y1 + y2) / 2;
+  const angle = (ux, uy, vx, vy) => {
+    const dot = ux * vx + uy * vy;
+    const len = Math.sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy));
+    let a = Math.acos(Math.max(-1, Math.min(1, dot / len)));
+    if (ux * vy - uy * vx < 0) a = -a;
+    return a;
+  };
+  const theta1 = angle(1, 0, (x1p - cxp) / rxFixed, (y1p - cyp) / ryFixed);
+  let dTheta = angle(
+    (x1p - cxp) / rxFixed,
+    (y1p - cyp) / ryFixed,
+    (-x1p - cxp) / rxFixed,
+    (-y1p - cyp) / ryFixed
+  );
+  if (!sweep && dTheta > 0) dTheta -= 2 * Math.PI;
+  else if (sweep && dTheta < 0) dTheta += 2 * Math.PI;
+  const segCount = Math.max(1, Math.ceil(Math.abs(dTheta) / (Math.PI / 2)));
+  const segAngle = dTheta / segCount;
+  const t = 4 / 3 * Math.tan(segAngle / 4);
+  let prevX = x1;
+  let prevY = y1;
+  let prevDx = -Math.sin(theta1) * rxFixed;
+  let prevDy = Math.cos(theta1) * ryFixed;
+  for (let i = 1; i <= segCount; i++) {
+    const theta = theta1 + i * segAngle;
+    const cosT = Math.cos(theta);
+    const sinT = Math.sin(theta);
+    const px = cosPhi * (cosT * rxFixed) - sinPhi * (sinT * ryFixed) + cx;
+    const py = sinPhi * (cosT * rxFixed) + cosPhi * (sinT * ryFixed) + cy;
+    const dxNew = -sinT * rxFixed;
+    const dyNew = cosT * ryFixed;
+    const c1x = prevX + cosPhi * (t * prevDx) - sinPhi * (t * prevDy);
+    const c1y = prevY + sinPhi * (t * prevDx) + cosPhi * (t * prevDy);
+    const c2x = px - cosPhi * (t * dxNew) + sinPhi * (t * dyNew);
+    const c2y = py - sinPhi * (t * dxNew) - cosPhi * (t * dyNew);
+    b.curveTo(c1x, c1y, c2x, c2y, px, py);
+    prevX = px;
+    prevY = py;
+    prevDx = dxNew;
+    prevDy = dyNew;
+  }
+}
+var OUTLINE_FLATTEN_TOLERANCE = 1 / 4096;
+var OUTLINE_MESH_CACHE_LIMIT = 2048;
+var cache3 = /* @__PURE__ */ new Map();
+function outlineMesh(key, d) {
+  const cached2 = cache3.get(key);
+  if (cached2 !== void 0) return cached2;
+  if (cache3.size >= OUTLINE_MESH_CACHE_LIMIT) cache3 = /* @__PURE__ */ new Map();
+  const mesh = tessellate(pathFromD(d), { flattenTolerance: OUTLINE_FLATTEN_TOLERANCE });
+  cache3.set(key, mesh);
+  return mesh;
+}
+function extractPolylines(path, opts = {}) {
+  if (path.kind === "rect") return [extractRect(path)];
+  return extractPolygon(path, opts);
+}
+function extractRect(p) {
+  const { x, y, width: w, height: h } = p;
+  return {
+    points: [x, y, x + w, y, x + w, y + h, x, y + h],
+    closed: true,
+    anchorA: new Uint32Array([0, 1, 2, 3]),
+    anchorB: new Uint32Array([0, 1, 2, 3]),
+    anchorT: new Float32Array([0, 0, 0, 0])
+  };
+}
+function extractPolygon(p, opts) {
+  const tolerance = opts.flattenTolerance ?? DEFAULT_FLATTEN_TOLERANCE;
+  const { commands, coords } = p;
+  const out = [];
+  let anchorCounter = 0;
+  let pts = null;
+  let aA = null;
+  let aB = null;
+  let aT = null;
+  let current = null;
+  let coordIdx = 0;
+  let prevX = 0;
+  let prevY = 0;
+  let prevAnchor = -1;
+  const beginContour = () => {
+    pts = [];
+    aA = [];
+    aB = [];
+    aT = [];
+    const next = { points: pts, closed: false };
+    out.push(next);
+    return next;
+  };
+  const dropDuplicateClosingPoint = () => {
+    if (!pts || !aA || !aB || !aT) return;
+    const n = pts.length / 2;
+    if (n < 2) return;
+    if (pts[0] !== pts[(n - 1) * 2] || pts[1] !== pts[(n - 1) * 2 + 1]) return;
+    pts.length -= 2;
+    aA.length -= 1;
+    aB.length -= 1;
+    aT.length -= 1;
+  };
+  const commit = (target) => {
+    if (!pts || !aA || !aB || !aT) return;
+    target.anchorA = new Uint32Array(aA);
+    target.anchorB = new Uint32Array(aB);
+    target.anchorT = new Float32Array(aT);
+  };
+  for (let cmdIdx = 0; cmdIdx < commands.length; cmdIdx++) {
+    const cmd = commands[cmdIdx];
+    switch (cmd) {
+      case PATH_M2: {
+        if (current) commit(current);
+        current = beginContour();
+        prevX = coords[coordIdx];
+        prevY = coords[coordIdx + 1];
+        pts.push(prevX, prevY);
+        aA.push(anchorCounter);
+        aB.push(anchorCounter);
+        aT.push(0);
+        prevAnchor = anchorCounter;
+        anchorCounter++;
+        coordIdx += 2;
+        break;
+      }
+      case PATH_L2: {
+        prevX = coords[coordIdx];
+        prevY = coords[coordIdx + 1];
+        pts.push(prevX, prevY);
+        aA.push(anchorCounter);
+        aB.push(anchorCounter);
+        aT.push(0);
+        prevAnchor = anchorCounter;
+        anchorCounter++;
+        coordIdx += 2;
+        break;
+      }
+      case PATH_Q2: {
+        const cx = coords[coordIdx], cy = coords[coordIdx + 1];
+        const ex = coords[coordIdx + 2], ey = coords[coordIdx + 3];
+        const targetAnchor = anchorCounter;
+        const segStart = pts.length / 2;
+        const arcAccum = [];
+        const total = flattenQuadraticWithArcLen(prevX, prevY, cx, cy, ex, ey, tolerance, pts, arcAccum);
+        for (let k = 0; k < arcAccum.length; k++) {
+          aA.push(prevAnchor);
+          aB.push(targetAnchor);
+          aT.push(total > 0 ? arcAccum[k] / total : 0);
         }
-      } else {
-        flushSpan();
+        const lastIdx = segStart + arcAccum.length - 1;
+        aA[lastIdx] = targetAnchor;
+        aB[lastIdx] = targetAnchor;
+        aT[lastIdx] = 0;
+        prevX = ex;
+        prevY = ey;
+        prevAnchor = targetAnchor;
+        anchorCounter++;
+        coordIdx += 4;
+        break;
       }
-      const outlineD = outlineFor(e);
-      if (outlineD !== null) {
-        const group2 = getOrCreateGroup(ctx, e.run, e.resolved, 0, "outline");
-        group2.glyphs.push({
-          d: outlineD,
-          key: `${e.resolved.resolved.family}|${e.resolved.resolved.weight}|${e.resolved.resolved.style}|${e.cp}`,
-          x: penX,
-          baselineY,
-          // Em space is unit-scale, so world units per em is just the size.
-          scale: e.fontSize
-        });
-        penX += step;
-        continue;
+      case PATH_C2: {
+        const c1x = coords[coordIdx], c1y = coords[coordIdx + 1];
+        const c2x = coords[coordIdx + 2], c2y = coords[coordIdx + 3];
+        const ex = coords[coordIdx + 4], ey = coords[coordIdx + 5];
+        const targetAnchor = anchorCounter;
+        const segStart = pts.length / 2;
+        const arcAccum = [];
+        const total = flattenCubicWithArcLen(prevX, prevY, c1x, c1y, c2x, c2y, ex, ey, tolerance, pts, arcAccum);
+        for (let k = 0; k < arcAccum.length; k++) {
+          aA.push(prevAnchor);
+          aB.push(targetAnchor);
+          aT.push(total > 0 ? arcAccum[k] / total : 0);
+        }
+        const lastIdx = segStart + arcAccum.length - 1;
+        aA[lastIdx] = targetAnchor;
+        aB[lastIdx] = targetAnchor;
+        aT[lastIdx] = 0;
+        prevX = ex;
+        prevY = ey;
+        prevAnchor = targetAnchor;
+        anchorCounter++;
+        coordIdx += 6;
+        break;
       }
-      if (e.advance === 0 || e.glyph.width === 0 || e.glyph.page < 0) {
-        penX += step;
-        continue;
+      case PATH_Z2: {
+        if (current) {
+          current.closed = true;
+          dropDuplicateClosingPoint();
+        }
+        break;
       }
-      const group = getOrCreateGroup(ctx, e.run, e.resolved, e.glyph.page);
-      const atlasW = e.font.common.scaleW;
-      const atlasH = e.font.common.scaleH;
-      const qx0 = penX + e.glyph.xoffset * scale2;
-      const qy0 = penY + e.glyph.yoffset * scale2;
-      const qx1 = qx0 + e.glyph.width * scale2;
-      const qy1 = qy0 + e.glyph.height * scale2;
-      const u0 = e.glyph.x / atlasW;
-      const v0 = e.glyph.y / atlasH;
-      const u1 = (e.glyph.x + e.glyph.width) / atlasW;
-      const v1 = (e.glyph.y + e.glyph.height) / atlasH;
-      group.quads.push({ x0: qx0, y0: qy0, x1: qx1, y1: qy1, u0, v0, u1, v1, baselineY });
-      penX += step;
+      default:
+        throw new Error(`extractPolylines: unknown command code ${cmd}`);
+    }
+  }
+  if (current) commit(current);
+  return out;
+}
+var EMPTY_MESH = {
+  vertices: new Float32Array(0),
+  indices: new Uint32Array(0),
+  anchorA: new Uint32Array(0),
+  anchorB: new Uint32Array(0),
+  anchorT: new Float32Array(0)
+};
+function tessellateStroke(path, stroke, opts = {}) {
+  const width = stroke.width ?? 1;
+  if (width <= 0) return EMPTY_MESH;
+  const join = stroke.join ?? "miter";
+  const cap = stroke.cap ?? "butt";
+  const align = stroke.align ?? "center";
+  const miterLimit = stroke.miterLimit ?? DEFAULT_MITER_LIMIT;
+  const varyingThreshold = stroke.varyingWidthJoinThreshold ?? DEFAULT_VARYING_WIDTH_JOIN_THRESHOLD;
+  let workingPath = path;
+  if (path.kind === "rect" && align !== "center") {
+    const aligned = alignedStrokeRect(path, align, width);
+    workingPath = {
+      kind: "rect",
+      x: aligned.x,
+      y: aligned.y,
+      width: aligned.width,
+      height: aligned.height
+    };
+  }
+  const polylines = extractPolylines(workingPath, opts);
+  if (stroke.vertexWidths && stroke.vertexWidths.length > 0) {
+    for (const pl of polylines) populatePolylineWidths(pl, stroke.vertexWidths, width);
+  }
+  const dash = stroke.dash ?? [];
+  const verts = [];
+  const idx = [];
+  const anchorA = [];
+  const anchorB = [];
+  const anchorT = [];
+  for (const pl of polylines) {
+    const subs = dash.length > 0 ? splitForDash(pl, dash) : [pl];
+    for (const sub2 of subs) {
+      expandPolyline(sub2, width, join, cap, miterLimit, varyingThreshold, verts, idx, anchorA, anchorB, anchorT);
     }
-    flushSpan();
-    lineBoxes.push({
-      x0: lineX0,
-      y0: penY,
-      x1: lineX0 + line.width,
-      y1: penY + line.height,
-      baselineY: lineBaselineY
-    });
-    maxLineWidth = Math.max(maxLineWidth, line.width);
-    penY += line.height;
   }
   return {
-    groups: [...ctx.groups.values()],
-    decorations,
-    lines: lineBoxes,
-    bounds: { width: maxLineWidth, height: penY }
+    vertices: new Float32Array(verts),
+    indices: new Uint32Array(idx),
+    anchorA: new Uint32Array(anchorA),
+    anchorB: new Uint32Array(anchorB),
+    anchorT: new Float32Array(anchorT)
   };
 }
-var LAYOUT_CACHE_VARIANT_LIMIT = 8;
-var cache2 = /* @__PURE__ */ new WeakMap();
-function outlineBucket(runs, min) {
-  if (min === void 0) return -1;
-  const sizes = /* @__PURE__ */ new Set();
-  for (const r of runs) sizes.add(r.fontSize);
-  let n = 0;
-  for (const size of sizes) if (size >= min) n++;
-  return n;
-}
-function variantKey2(runs, opts) {
-  return `${opts.maxWidth}|${opts.lineHeight}|${opts.align}|${outlineBucket(runs, opts.outlineMinSize)}`;
-}
-function cachedLayoutRuns(runs, opts) {
-  const fonts = glyphGeneration();
-  let entry = cache2.get(runs);
-  if (entry === void 0) {
-    entry = { generation: fonts, byVariant: /* @__PURE__ */ new Map() };
-    cache2.set(runs, entry);
-  } else if (entry.generation !== fonts) {
-    entry.generation = fonts;
-    entry.byVariant.clear();
+function expandPolyline(pl, width, join, cap, miterLimit, varyingThreshold, verts, idx, anchorA, anchorB, anchorT) {
+  const half = width / 2;
+  const pts = pl.points;
+  const ptCount = pts.length / 2;
+  const segCount = ptCount - 1;
+  if (segCount < 1) return;
+  const plA = pl.anchorA ?? new Uint32Array(ptCount);
+  const plB = pl.anchorB ?? new Uint32Array(ptCount);
+  const plT = pl.anchorT ?? new Float32Array(ptCount);
+  const plHalf = pl.widths ? pl.widths.map((w) => w / 2) : null;
+  const segs = [];
+  const segSrcIdx = [];
+  for (let s = 0; s < segCount; s++) {
+    const ha = plHalf ? plHalf[s] : half;
+    const hb = plHalf ? plHalf[s + 1] : half;
+    const seg = makeSeg(pts[s * 2], pts[s * 2 + 1], pts[(s + 1) * 2], pts[(s + 1) * 2 + 1], ha, hb);
+    if (seg) {
+      segs.push(seg);
+      segSrcIdx.push(s);
+    }
+  }
+  let closerSrcIdx = -1;
+  if (pl.closed && segs.length >= 1) {
+    const last = segs[segs.length - 1];
+    const first = segs[0];
+    const haCloser = plHalf ? plHalf[ptCount - 1] : half;
+    const hbCloser = plHalf ? plHalf[0] : half;
+    const closer = makeSeg(last.bx, last.by, first.ax, first.ay, haCloser, hbCloser);
+    if (closer) {
+      segs.push(closer);
+      closerSrcIdx = ptCount - 1;
+      segSrcIdx.push(closerSrcIdx);
+    }
+  }
+  if (segs.length === 0) return;
+  const segBaseIdx = [];
+  for (let s = 0; s < segs.length; s++) {
+    const seg = segs[s];
+    const startSrc = segSrcIdx[s];
+    const endSrc = s === segs.length - 1 && pl.closed && closerSrcIdx >= 0 ? 0 : startSrc + 1;
+    const base = verts.length / 2;
+    segBaseIdx.push(base);
+    const nxA = seg.nxUnit * seg.halfA, nyA = seg.nyUnit * seg.halfA;
+    const nxB = seg.nxUnit * seg.halfB, nyB = seg.nyUnit * seg.halfB;
+    verts.push(seg.ax + nxA, seg.ay + nyA);
+    anchorA.push(plA[startSrc]);
+    anchorB.push(plB[startSrc]);
+    anchorT.push(plT[startSrc]);
+    verts.push(seg.ax - nxA, seg.ay - nyA);
+    anchorA.push(plA[startSrc]);
+    anchorB.push(plB[startSrc]);
+    anchorT.push(plT[startSrc]);
+    verts.push(seg.bx + nxB, seg.by + nyB);
+    anchorA.push(plA[endSrc]);
+    anchorB.push(plB[endSrc]);
+    anchorT.push(plT[endSrc]);
+    verts.push(seg.bx - nxB, seg.by - nyB);
+    anchorA.push(plA[endSrc]);
+    anchorB.push(plB[endSrc]);
+    anchorT.push(plT[endSrc]);
+    idx.push(base, base + 1, base + 2, base + 1, base + 3, base + 2);
+  }
+  const joinCount = pl.closed ? segs.length : segs.length - 1;
+  for (let j = 0; j < joinCount; j++) {
+    emitJoin(segs, segBaseIdx, j, join, miterLimit, varyingThreshold, verts, idx, anchorA, anchorB, anchorT, segSrcIdx, plA, plB, plT);
+  }
+  if (!pl.closed && cap !== "butt") {
+    const first = segs[0];
+    const firstBase = segBaseIdx[0];
+    emitCap(first, firstBase + 0, firstBase + 1, false, first.halfA, cap, verts, idx, anchorA, anchorB, anchorT, plA[0], plB[0], plT[0]);
+    const last = segs[segs.length - 1];
+    const lastBase = segBaseIdx[segs.length - 1];
+    const lastSrc = segSrcIdx[segs.length - 1] + 1;
+    emitCap(last, lastBase + 2, lastBase + 3, true, last.halfB, cap, verts, idx, anchorA, anchorB, anchorT, plA[lastSrc], plB[lastSrc], plT[lastSrc]);
   }
-  const key = variantKey2(runs, opts);
-  const hit = entry.byVariant.get(key);
-  if (hit !== void 0) return hit;
-  const laid = layoutRuns(runs, opts);
-  if (entry.byVariant.size >= LAYOUT_CACHE_VARIANT_LIMIT) entry.byVariant.clear();
-  entry.byVariant.set(key, laid);
-  return laid;
-}
-function verticalAlignOffset(align, boxHeight, textHeight) {
-  if (align === void 0 || align === "top" || boxHeight === void 0) return 0;
-  const slack = boxHeight - textHeight;
-  return align === "center" ? slack / 2 : slack;
 }
-var NUM_RE = /[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g;
-function tokenize(d) {
-  const out = [];
-  let i = 0;
-  while (i < d.length) {
-    const ch = d[i];
-    if (/[A-Za-z]/.test(ch)) {
-      let j = i + 1;
-      while (j < d.length && !/[A-Za-z]/.test(d[j])) j++;
-      const argSlice = d.slice(i + 1, j);
-      out.push({ cmd: ch, args: readNumbers(argSlice) });
-      i = j;
+function populatePolylineWidths(pl, vertexWidths, fallbackWidth) {
+  const ptCount = pl.points.length / 2;
+  if (ptCount === 0) return;
+  const aA = pl.anchorA ?? new Uint32Array(ptCount);
+  const aB = pl.anchorB ?? new Uint32Array(ptCount);
+  const aT = pl.anchorT ?? new Float32Array(ptCount);
+  const widths = new Float32Array(ptCount);
+  const read2 = (i) => {
+    const v = vertexWidths[i];
+    return typeof v === "number" && isFinite(v) && v > 0 ? v : fallbackWidth;
+  };
+  for (let i = 0; i < ptCount; i++) {
+    const a = aA[i], b = aB[i], t = aT[i];
+    if (a === b) {
+      widths[i] = read2(a);
     } else {
-      i++;
+      const wa = read2(a);
+      const wb = read2(b);
+      widths[i] = wa + (wb - wa) * t;
     }
   }
-  return out;
+  pl.widths = widths;
 }
-function readNumbers(s) {
-  const out = [];
-  let m;
-  NUM_RE.lastIndex = 0;
-  while ((m = NUM_RE.exec(s)) !== null) {
-    const n = Number(m[0]);
-    if (Number.isFinite(n)) out.push(n);
+var ROUND_CAP_STEP_RAD = 10 * Math.PI / 180;
+function emitCap(seg, leftIdx, rightIdx, atEnd, half, cap, verts, idx, anchorA, anchorB, anchorT, endA, endB, endT) {
+  const sign2 = atEnd ? 1 : -1;
+  const dx = (seg.bx - seg.ax) / seg.len * sign2;
+  const dy = (seg.by - seg.ay) / seg.len * sign2;
+  const cx = atEnd ? seg.bx : seg.ax;
+  const cy = atEnd ? seg.by : seg.ay;
+  const nx = seg.nxUnit * half;
+  const ny = seg.nyUnit * half;
+  if (cap === "square") {
+    const ox = cx + dx * half;
+    const oy = cy + dy * half;
+    const lOut = verts.length / 2;
+    verts.push(ox + nx, oy + ny);
+    anchorA.push(endA);
+    anchorB.push(endB);
+    anchorT.push(endT);
+    const rOut = verts.length / 2;
+    verts.push(ox - nx, oy - ny);
+    anchorA.push(endA);
+    anchorB.push(endB);
+    anchorT.push(endT);
+    if (atEnd) {
+      idx.push(leftIdx, lOut, rOut, leftIdx, rOut, rightIdx);
+    } else {
+      idx.push(leftIdx, rOut, lOut, leftIdx, rightIdx, rOut);
+    }
+    return;
   }
-  return out;
-}
-var ARG_COUNTS = {
-  M: 2,
-  L: 2,
-  H: 1,
-  V: 1,
-  C: 6,
-  S: 4,
-  Q: 4,
-  T: 2,
-  A: 7,
-  Z: 0
-};
-function pathFromD(d, onWarn) {
-  const tokens = tokenize(d);
-  const b = new PathBuilder();
-  const st = {
-    x: 0,
-    y: 0,
-    startX: 0,
-    startY: 0,
-    lastCubicCtrl: null,
-    lastQuadCtrl: null
-  };
-  for (const { cmd, args } of tokens) {
-    const upper = cmd.toUpperCase();
-    const relative = cmd !== upper;
-    const argCount = ARG_COUNTS[upper];
-    if (argCount === void 0) {
-      continue;
+  if (cap === "round") {
+    const pivotIdx = verts.length / 2;
+    verts.push(cx, cy);
+    anchorA.push(endA);
+    anchorB.push(endB);
+    anchorT.push(endT);
+    const startAngle = Math.atan2(ny, nx);
+    const sweep = atEnd ? -Math.PI : Math.PI;
+    const steps = Math.max(1, Math.ceil(Math.abs(sweep) / ROUND_CAP_STEP_RAD));
+    const stepAngle = sweep / steps;
+    let prevIdx = leftIdx;
+    for (let i = 1; i < steps; i++) {
+      const ang = startAngle + i * stepAngle;
+      const fx = cx + Math.cos(ang) * half;
+      const fy = cy + Math.sin(ang) * half;
+      const newIdx = verts.length / 2;
+      verts.push(fx, fy);
+      anchorA.push(endA);
+      anchorB.push(endB);
+      anchorT.push(endT);
+      if (atEnd) idx.push(prevIdx, newIdx, pivotIdx);
+      else idx.push(prevIdx, pivotIdx, newIdx);
+      prevIdx = newIdx;
     }
-    if (upper === "Z") {
-      b.close();
-      st.x = st.startX;
-      st.y = st.startY;
-      st.lastCubicCtrl = null;
-      st.lastQuadCtrl = null;
-      continue;
+    if (atEnd) idx.push(prevIdx, rightIdx, pivotIdx);
+    else idx.push(prevIdx, pivotIdx, rightIdx);
+  }
+}
+function splitForDash(pl, dash) {
+  const out = [];
+  const plA = pl.anchorA ?? new Uint32Array(pl.points.length / 2);
+  const plB = pl.anchorB ?? new Uint32Array(pl.points.length / 2);
+  const plT = pl.anchorT ?? new Float32Array(pl.points.length / 2);
+  let dashIdx = 0;
+  let dashRemaining = dash[0];
+  let onPhase = true;
+  let curPts = onPhase ? [pl.points[0], pl.points[1]] : null;
+  let curA = onPhase ? [plA[0]] : null;
+  let curB = onPhase ? [plB[0]] : null;
+  let curT = onPhase ? [plT[0]] : null;
+  const flushAndAdvance = () => {
+    if (curPts && curPts.length >= 4) {
+      out.push({
+        points: curPts,
+        closed: false,
+        anchorA: new Uint32Array(curA),
+        anchorB: new Uint32Array(curB),
+        anchorT: new Float32Array(curT)
+      });
     }
-    const groups = argCount === 0 ? 1 : Math.floor(args.length / argCount);
-    for (let g = 0; g < groups; g++) {
-      const a = args.slice(g * argCount, (g + 1) * argCount);
-      const effectiveUpper = upper === "M" && g > 0 ? "L" : upper;
-      runCommand(effectiveUpper, relative, a, st, b);
+    curPts = null;
+    curA = null;
+    curB = null;
+    curT = null;
+    dashIdx = (dashIdx + 1) % dash.length;
+    dashRemaining = dash[dashIdx];
+    onPhase = !onPhase;
+  };
+  let prevX = pl.points[0], prevY = pl.points[1];
+  const ptCount = pl.points.length / 2;
+  const segCount = pl.closed ? ptCount : ptCount - 1;
+  for (let i = 0; i < segCount; i++) {
+    const nextIdx = (i + 1) % ptCount;
+    const cx = pl.points[nextIdx * 2], cy = pl.points[nextIdx * 2 + 1];
+    const startA = plA[i], startB = plB[i], startT = plT[i];
+    const endA = plA[nextIdx], endB = plB[nextIdx], endT = plT[nextIdx];
+    const segFullDx = cx - prevX, segFullDy = cy - prevY;
+    const segFullLen = Math.hypot(segFullDx, segFullDy);
+    let segDx = segFullDx, segDy = segFullDy;
+    let segLen = segFullLen;
+    let traveled = 0;
+    while (segLen > 1e-9) {
+      if (segLen <= dashRemaining) {
+        if (onPhase && curPts) {
+          curPts.push(cx, cy);
+          curA.push(endA);
+          curB.push(endB);
+          curT.push(endT);
+        }
+        dashRemaining -= segLen;
+        prevX = cx;
+        prevY = cy;
+        traveled = segFullLen;
+        segLen = 0;
+        if (dashRemaining <= 1e-9) {
+          flushAndAdvance();
+          if (onPhase) {
+            curPts = [prevX, prevY];
+            curA = [endA];
+            curB = [endB];
+            curT = [endT];
+          }
+        }
+      } else {
+        const tConsume = dashRemaining / segLen;
+        const ix = prevX + segDx * tConsume;
+        const iy = prevY + segDy * tConsume;
+        traveled += dashRemaining;
+        const frac = traveled / segFullLen;
+        let mA, mB, mT;
+        if (startA === endA && startB === endB) {
+          mA = startA;
+          mB = startB;
+          mT = startT + (endT - startT) * frac;
+        } else {
+          if (frac < 0.5) {
+            mA = startA;
+            mB = startB;
+            mT = startT;
+          } else {
+            mA = endA;
+            mB = endB;
+            mT = endT;
+          }
+        }
+        if (onPhase && curPts) {
+          curPts.push(ix, iy);
+          curA.push(mA);
+          curB.push(mB);
+          curT.push(mT);
+        }
+        prevX = ix;
+        prevY = iy;
+        segDx = cx - prevX;
+        segDy = cy - prevY;
+        segLen = Math.hypot(segDx, segDy);
+        flushAndAdvance();
+        if (onPhase) {
+          curPts = [prevX, prevY];
+          curA = [mA];
+          curB = [mB];
+          curT = [mT];
+        }
+      }
     }
   }
-  return b.build();
+  if (curPts && curPts.length >= 4) {
+    out.push({
+      points: curPts,
+      closed: false,
+      anchorA: new Uint32Array(curA),
+      anchorB: new Uint32Array(curB),
+      anchorT: new Float32Array(curT)
+    });
+  }
+  return out;
 }
-function runCommand(upper, relative, a, st, b) {
-  const rx = relative ? st.x : 0;
-  const ry = relative ? st.y : 0;
-  switch (upper) {
-    case "M": {
-      const x = a[0] + rx;
-      const y = a[1] + ry;
-      b.moveTo(x, y);
-      st.x = x;
-      st.y = y;
-      st.startX = x;
-      st.startY = y;
-      st.lastCubicCtrl = null;
-      st.lastQuadCtrl = null;
-      return;
-    }
-    case "L": {
-      const x = a[0] + rx;
-      const y = a[1] + ry;
-      b.lineTo(x, y);
-      st.x = x;
-      st.y = y;
-      st.lastCubicCtrl = null;
-      st.lastQuadCtrl = null;
-      return;
-    }
-    case "H": {
-      const x = a[0] + (relative ? st.x : 0);
-      b.lineTo(x, st.y);
-      st.x = x;
-      st.lastCubicCtrl = null;
-      st.lastQuadCtrl = null;
-      return;
-    }
-    case "V": {
-      const y = a[0] + (relative ? st.y : 0);
-      b.lineTo(st.x, y);
-      st.y = y;
-      st.lastCubicCtrl = null;
-      st.lastQuadCtrl = null;
-      return;
-    }
-    case "C": {
-      const x1 = a[0] + rx, y1 = a[1] + ry;
-      const x2 = a[2] + rx, y2 = a[3] + ry;
-      const x = a[4] + rx, y = a[5] + ry;
-      b.curveTo(x1, y1, x2, y2, x, y);
-      st.x = x;
-      st.y = y;
-      st.lastCubicCtrl = { x: x2, y: y2 };
-      st.lastQuadCtrl = null;
-      return;
-    }
-    case "S": {
-      const ref = st.lastCubicCtrl ?? { x: st.x, y: st.y };
-      const x1 = 2 * st.x - ref.x;
-      const y1 = 2 * st.y - ref.y;
-      const x2 = a[0] + rx, y2 = a[1] + ry;
-      const x = a[2] + rx, y = a[3] + ry;
-      b.curveTo(x1, y1, x2, y2, x, y);
-      st.x = x;
-      st.y = y;
-      st.lastCubicCtrl = { x: x2, y: y2 };
-      st.lastQuadCtrl = null;
-      return;
-    }
-    case "Q": {
-      const x1 = a[0] + rx, y1 = a[1] + ry;
-      const x = a[2] + rx, y = a[3] + ry;
-      b.quadTo(x1, y1, x, y);
-      st.x = x;
-      st.y = y;
-      st.lastQuadCtrl = { x: x1, y: y1 };
-      st.lastCubicCtrl = null;
-      return;
-    }
-    case "T": {
-      const ref = st.lastQuadCtrl ?? { x: st.x, y: st.y };
-      const x1 = 2 * st.x - ref.x;
-      const y1 = 2 * st.y - ref.y;
-      const x = a[0] + rx, y = a[1] + ry;
-      b.quadTo(x1, y1, x, y);
-      st.x = x;
-      st.y = y;
-      st.lastQuadCtrl = { x: x1, y: y1 };
-      st.lastCubicCtrl = null;
+function makeSeg(ax, ay, bx, by, halfA, halfB) {
+  const dx = bx - ax, dy = by - ay;
+  const len = Math.hypot(dx, dy);
+  if (len === 0) return null;
+  return {
+    ax,
+    ay,
+    bx,
+    by,
+    nxUnit: -dy / len,
+    nyUnit: dx / len,
+    halfA,
+    halfB,
+    len
+  };
+}
+var DEFAULT_MITER_LIMIT = 10;
+var DEFAULT_VARYING_WIDTH_JOIN_THRESHOLD = 1.5;
+function emitJoin(segs, segBaseIdx, j, join, miterLimit, varyingThreshold, verts, idx, anchorA, anchorB, anchorT, segSrcIdx, plA, plB, plT) {
+  const a = segs[j];
+  const b = segs[(j + 1) % segs.length];
+  const aBase = segBaseIdx[j];
+  const bBase = segBaseIdx[(j + 1) % segs.length];
+  const adx = a.bx - a.ax, ady = a.by - a.ay;
+  const bdx = b.bx - b.ax, bdy = b.by - b.ay;
+  const cross = adx * bdy - ady * bdx;
+  if (cross === 0) return;
+  const onPositive = cross > 0;
+  const aOuterEnd = onPositive ? aBase + 3 : aBase + 2;
+  const bOuterStart = onPositive ? bBase + 1 : bBase + 0;
+  const nextSeg = (j + 1) % segs.length;
+  const cornerSrc = segSrcIdx[nextSeg];
+  const cornerA = plA[cornerSrc];
+  const cornerB = plB[cornerSrc];
+  const cornerT = plT[cornerSrc];
+  const halfAtCorner = a.halfB;
+  const taperA = Math.max(a.halfA, a.halfB) / Math.max(1e-9, Math.min(a.halfA, a.halfB));
+  const taperB = Math.max(b.halfA, b.halfB) / Math.max(1e-9, Math.min(b.halfA, b.halfB));
+  const forceBevelForVarying = taperA > varyingThreshold || taperB > varyingThreshold;
+  if (join === "bevel" || forceBevelForVarying) {
+    emitBevel(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);
+    return;
+  }
+  if (join === "miter") {
+    const aOX = verts[aOuterEnd * 2], aOY = verts[aOuterEnd * 2 + 1];
+    const bOX = verts[bOuterStart * 2], bOY = verts[bOuterStart * 2 + 1];
+    const apex = lineLineIntersect(aOX, aOY, adx, ady, bOX, bOY, -bdx, -bdy);
+    if (!apex) {
+      emitBevel(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);
       return;
     }
-    case "A": {
-      const rxA = Math.abs(a[0]);
-      const ryA = Math.abs(a[1]);
-      const xRot = a[2];
-      const largeArc = a[3] !== 0;
-      const sweep = a[4] !== 0;
-      const ex = a[5] + rx;
-      const ey = a[6] + ry;
-      arcToCubics(st.x, st.y, ex, ey, rxA, ryA, xRot, largeArc, sweep, b);
-      st.x = ex;
-      st.y = ey;
-      st.lastCubicCtrl = null;
-      st.lastQuadCtrl = null;
+    const miterLen = Math.hypot(apex[0] - a.bx, apex[1] - a.by);
+    if (miterLen > miterLimit * halfAtCorner) {
+      emitBevel(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);
       return;
     }
-    default:
-      return;
-  }
-}
-function arcToCubics(x1, y1, x2, y2, rx, ry, xAxisRotationDeg, largeArc, sweep, b) {
-  if (x1 === x2 && y1 === y2) return;
-  if (rx === 0 || ry === 0) {
-    b.lineTo(x2, y2);
-    return;
-  }
-  const phi = xAxisRotationDeg * Math.PI / 180;
-  const cosPhi = Math.cos(phi);
-  const sinPhi = Math.sin(phi);
-  const dx = (x1 - x2) / 2;
-  const dy = (y1 - y2) / 2;
-  const x1p = cosPhi * dx + sinPhi * dy;
-  const y1p = -sinPhi * dx + cosPhi * dy;
-  let rxs = rx * rx;
-  let rys = ry * ry;
-  const x1ps = x1p * x1p;
-  const y1ps = y1p * y1p;
-  const lambda = x1ps / rxs + y1ps / rys;
-  let rxFixed = rx;
-  let ryFixed = ry;
-  if (lambda > 1) {
-    const sqrtLambda = Math.sqrt(lambda);
-    rxFixed = sqrtLambda * rx;
-    ryFixed = sqrtLambda * ry;
-    rxs = rxFixed * rxFixed;
-    rys = ryFixed * ryFixed;
-  }
-  const sign2 = largeArc === sweep ? -1 : 1;
-  const num = rxs * rys - rxs * y1ps - rys * x1ps;
-  const den = rxs * y1ps + rys * x1ps;
-  const factor = sign2 * Math.sqrt(Math.max(0, num / den));
-  const cxp = factor * (rxFixed * y1p) / ryFixed;
-  const cyp = factor * -(ryFixed * x1p) / rxFixed;
-  const cx = cosPhi * cxp - sinPhi * cyp + (x1 + x2) / 2;
-  const cy = sinPhi * cxp + cosPhi * cyp + (y1 + y2) / 2;
-  const angle = (ux, uy, vx, vy) => {
-    const dot = ux * vx + uy * vy;
-    const len = Math.sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy));
-    let a = Math.acos(Math.max(-1, Math.min(1, dot / len)));
-    if (ux * vy - uy * vx < 0) a = -a;
-    return a;
-  };
-  const theta1 = angle(1, 0, (x1p - cxp) / rxFixed, (y1p - cyp) / ryFixed);
-  let dTheta = angle(
-    (x1p - cxp) / rxFixed,
-    (y1p - cyp) / ryFixed,
-    (-x1p - cxp) / rxFixed,
-    (-y1p - cyp) / ryFixed
-  );
-  if (!sweep && dTheta > 0) dTheta -= 2 * Math.PI;
-  else if (sweep && dTheta < 0) dTheta += 2 * Math.PI;
-  const segCount = Math.max(1, Math.ceil(Math.abs(dTheta) / (Math.PI / 2)));
-  const segAngle = dTheta / segCount;
-  const t = 4 / 3 * Math.tan(segAngle / 4);
-  let prevX = x1;
-  let prevY = y1;
-  let prevDx = -Math.sin(theta1) * rxFixed;
-  let prevDy = Math.cos(theta1) * ryFixed;
-  for (let i = 1; i <= segCount; i++) {
-    const theta = theta1 + i * segAngle;
-    const cosT = Math.cos(theta);
-    const sinT = Math.sin(theta);
-    const px = cosPhi * (cosT * rxFixed) - sinPhi * (sinT * ryFixed) + cx;
-    const py = sinPhi * (cosT * rxFixed) + cosPhi * (sinT * ryFixed) + cy;
-    const dxNew = -sinT * rxFixed;
-    const dyNew = cosT * ryFixed;
-    const c1x = prevX + cosPhi * (t * prevDx) - sinPhi * (t * prevDy);
-    const c1y = prevY + sinPhi * (t * prevDx) + cosPhi * (t * prevDy);
-    const c2x = px - cosPhi * (t * dxNew) + sinPhi * (t * dyNew);
-    const c2y = py - sinPhi * (t * dxNew) - cosPhi * (t * dyNew);
-    b.curveTo(c1x, c1y, c2x, c2y, px, py);
-    prevX = px;
-    prevY = py;
-    prevDx = dxNew;
-    prevDy = dyNew;
+    const apexIdx = verts.length / 2;
+    verts.push(apex[0], apex[1]);
+    anchorA.push(cornerA);
+    anchorB.push(cornerB);
+    anchorT.push(cornerT);
+    const jIdx = verts.length / 2;
+    verts.push(a.bx, a.by);
+    anchorA.push(cornerA);
+    anchorB.push(cornerB);
+    anchorT.push(cornerT);
+    if (onPositive) {
+      idx.push(aOuterEnd, apexIdx, bOuterStart);
+      idx.push(aOuterEnd, bOuterStart, jIdx);
+    } else {
+      idx.push(aOuterEnd, bOuterStart, apexIdx);
+      idx.push(aOuterEnd, jIdx, bOuterStart);
+    }
+    return;
+  }
+  if (join === "round") {
+    emitRoundJoin(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);
+    return;
   }
 }
-var OUTLINE_FLATTEN_TOLERANCE = 1 / 4096;
-var OUTLINE_MESH_CACHE_LIMIT = 2048;
-var cache3 = /* @__PURE__ */ new Map();
-function outlineMesh(key, d) {
-  const cached2 = cache3.get(key);
-  if (cached2 !== void 0) return cached2;
-  if (cache3.size >= OUTLINE_MESH_CACHE_LIMIT) cache3 = /* @__PURE__ */ new Map();
-  const mesh = tessellate(pathFromD(d), { flattenTolerance: OUTLINE_FLATTEN_TOLERANCE });
-  cache3.set(key, mesh);
-  return mesh;
+var ROUND_STEP_RAD = 10 * Math.PI / 180;
+function emitRoundJoin(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT) {
+  const cx = a.bx, cy = a.by;
+  const pivotIdx = verts.length / 2;
+  verts.push(cx, cy);
+  anchorA.push(cornerA);
+  anchorB.push(cornerB);
+  anchorT.push(cornerT);
+  const startX = verts[aOuterEnd * 2] - cx;
+  const startY = verts[aOuterEnd * 2 + 1] - cy;
+  const endX = verts[bOuterStart * 2] - cx;
+  const endY = verts[bOuterStart * 2 + 1] - cy;
+  const r = Math.hypot(startX, startY);
+  const startAngle = Math.atan2(startY, startX);
+  const endAngle = Math.atan2(endY, endX);
+  let sweep = endAngle - startAngle;
+  if (onPositive && sweep < 0) sweep += 2 * Math.PI;
+  else if (!onPositive && sweep > 0) sweep -= 2 * Math.PI;
+  const steps = Math.max(1, Math.ceil(Math.abs(sweep) / ROUND_STEP_RAD));
+  const stepAngle = sweep / steps;
+  let prevIdx = aOuterEnd;
+  for (let i = 1; i < steps; i++) {
+    const ang = startAngle + i * stepAngle;
+    const fx = cx + Math.cos(ang) * r;
+    const fy = cy + Math.sin(ang) * r;
+    const newIdx = verts.length / 2;
+    verts.push(fx, fy);
+    anchorA.push(cornerA);
+    anchorB.push(cornerB);
+    anchorT.push(cornerT);
+    if (onPositive) idx.push(prevIdx, pivotIdx, newIdx);
+    else idx.push(prevIdx, newIdx, pivotIdx);
+    prevIdx = newIdx;
+  }
+  if (onPositive) idx.push(prevIdx, pivotIdx, bOuterStart);
+  else idx.push(prevIdx, bOuterStart, pivotIdx);
+}
+function emitBevel(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT) {
+  const jIdx = verts.length / 2;
+  verts.push(a.bx, a.by);
+  anchorA.push(cornerA);
+  anchorB.push(cornerB);
+  anchorT.push(cornerT);
+  if (onPositive) idx.push(aOuterEnd, jIdx, bOuterStart);
+  else idx.push(aOuterEnd, bOuterStart, jIdx);
+}
+function lineLineIntersect(apx, apy, adx, ady, bpx, bpy, bdx, bdy) {
+  const denom = adx * bdy - ady * bdx;
+  if (Math.abs(denom) < 1e-9) return null;
+  const t = ((bpx - apx) * bdy - (bpy - apy) * bdx) / denom;
+  return [apx + t * adx, apy + t * ady];
 }
 var OUTLINE_STROKE_MESH_CACHE_LIMIT = 2048;
 var WIDTH_QUANTUM = 1 / 1024;
@@ -6162,6 +5833,36 @@ function outlineStrokeMesh(glyphKey, d, emWidth, stroke) {
   cache4.set(key, mesh);
   return mesh.indices.length === 0 ? null : mesh;
 }
+var STROKE_CONFIGS_PER_PATH = 8;
+var cache5 = /* @__PURE__ */ new WeakMap();
+function configKey(stroke, flattenTolerance) {
+  return [
+    stroke.width ?? 1,
+    stroke.cap ?? "butt",
+    stroke.join ?? "miter",
+    stroke.miterLimit ?? "",
+    stroke.align ?? "center",
+    (stroke.dash ?? []).join(","),
+    stroke.varyingWidthJoinThreshold ?? "",
+    flattenTolerance ?? ""
+  ].join("|");
+}
+function strokeMesh(path, stroke, flattenTolerance) {
+  let byConfig = cache5.get(path);
+  if (byConfig === void 0) {
+    byConfig = /* @__PURE__ */ new Map();
+    cache5.set(path, byConfig);
+  }
+  const key = configKey(stroke, flattenTolerance);
+  const entry = byConfig.get(key);
+  if (entry !== void 0 && entry.vertexWidths === stroke.vertexWidths) {
+    return entry.mesh;
+  }
+  const mesh = tessellateStroke(path, stroke, { flattenTolerance });
+  if (entry === void 0 && byConfig.size >= STROKE_CONFIGS_PER_PATH) byConfig.clear();
+  byConfig.set(key, { mesh, vertexWidths: stroke.vertexWidths });
+  return mesh;
+}
 var MAX_VERTICES_PER_BATCH = 32768;
 var FLOATS_PER_VERTEX = 6;
 var INITIAL_VERTICES = 256;
@@ -6563,44 +6264,40 @@ function drawGroup(ctx, cmd) {
         "weasel: clip nesting depth exceeded (max 7). You can't nest more than 7 levels of clipped containers in a single draw tree. Flatten the hierarchy or compose poses outside the scene graph."
       );
     }
-    flushSolids(ctx);
     pushClip(ctx, cmd.clip, newDepth);
     ctx.clipDepth = newDepth;
   }
   for (const child of cmd.children) dispatch(ctx, child);
   if (cmd.clip) {
-    flushSolids(ctx);
     popClip(ctx, cmd.clip, ctx.clipDepth - 1);
     ctx.clipDepth -= 1;
   }
   ctx.state.pop();
 }
 function drawPath(ctx, cmd) {
-  if (!cmd.fill && !cmd.stroke) return;
-  if (cmd.fill) {
-    const batchablePaint = (cmd.fill.fill === void 0 || cmd.fill.fill === "solid") && (!cmd.vertexColors || cmd.vertexColors.length === 0);
-    const solid = cmd.fill;
-    if (batchablePaint && cmd.path.kind === "rect") {
-      pushRect(ctx, cmd.path, solid);
-    } else {
-      const mesh = fillMesh(ctx, cmd.path);
-      if (batchablePaint && canBatchMesh(mesh)) {
-        pushMesh(ctx, mesh, solid);
-      } else {
-        flushSolids(ctx);
-        const handle = meshHandle(ctx, mesh);
-        if (cmd.vertexColors && cmd.vertexColors.length > 0 && (cmd.fill.fill === void 0 || cmd.fill.fill === "solid")) {
-          drawPathFillVColor(ctx, cmd, solid, handle);
-        } else if (handle.requiresStencil) {
-          drawPathFillStencil(ctx, cmd.fill, handle);
-        } else {
-          drawPathFillByKind(ctx, cmd.fill, handle);
-        }
-      }
-    }
-  }
+  if (cmd.fill) drawPathFill(ctx, cmd);
   if (cmd.stroke) drawPathStroke(ctx, cmd);
 }
+function drawPathFill(ctx, cmd) {
+  const fill = cmd.fill;
+  const isSolid = fill.fill === void 0 || fill.fill === "solid";
+  const hasVColors = !!(cmd.vertexColors && cmd.vertexColors.length > 0);
+  const solid = fill;
+  if (isSolid && !hasVColors && cmd.path.kind === "rect") {
+    pushRect(ctx, cmd.path, solid);
+    return;
+  }
+  const mesh = fillMesh(ctx, cmd.path);
+  if (tryStageSolid(ctx, mesh, isSolid && !hasVColors ? solid : void 0)) return;
+  const handle = meshHandle(ctx, mesh);
+  if (isSolid && hasVColors) {
+    drawPathFillVColor(ctx, cmd, solid, handle);
+  } else if (handle.requiresStencil) {
+    drawPathFillStencil(ctx, fill, handle);
+  } else {
+    drawPathFillByKind(ctx, fill, handle);
+  }
+}
 function isIdentityColorMatrix(cm) {
   return cm === IDENTITY_COLOR_MATRIX || sameValues(IDENTITY_COLOR_MATRIX, cm);
 }
@@ -6653,6 +6350,14 @@ function pushMesh(ctx, mesh, paint) {
   const [r, g, b, a] = stagedColor(ctx, staged, paint);
   ctx.solidBatch.pushMesh(mesh, ctx.state.transform, r, g, b, a);
 }
+function tryStageSolid(ctx, mesh, paint) {
+  if (paint !== void 0 && canBatchMesh(mesh)) {
+    pushMesh(ctx, mesh, paint);
+    return true;
+  }
+  flushSolids(ctx);
+  return false;
+}
 function flushSolids(ctx) {
   const batch = ctx.solidBatch;
   const staged = ctx.solidState;
@@ -6856,6 +6561,7 @@ function rasterizePathToStencil(ctx, path) {
   gl.bindVertexArray(null);
 }
 function pushClip(ctx, path, newDepth) {
+  flushSolids(ctx);
   const gl = ctx.gl;
   const ancestors = ancestorMask(newDepth - 1);
   const newBit = 1 << newDepth;
@@ -6870,6 +6576,7 @@ function pushClip(ctx, path, newDepth) {
   gl.stencilMask(255);
 }
 function popClip(ctx, path, oldDepth) {
+  flushSolids(ctx);
   const gl = ctx.gl;
   gl.enable(gl.STENCIL_TEST);
   const oldBit = 1 << oldDepth + 1;
@@ -6926,17 +6633,13 @@ function drawPathStroke(ctx, cmd) {
 function drawPathStrokeUnclipped(ctx, cmd) {
   const stroke = cmd.stroke;
   const solid = stroke.paint;
-  const mesh = tessellateStroke(cmd.path, stroke, { flattenTolerance: ctx.flattenTolerance });
+  const mesh = strokeMesh(cmd.path, stroke, ctx.flattenTolerance);
   if (mesh.indices.length === 0) return;
   const hasVColors = !!(stroke.vertexColors && stroke.vertexColors.length > 0);
-  if (!hasVColors && canBatchMesh(mesh)) {
-    pushMesh(ctx, mesh, solid);
-    return;
-  }
-  flushSolids(ctx);
-  const handle = ctx.meshCache.uploadTransient(mesh);
+  if (tryStageSolid(ctx, mesh, hasVColors ? void 0 : solid)) return;
+  const handle = hasVColors ? ctx.meshCache.uploadTransient(mesh) : ctx.meshCache.uploadRecurring(mesh);
   const gl = ctx.gl;
-  if (stroke.vertexColors && stroke.vertexColors.length > 0) {
+  if (hasVColors) {
     const prog = ctx.pathFillVColor;
     gl.useProgram(prog.handle);
     gl.bindVertexArray(handle.vao);
@@ -6967,16 +6670,30 @@ function drawPathStrokeUnclipped(ctx, cmd) {
   gl.drawElements(gl.TRIANGLES, handle.indexCount, gl.UNSIGNED_INT, 0);
   gl.bindVertexArray(null);
 }
+var DOUBLED_VERTEX_WIDTHS = /* @__PURE__ */ new WeakMap();
+function doubledVertexWidths(widths) {
+  let doubled = DOUBLED_VERTEX_WIDTHS.get(widths);
+  if (doubled === void 0) {
+    doubled = widths.map((w) => w * 2);
+    DOUBLED_VERTEX_WIDTHS.set(widths, doubled);
+  }
+  return doubled;
+}
 function drawPathStrokeStenciled(ctx, cmd, align) {
   const stroke = cmd.stroke;
   const solid = stroke.paint;
-  const widerStroke = { ...stroke, width: (stroke.width ?? 1) * 2, align: "center" };
+  const widerStroke = {
+    ...stroke,
+    width: (stroke.width ?? 1) * 2,
+    ...stroke.vertexWidths ? { vertexWidths: doubledVertexWidths(stroke.vertexWidths) } : {},
+    align: "center"
+  };
+  const useVColor = !!(stroke.vertexColors && stroke.vertexColors.length > 0);
   const fillHandle = fillMeshHandle(ctx, cmd.path);
-  const ribbonMesh = tessellateStroke(cmd.path, widerStroke, { flattenTolerance: ctx.flattenTolerance });
+  const ribbonMesh = strokeMesh(cmd.path, widerStroke, ctx.flattenTolerance);
   if (ribbonMesh.indices.length === 0) return;
-  const ribbonHandle = ctx.meshCache.uploadTransient(ribbonMesh);
+  const ribbonHandle = useVColor ? ctx.meshCache.uploadTransient(ribbonMesh) : ctx.meshCache.uploadRecurring(ribbonMesh);
   const gl = ctx.gl;
-  const useVColor = !!(stroke.vertexColors && stroke.vertexColors.length > 0);
   const prog = useVColor ? ctx.pathFillVColor : ctx.pathFill;
   gl.useProgram(prog.handle);
   setProjAndModel(ctx, prog);
@@ -7012,11 +6729,11 @@ function drawPathStrokeStenciled(ctx, cmd, align) {
     }
   }
   gl.drawElements(gl.TRIANGLES, ribbonHandle.indexCount, gl.UNSIGNED_INT, 0);
-  if (colorVbo) gl.deleteBuffer(colorVbo);
   gl.stencilMask(1);
   gl.clear(gl.STENCIL_BUFFER_BIT);
   gl.disable(gl.STENCIL_TEST);
   gl.bindVertexArray(null);
+  if (colorVbo) gl.deleteBuffer(colorVbo);
 }
 var OUTLINE_MIN_SCREEN_PX = 48;
 function modelScale(m) {
@@ -7065,9 +6782,9 @@ function drawTextOutlineGroup(ctx, group, dx, dy) {
   const mesh = outlineGroupMesh(group, dx, dy);
   if (mesh) drawPathFillByKind(ctx, group.fill, ctx.meshCache.uploadTransient(mesh));
   if (!group.stroke) return;
-  const strokeMesh = outlineGroupStrokeMesh(group, dx, dy);
-  if (strokeMesh) {
-    drawPathFillByKind(ctx, group.stroke.paint, ctx.meshCache.uploadTransient(strokeMesh));
+  const ribbon = outlineGroupStrokeMesh(group, dx, dy);
+  if (ribbon) {
+    drawPathFillByKind(ctx, group.stroke.paint, ctx.meshCache.uploadTransient(ribbon));
   }
 }
 function outlineGroupMesh(group, dx, dy) {
@@ -7273,70 +6990,98 @@ function drawTextGroup(ctx, group, prog, dx, dy) {
   gl.deleteBuffer(vbo);
   gl.deleteBuffer(ibo);
 }
+var IMAGE_QUAD_RING_SIZE = 64;
+var IMAGE_QUAD_RINGS = /* @__PURE__ */ new WeakMap();
+var IMAGE_QUAD_INDICES = new Uint32Array([0, 1, 2, 1, 3, 2]);
+var IMAGE_QUAD_STRIDE = 16;
+function imageQuadRing(gl, prog) {
+  const existing = IMAGE_QUAD_RINGS.get(prog);
+  if (existing) return existing;
+  const aPosLoc = prog.attribute("a_position");
+  const aUvLoc = prog.attribute("a_uv");
+  const ibo = gl.createBuffer();
+  if (!ibo) throw new Error("drawImage: createBuffer (IBO) returned null");
+  const vaos = [];
+  const vbos = [];
+  for (let slot = 0; slot < IMAGE_QUAD_RING_SIZE; slot++) {
+    const vao = gl.createVertexArray();
+    const vbo = gl.createBuffer();
+    if (!vao) throw new Error("drawImage: createVertexArray returned null");
+    if (!vbo) throw new Error("drawImage: createBuffer returned null");
+    gl.bindVertexArray(vao);
+    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
+    gl.bufferData(gl.ARRAY_BUFFER, 4 * IMAGE_QUAD_STRIDE, gl.DYNAMIC_DRAW);
+    if (aPosLoc !== void 0) {
+      gl.enableVertexAttribArray(aPosLoc);
+      gl.vertexAttribPointer(aPosLoc, 2, gl.FLOAT, false, IMAGE_QUAD_STRIDE, 0);
+    }
+    if (aUvLoc !== void 0) {
+      gl.enableVertexAttribArray(aUvLoc);
+      gl.vertexAttribPointer(aUvLoc, 2, gl.FLOAT, false, IMAGE_QUAD_STRIDE, 8);
+    }
+    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);
+    if (slot === 0) gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, IMAGE_QUAD_INDICES, gl.STATIC_DRAW);
+    gl.bindVertexArray(null);
+    vaos.push(vao);
+    vbos.push(vbo);
+  }
+  const ring = { vaos, vbos, ibo, next: 0 };
+  IMAGE_QUAD_RINGS.set(prog, ring);
+  return ring;
+}
+function disposeImageQuads(gl, prog) {
+  const ring = IMAGE_QUAD_RINGS.get(prog);
+  if (!ring) return;
+  for (const vao of ring.vaos) gl.deleteVertexArray(vao);
+  for (const vbo of ring.vbos) gl.deleteBuffer(vbo);
+  gl.deleteBuffer(ring.ibo);
+  IMAGE_QUAD_RINGS.delete(prog);
+}
+var IMAGE_QUAD_VERTICES = new Float32Array(16);
 function drawImage(ctx, cmd) {
   ctx.imageCache.upload(cmd.image, cmd.image);
   const gl = ctx.gl;
-  gl.useProgram(ctx.imageFill.handle);
+  const prog = ctx.imageFill;
+  gl.useProgram(prog.handle);
   const x0 = cmd.x, y0 = cmd.y;
   const x1 = cmd.x + cmd.w, y1 = cmd.y + cmd.h;
-  const vertices = new Float32Array([
-    x0,
-    y0,
-    0,
-    0,
-    x1,
-    y0,
-    1,
-    0,
-    x0,
-    y1,
-    0,
-    1,
-    x1,
-    y1,
-    1,
-    1
-  ]);
-  const indices = new Uint32Array([0, 1, 2, 1, 3, 2]);
-  const vao = gl.createVertexArray();
-  if (!vao) throw new Error("drawImage: createVertexArray returned null");
-  gl.bindVertexArray(vao);
-  const vbo = gl.createBuffer();
-  if (!vbo) throw new Error("drawImage: createBuffer returned null");
-  gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
-  gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.DYNAMIC_DRAW);
-  const stride = 16;
-  const aPosLoc = ctx.imageFill.attribute("a_position");
-  const aUvLoc = ctx.imageFill.attribute("a_uv");
-  if (aPosLoc !== void 0) {
-    gl.enableVertexAttribArray(aPosLoc);
-    gl.vertexAttribPointer(aPosLoc, 2, gl.FLOAT, false, stride, 0);
-  }
-  if (aUvLoc !== void 0) {
-    gl.enableVertexAttribArray(aUvLoc);
-    gl.vertexAttribPointer(aUvLoc, 2, gl.FLOAT, false, stride, 8);
-  }
-  const ibo = gl.createBuffer();
-  if (!ibo) throw new Error("drawImage: createBuffer (IBO) returned null");
-  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);
-  gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices, gl.DYNAMIC_DRAW);
-  setProjAndModel(ctx, ctx.imageFill);
-  setColorMatrixUniforms(ctx, ctx.imageFill);
+  const v = IMAGE_QUAD_VERTICES;
+  v[0] = x0;
+  v[1] = y0;
+  v[2] = 0;
+  v[3] = 0;
+  v[4] = x1;
+  v[5] = y0;
+  v[6] = 1;
+  v[7] = 0;
+  v[8] = x0;
+  v[9] = y1;
+  v[10] = 0;
+  v[11] = 1;
+  v[12] = x1;
+  v[13] = y1;
+  v[14] = 1;
+  v[15] = 1;
+  const ring = imageQuadRing(gl, prog);
+  const slot = ring.next;
+  ring.next = (slot + 1) % IMAGE_QUAD_RING_SIZE;
+  gl.bindVertexArray(ring.vaos[slot]);
+  gl.bindBuffer(gl.ARRAY_BUFFER, ring.vbos[slot]);
+  gl.bufferSubData(gl.ARRAY_BUFFER, 0, v);
+  setProjAndModel(ctx, prog);
+  setColorMatrixUniforms(ctx, prog);
   ctx.imageCache.bind(cmd.image, 0);
   gl.texParameteri(
     gl.TEXTURE_2D,
     gl.TEXTURE_MAG_FILTER,
     cmd.sampling === "nearest" ? gl.NEAREST : gl.LINEAR
   );
-  gl.uniform1i(ctx.imageFill.uniform("u_sampler"), 0);
-  gl.uniform1f(ctx.imageFill.uniform("u_opacity"), cmd.opacity ?? 1);
-  gl.uniform1f(ctx.imageFill.uniform("u_alpha"), ctx.state.alpha);
+  gl.uniform1i(prog.uniform("u_sampler"), 0);
+  gl.uniform1f(prog.uniform("u_opacity"), cmd.opacity ?? 1);
+  gl.uniform1f(prog.uniform("u_alpha"), ctx.state.alpha);
   applyClipTest(ctx);
   gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, 0);
   gl.bindVertexArray(null);
-  gl.deleteVertexArray(vao);
-  gl.deleteBuffer(vbo);
-  gl.deleteBuffer(ibo);
 }
 var CUSTOM_VERT_SRC = (
   /* glsl */
@@ -7393,16 +7138,28 @@ var registry3 = /* @__PURE__ */ new Map();
 function getProgramSource(id) {
   return registry3.get(id) ?? null;
 }
+var UNIFORM_QUALIFIER = /^(?:lowp|mediump|highp|precise|invariant|centroid|flat|smooth|noperspective)$/;
 function extractUniformNames(glsl) {
-  const reScalar = /\buniform\s+\S+\s+(\w+)\s*;/g;
-  const reArray = /\buniform\s+\S+\s+(\w+)\s*\[\s*(\d+)\s*\]\s*;/g;
+  const re = /\buniform\s+([^;{]+);/g;
   const names = [];
   let m;
-  while ((m = reScalar.exec(glsl)) !== null) names.push(m[1]);
-  while ((m = reArray.exec(glsl)) !== null) {
-    const name = m[1];
-    const size = parseInt(m[2], 10);
-    for (let i = 0; i < size; i++) names.push(`${name}[${i}]`);
+  while ((m = re.exec(glsl)) !== null) {
+    const words = m[1].trim().split(/\s+/);
+    let i = 0;
+    while (i < words.length && UNIFORM_QUALIFIER.test(words[i])) i++;
+    i++;
+    const declarators = words.slice(i).join(" ");
+    if (!declarators) continue;
+    for (const raw of declarators.split(",")) {
+      const d = raw.trim();
+      const arr = /^(\w+)\s*\[\s*(\d+)\s*\]$/.exec(d);
+      if (arr) {
+        const size = parseInt(arr[2], 10);
+        for (let k = 0; k < size; k++) names.push(`${arr[1]}[${k}]`);
+      } else if (/^\w+$/.test(d)) {
+        names.push(d);
+      }
+    }
   }
   return names;
 }
@@ -7644,6 +7401,7 @@ var WeaselRenderer = class {
     this.gradRampCache.free();
     if (this.quadVbo) gl.deleteBuffer(this.quadVbo);
     if (this.quadIbo) gl.deleteBuffer(this.quadIbo);
+    disposeImageQuads(gl, this.imageFill);
     this.solidBatch.dispose();
   }
   /**
@@ -8178,6 +7936,12 @@ function runLayoutPass(scratch, moveCtx) {
     if (layout2.contains) return layout2.contains(cPose, draggedCenter);
     return draggedCenter.x >= aabb.x && draggedCenter.x < aabb.x + aabb.width && draggedCenter.y >= aabb.y && draggedCenter.y < aabb.y + aabb.height;
   };
+  const draggedArg = {
+    id: draggedId,
+    originPose: startWorld,
+    pose: draggedWorld,
+    sourceContainerId
+  };
   const consider = (id, zPath) => {
     if (id === draggedId) return;
     const layout2 = layoutDep.getLayout(id);
@@ -8187,6 +7951,7 @@ function runLayoutPass(scratch, moveCtx) {
     const worldPose = composeWorldPose(poseAdapter, id, pc.compose);
     const worldAABB = boundsOf2(worldPose);
     if (!testInside(worldPose, worldAABB, layout2)) return;
+    if (layout2.acceptsDrop && !layout2.acceptsDrop({ id, bounds: worldAABB }, draggedArg)) return;
     candidates.push({
       id,
       bounds: worldAABB,
@@ -8235,20 +8000,16 @@ function runLayoutPass(scratch, moveCtx) {
     id: cid,
     pose: composeWorldPose(poseAdapter, cid, pc.compose)
   }));
-  const draggedArg = {
-    id: draggedId,
-    originPose: startWorld,
-    pose: draggedWorld,
-    sourceContainerId
-  };
   const targets = layout.getDropTargets(container, children, draggedArg);
   const target = layout.snap.pickTarget(targets, { x: moveCtx.drag.current.x, y: moveCtx.drag.current.y });
   if (!target) return;
+  const reflowIds = /* @__PURE__ */ new Set();
   for (const [cid, pose] of layout.reflowPoses(container, children, draggedArg, target)) {
     if (asNodeId(cid) === draggedId) continue;
     const parent = scene.get(asNodeId(cid))?.parent ?? null;
     const local = rebaseLocalPose(poseAdapter, pose, parent, pc.compose, pc.decompose);
     scratch.previews.set(asNodeId(cid), local);
+    reflowIds.add(asNodeId(cid));
   }
   const sourceReflow = /* @__PURE__ */ new Map();
   if (sourceContainerId && sourceContainerId !== dest.id) {
@@ -8271,10 +8032,11 @@ function runLayoutPass(scratch, moveCtx) {
         sourceReflow.set(cid, pose);
         const parent = scene.get(asNodeId(cid))?.parent ?? null;
         scratch.previews.set(asNodeId(cid), rebaseLocalPose(poseAdapter, pose, parent, pc.compose, pc.decompose));
+        reflowIds.add(asNodeId(cid));
       }
     }
   }
-  scratch.layoutPass = { layout, container, children, target, sourceReflow };
+  scratch.layoutPass = { layout, container, children, target, sourceReflow, reflowIds };
 }
 function scenePoseAdapter(scene) {
   return {
@@ -8582,7 +8344,8 @@ var moveAction = {
           scratch.previews.clear();
         },
         previewIds: () => scratch.previews.keys(),
-        previewPose: (id) => scratch.previews.get(id) ?? null
+        previewPose: (id) => scratch.previews.get(id) ?? null,
+        previewOpaqueIds: () => scratch.layoutPass?.reflowIds ?? null
       };
     }
   },
@@ -9318,7 +9081,8 @@ var KIT_INSERT_KINDS = /* @__PURE__ */ new Set([
   "line",
   "polygon",
   "star",
-  "pencil"
+  "pencil",
+  "image"
 ]);
 var liveInsertScratch = null;
 function effectiveOriginMode(paramsOrigin, altHeld) {
@@ -10366,7 +10130,7 @@ var pinchZoomAction = {
       const multiTouch = ctx.multiTouch;
       if (!multiTouch) return {};
       const startSpread = multiTouch.spread > 0 ? multiTouch.spread : 1;
-      const scratch = { view, startSpread };
+      const scratch = { view, startSpread, centroid: multiTouch.centroid };
       return {
         kind: "pinch",
         onMove(moveCtx) {
@@ -10376,8 +10140,15 @@ var pinchZoomAction = {
           if (currentSpread <= 0 || scratch.startSpread <= 0) return;
           const factor = currentSpread / scratch.startSpread;
           scratch.startSpread = currentSpread;
+          const prev = scratch.centroid;
+          scratch.centroid = centroid;
           const current = scratch.view.get();
-          scratch.view.set(zoomAt(current, centroid, factor));
+          const zoomed = zoomAt(current, prev, factor);
+          scratch.view.set({
+            scale: zoomed.scale,
+            x: zoomed.x - (centroid.x - prev.x) / zoomed.scale.x,
+            y: zoomed.y - (centroid.y - prev.y) / zoomed.scale.y
+          });
         }
         // onEnd: nothing to do — zoom was applied each frame.
       };
@@ -10837,10 +10608,12 @@ function normalizeNegativeExtent(pose) {
   if (!mutated) return pose;
   return { ...pose, x: nx, y: ny, width: nw, height: nh };
 }
-function flipSelection(selection, scene, axis, applyOps, geometryProjection) {
+function flipSelection(selection, scene, axis, pivot, applyOps, geometryProjection) {
   const ids = selection.get();
   if (ids.length === 0) return;
   const geom = AUTO_POSE_DESCRIPTOR;
+  const nodes = ids.map((id) => scene.get(id)).filter((n) => n != null);
+  const unionPivot = pivot === "union" ? unionBounds(nodes.map((n) => geom.getBounds(n.pose))) : null;
   const ops = [];
   for (const id of ids) {
     const node = scene.get(id);
@@ -10848,10 +10621,10 @@ function flipSelection(selection, scene, axis, applyOps, geometryProjection) {
     ops.push(createTransformOp({
       id,
       from: node.pose,
-      to: flipPoseViaDescriptor(node.pose, axis, geom),
+      to: unionPivot ? flipPoseAboutBounds(node.pose, axis, geom, unionPivot) : flipPoseViaDescriptor(node.pose, axis, geom),
       label: "Flip"
     }));
-    const g = geom.getBounds(node.pose);
+    const g = unionPivot ?? geom.getBounds(node.pose);
     const cx = g.x + g.width / 2;
     const cy = g.y + g.height / 2;
     const m = axis === "x" ? [-1, 0, 0, 1, 2 * cx, 0] : [1, 0, 0, -1, 0, 2 * cy];
@@ -10880,12 +10653,13 @@ var flipAction = {
     timing: "immediate",
     run: (deps, params) => {
       const axis = params?.axis ?? "x";
+      const pivot = params?.pivot ?? "each";
       const selection = deps.selection;
       const scene = deps.scene;
       const applyOps = deps.applyOps;
       const geometryProjection = deps.geometryProjection;
       if (!selection || !scene) return;
-      flipSelection(selection, scene, axis, applyOps, geometryProjection);
+      flipSelection(selection, scene, axis, pivot, applyOps, geometryProjection);
     }
   },
   enabled: requiresSelection
@@ -12743,11 +12517,18 @@ var DEFAULT_DEBUG_THEME = {
   fpsText: "#e0e0e0",
   fpsTextBg: "rgba(0, 0, 0, 0.6)"
 };
+var DEFAULT_DEBUG_STROKES = {
+  hitbox: { width: 1, dash: [2, 2] },
+  bounds: { width: 1 },
+  handle: { width: 1 },
+  snap: { width: 1 }
+};
 function createDebugOverlayLayer({
   sink,
   config
 }) {
   const theme = { ...DEFAULT_DEBUG_THEME, ...config.theme ?? {} };
+  const strokes = { ...DEFAULT_DEBUG_STROKES, ...config.strokes ?? {} };
   const fpsHistory = [];
   const FPS_WINDOW = 60;
   return {
@@ -12759,11 +12540,11 @@ function createDebugOverlayLayer({
       const s = sink.snapshot();
       const t = viewToTransform(view);
       const out = [];
-      if (config.hitboxes) emitHitboxes(out, s, view, t, theme);
-      if (config.bounds) emitBounds(out, s, view, t, theme);
-      if (config.handles) emitHandles(out, s, t, theme);
+      if (config.hitboxes) emitHitboxes(out, s, view, t, theme, strokes);
+      if (config.bounds) emitBounds(out, s, view, t, theme, strokes);
+      if (config.handles) emitHandles(out, s, t, theme, strokes);
       if (config.origins) emitOrigins(out, s, t, theme);
-      if (config.snap) emitSnap(out, s, t, theme);
+      if (config.snap) emitSnap(out, s, t, theme, strokes);
       if (config.ids) emitIds(out, s, t, theme);
       if (config.layers) emitLayersPanel(out, s, dims, theme);
       if (config.fps) {
@@ -12796,9 +12577,16 @@ function approxCircleScreen(cx, cy, r, segments = 24) {
 function rectPath2(x, y, w, h) {
   return { kind: "rect", x, y, width: w, height: h };
 }
-function emitHitboxes(out, s, view, t, theme) {
+function strokeOf(s, color) {
+  return {
+    paint: { fill: "solid", color },
+    width: s.width,
+    ...s.dash && s.dash.length > 0 ? { dash: [...s.dash] } : {}
+  };
+}
+function emitHitboxes(out, s, view, t, theme, strokes) {
   const fill = { fill: "solid", color: theme.hitboxFill };
-  const stroke = { paint: { fill: "solid", color: theme.hitboxStroke }, width: 1, dash: [2, 2] };
+  const stroke = strokeOf(strokes.hitbox, theme.hitboxStroke);
   for (const h of s.hitboxes) {
     if (h.shape.kind === "rect") {
       const [sx, sy] = worldToScreen(h.shape.x, h.shape.y, t);
@@ -12812,8 +12600,8 @@ function emitHitboxes(out, s, view, t, theme) {
     }
   }
 }
-function emitBounds(out, s, view, t, theme) {
-  const stroke = { paint: { fill: "solid", color: theme.bounds }, width: 1 };
+function emitBounds(out, s, view, t, theme, strokes) {
+  const stroke = strokeOf(strokes.bounds, theme.bounds);
   for (const b of s.bounds) {
     const [sx, sy] = worldToScreen(b.bounds.x, b.bounds.y, t);
     const sw = b.bounds.width * view.scale.x;
@@ -12821,8 +12609,8 @@ function emitBounds(out, s, view, t, theme) {
     out.push({ kind: "path", path: rectPath2(sx, sy, sw, sh), stroke });
   }
 }
-function emitHandles(out, s, t, theme) {
-  const stroke = { paint: { fill: "solid", color: theme.handle }, width: 1 };
+function emitHandles(out, s, t, theme, strokes) {
+  const stroke = strokeOf(strokes.handle, theme.handle);
   for (const h of s.handles) {
     const [cx, cy] = worldToScreen(h.position.x, h.position.y, t);
     const horiz = {
@@ -12848,14 +12636,14 @@ function emitOrigins(out, s, t, theme) {
     out.push({ kind: "path", path: approxCircleScreen(cx, cy, 3), fill });
   }
 }
-function emitSnap(out, s, t, theme) {
+function emitSnap(out, s, t, theme, strokes) {
   const color = theme.snap;
   for (const c of s.snap) {
     const [cx, cy] = worldToScreen(c.point.x, c.point.y, t);
     const cmd = {
       kind: "path",
       path: approxCircleScreen(cx, cy, 4),
-      ...c.accepted ? { fill: { fill: "solid", color } } : { stroke: { paint: { fill: "solid", color }, width: 1 } }
+      ...c.accepted ? { fill: { fill: "solid", color } } : { stroke: strokeOf(strokes.snap, color) }
     };
     out.push(cmd);
   }
@@ -13227,11 +13015,22 @@ function reportDeadClaim(owner, warn) {
     `[weasel] exclusive claim by "${key}" matched no binding: no \`affordance:\` or \`kindOf\` target resolved against it, so the press was dropped.`
   );
 }
+function phaseRank(spec) {
+  if (spec === void 0) return 0;
+  const atoms = typeof spec === "string" ? [{ channel: "&", phase: spec }] : spec;
+  if (atoms.length === 0) return 0;
+  let min = 2;
+  for (const a of atoms) {
+    const rank = (a.channel === "*" ? 0 : 1) + (a.phase === "*" ? 0 : 1);
+    if (rank < min) min = rank;
+  }
+  return min;
+}
 function specificity(spec) {
   const t = targetRank(specTargetOf(spec));
   const mods = "mods" in spec ? spec.mods : void 0;
   const m = modsCount(mods);
-  const p = "phase" in spec && spec.phase !== void 0 ? 1 : 0;
+  const p = phaseRank("phase" in spec ? spec.phase : void 0);
   const typed = (spec.kind === "drop" || spec.kind === "paste") && spec.types !== void 0 && spec.types.length > 0 ? 2 : 1;
   return [t, m, p, typed];
 }
@@ -14831,8 +14630,7 @@ function useGestureDispatcher(opts) {
       if (!cd) return;
       const items = itemsFromClipboardData(cd);
       if (items.length === 0) return;
-      e.preventDefault();
-      dispatch2({
+      const result = dispatch2({
         kind: "paste",
         items,
         // ClipboardEvent carries no modifier state.
@@ -14841,6 +14639,7 @@ function useGestureDispatcher(opts) {
         metaKey: false,
         shiftKey: false
       });
+      if (result === "handled") e.preventDefault();
     };
     if (keyboard) {
       window.addEventListener("keydown", onKeyDown);
@@ -15083,6 +14882,50 @@ function usePinchGesture(canvasRef, onPinch, enabled = true) {
     };
   }, [canvasRef, enabled]);
 }
+function validateId(id, kind) {
+  if (id.length === 0) {
+    throw new Error(`weasel: ${kind} id may not be empty`);
+  }
+  if (RESERVED_ID_PREFIXES.has(id[0])) {
+    throw new Error(
+      `weasel: ${kind} id "${id}" starts with reserved sigil "${id[0]}" (reserved set: ${[...RESERVED_ID_PREFIXES].join(" ")})`
+    );
+  }
+  if (RESERVED_ID_NAMES.has(id)) {
+    throw new Error(
+      `weasel: ${kind} id "${id}" collides with a reserved phase keyword (reserved: ${[...RESERVED_ID_NAMES].join(", ")})`
+    );
+  }
+}
+function defineTool(def) {
+  validateId(def.id, "tool");
+  const resolveCursor = (ctx) => {
+    if (def.cursor == null) return "";
+    return typeof def.cursor === "function" ? def.cursor(ctx) : def.cursor;
+  };
+  return {
+    id: def.id,
+    eligibility: {
+      focus: true,
+      capabilities: def.capabilities,
+      ...def.hotkey ? { offhand: def.hotkey } : {}
+    },
+    actions: def.actions,
+    def,
+    presentation: def.presentation,
+    keybinding: def.keybinding,
+    onActivate: def.onActivate,
+    onDeactivate: def.onDeactivate,
+    initScratch: def.initScratch ?? (() => null),
+    cursor: resolveCursor,
+    bindings: def.bindings,
+    overlay: def.overlay,
+    overlayPosition: def.overlayPosition
+  };
+}
+function defineViewportTool(def) {
+  return defineTool(def);
+}
 var TOOL_OFFHAND_ID = "tool.offhand";
 function offhandKeyFor(trigger) {
   switch (trigger) {
@@ -15173,17 +15016,19 @@ function useContributions(opts) {
     const { ordered, state } = snapshot();
     return scopeBindings(ordered, state);
   }, [snapshot]);
-  const overlays = useCallback(() => {
+  const overlays = useCallback((position = "top") => {
     const { ordered, state } = snapshot();
     const active = [];
     const hotkey = [];
     const ambient = [];
     for (const entry of ordered) {
       if (!entry.overlay) continue;
+      if ((entry.overlayPosition ?? "top") !== position) continue;
+      const layers = Array.isArray(entry.overlay) ? entry.overlay : [entry.overlay];
       const scope = liveScope(entry.id, entry.eligibility ?? {}, state);
-      if (scope === "active") active.push(entry.overlay);
-      else if (scope === "hotkey") hotkey.push(entry.overlay);
-      else if (scope === "ambient") ambient.push(entry.overlay);
+      if (scope === "active") active.push(...layers);
+      else if (scope === "hotkey") hotkey.push(...layers);
+      else if (scope === "ambient") ambient.push(...layers);
     }
     return [...active, ...hotkey, ...ambient];
   }, [snapshot]);
@@ -15811,7 +15656,7 @@ function isBoundsGradient(fill) {
   }
   return fill.units === "bounds";
 }
-var cache5 = /* @__PURE__ */ new Map();
+var cache6 = /* @__PURE__ */ new Map();
 function specKey(spec) {
   const keys = Object.keys(spec).sort();
   const bag = spec;
@@ -15819,10 +15664,10 @@ function specKey(spec) {
 }
 function resolvePatternSpec(spec) {
   const key = specKey(spec);
-  const hit = cache5.get(key);
+  const hit = cache6.get(key);
   if (hit !== void 0) return hit;
   const built = buildTile(spec);
-  cache5.set(key, built);
+  cache6.set(key, built);
   return built;
 }
 function buildTile(spec) {
@@ -15856,7 +15701,7 @@ function resolveFillPattern(fill) {
   const handle = resolvePatternSpec(fill.pattern);
   return handle ? { ...fill, pattern: handle } : null;
 }
-var cache6 = /* @__PURE__ */ new Map();
+var cache7 = /* @__PURE__ */ new Map();
 var subscribers2 = /* @__PURE__ */ new Set();
 var defaultLoader = async (src) => {
   if (typeof Image === "undefined" || typeof createImageBitmap === "undefined") {
@@ -15874,28 +15719,28 @@ function notify() {
 }
 function startLoad(src) {
   const entry = { status: "loading" };
-  cache6.set(src, entry);
+  cache7.set(src, entry);
   loader(src).then(
     (bitmap) => {
-      if (cache6.get(src) !== entry) return;
-      cache6.set(src, { status: "ready", bitmap });
+      if (cache7.get(src) !== entry) return;
+      cache7.set(src, { status: "ready", bitmap });
       notify();
     },
     () => {
-      if (cache6.get(src) !== entry) return;
-      cache6.set(src, { status: "error" });
+      if (cache7.get(src) !== entry) return;
+      cache7.set(src, { status: "error" });
       notify();
     }
   );
 }
 function getImageBitmap(src) {
-  const entry = cache6.get(src);
+  const entry = cache7.get(src);
   if (entry) return entry.bitmap;
   startLoad(src);
   return void 0;
 }
 function imageStatus(src) {
-  return cache6.get(src)?.status ?? "idle";
+  return cache7.get(src)?.status ?? "idle";
 }
 function subscribeImageReady(cb) {
   subscribers2.add(cb);
@@ -16253,6 +16098,7 @@ registerBuiltInShapePainters();
 function pickTopMostHit(ids, adapter) {
   if (ids.length === 0) return null;
   if (ids.length === 1) return ids[0];
+  let candidates = ids;
   const getParent = adapter?.getParent;
   if (typeof getParent === "function") {
     const set = new Set(ids);
@@ -16267,16 +16113,40 @@ function pickTopMostHit(ids, adapter) {
     }
     if (dropped.size > 0) {
       const filtered = ids.filter((id) => !dropped.has(id));
-      if (filtered.length === 0) ;
-      else if (filtered.length === 1) {
-        return filtered[0];
-      } else {
-        return filtered[filtered.length - 1];
+      if (filtered.length === 1) return filtered[0];
+      if (filtered.length > 1) candidates = filtered;
+    }
+  }
+  return pickHighestZ(candidates, adapter);
+}
+function pickHighestZ(ids, adapter) {
+  const compareZ = adapter?.compareZ;
+  if (typeof compareZ === "function") {
+    let best = ids[0];
+    for (let i = 1; i < ids.length; i++) {
+      if (compareZ(ids[i], best) >= 0) best = ids[i];
+    }
+    return best;
+  }
+  const getZIndex = adapter?.getZIndex;
+  if (typeof getZIndex === "function") {
+    let best = ids[0];
+    let bestZ = zOf(getZIndex, best);
+    for (let i = 1; i < ids.length; i++) {
+      const z = zOf(getZIndex, ids[i]);
+      if (z >= bestZ) {
+        best = ids[i];
+        bestZ = z;
       }
     }
+    return best;
   }
   return ids[ids.length - 1];
 }
+function zOf(getZIndex, id) {
+  const z = getZIndex(id);
+  return typeof z === "number" && Number.isFinite(z) ? z : -Infinity;
+}
 var MULTI_RESIZE_TARGET_ID = "__weasel:multi-selection";
 function useSelectTool(adapter, options) {
   const poseBoundsFn = options.poseBounds ?? ((p) => p);
@@ -16673,9 +16543,19 @@ function composeAffordanceLayer(id, label, affordances) {
     },
     // The walk itself lives in `hitAffordanceRegions` so this layer and
     // `buildAffordanceAt` share one implementation rather than two that can
-    // drift. This wrapper exists because `RenderLayer.hitTest` wants only the
-    // binding back.
-    hitTest: (wx, wy, state, view, _dims, isVisible) => hitAffordanceRegions(affordances, wx, wy, state, view, isVisible)?.binding ?? null
+    // drift. This wrapper lifts the region's declared cursor and claim onto
+    // the binding, the way `buildAffordanceAt` lifts them onto `AffordanceHit`.
+    hitTest: (wx, wy, state, view, _dims, isVisible) => {
+      const hit = hitAffordanceRegions(affordances, wx, wy, state, view, isVisible);
+      if (!hit) return null;
+      const { cursor, strength, claimedKinds } = hit.region;
+      return {
+        ...hit.binding,
+        ...cursor !== void 0 ? { cursor } : {},
+        ...strength !== void 0 ? { strength } : {},
+        ...claimedKinds !== void 0 ? { claimedKinds } : {}
+      };
+    }
   };
 }
 function asChromeState(data) {
@@ -17835,6 +17715,19 @@ function composeOrderedLayers(layersMap, standardLayers, sceneLayers) {
   }
   return out;
 }
+function placeToolOverlays(ordered, selectionOverlay, overlays) {
+  const before = overlays("before-selection");
+  const after = overlays("after-selection");
+  const at = selectionOverlay ? ordered.indexOf(selectionOverlay) : -1;
+  if (at >= 0) {
+    ordered.splice(at + 1, 0, ...after);
+    ordered.splice(at, 0, ...before);
+  } else {
+    ordered.push(...before, ...after);
+  }
+  ordered.push(...overlays("top"));
+  return ordered;
+}
 function* toolsInPriorityOrder(tools) {
   const seen = /* @__PURE__ */ new Set();
   const hotkey = tools.hotkeyEngaged ? tools.registry[tools.hotkeyEngaged] : void 0;
@@ -19263,7 +19156,7 @@ function CanvasInner(props, ref) {
     const out = composeOrderedLayers(effectiveLayersMap, standardLayers, sceneLayers);
     if (decorationLayer) out.push(decorationLayer);
     if (tools) {
-      out.push(...tools.getActiveOverlays());
+      placeToolOverlays(out, standardLayers.selectionOverlay, tools.getActiveOverlays);
     }
     return out;
   }, [layersMap, adapter, selectedIds, effectiveBoundsOf, multiActive2, debugSink, tools, backgroundLayer, decorationLayer]);
@@ -20893,6 +20786,7 @@ function useSceneSelectTool(args) {
     boundsOf: wiredBoundsOf
   };
 }
+var GHOST_ALPHA = 0.85;
 function usePreviewGhostLayer(args) {
   const { scene, tools, sceneSlot, dispatcher } = args;
   const sceneRef = useRef(scene);
@@ -20979,15 +20873,26 @@ function usePreviewGhostLayer(args) {
         }
         return [group];
       };
+      const opaqueSet = /* @__PURE__ */ new Set();
+      for (const source of sources) {
+        const ids = source.previewOpaqueIds?.();
+        if (!ids) continue;
+        for (const id of ids) opaqueSet.add(id);
+      }
       const children = [];
+      const opaque = [];
       for (const id of idSet) {
         const node = sc.get(asNodeId(id));
         const parent = node?.parent;
         if (parent != null && idSet.has(parent)) continue;
-        for (const cmd of buildSubtree(id)) children.push(cmd);
+        const sink = opaqueSet.has(id) ? opaque : children;
+        for (const cmd of buildSubtree(id)) sink.push(cmd);
       }
-      if (children.length === 0) return [];
-      return [{ kind: "group", alpha: 0.85, children }];
+      if (children.length === 0 && opaque.length === 0) return [];
+      const out = [];
+      if (opaque.length > 0) out.push({ kind: "group", children: opaque });
+      if (children.length > 0) out.push({ kind: "group", alpha: GHOST_ALPHA, children });
+      return out;
     }
   }), []);
 }
@@ -20997,6 +20902,7 @@ var DEFAULT_STYLE = {
   dash: [3, 3],
   lineWidth: 1
 };
+var PREVIEW_CONTENT_OPACITY = 0.85;
 function useDispatcherOverlayLayer(args) {
   const { dispatcher, style } = args;
   const dispatcherRef = useRef(dispatcher);
@@ -21059,6 +20965,26 @@ function useDispatcherOverlayLayer(args) {
                 pathCmd = rectPath(sx, sy, b.width * view.scale.x, b.height * view.scale.y);
                 break;
               }
+              case "image": {
+                const e = ov.extras;
+                const [sx, sy] = worldToScreen(b.x, b.y, t);
+                const sw = b.width * view.scale.x;
+                const sh = b.height * view.scale.y;
+                const bmp = e.preview === "outline" || !e.src ? void 0 : getImageBitmap(e.src);
+                if (bmp) {
+                  out.push({
+                    kind: "image",
+                    image: bmp,
+                    x: sx,
+                    y: sy,
+                    w: sw,
+                    h: sh,
+                    opacity: PREVIEW_CONTENT_OPACITY
+                  });
+                }
+                pathCmd = rectPath(sx, sy, sw, sh);
+                break;
+              }
               case "ellipse": {
                 const [sx, sy] = worldToScreen(b.x, b.y, t);
                 pathCmd = ellipsePath({
@@ -21117,7 +21043,7 @@ function useDispatcherOverlayLayer(args) {
             const cmd = {
               kind: "path",
               path: pathCmd,
-              fill: ov.shape === "line" || ov.shape === "pencil" ? void 0 : { color: cfg.fill },
+              fill: ov.shape === "line" || ov.shape === "pencil" || ov.shape === "image" ? void 0 : { color: cfg.fill },
               stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash }
             };
             out.push(cmd);
@@ -21806,9 +21732,6 @@ function buildClassifyTarget(getSelection, pickBest, kindOfNode) {
 function w2s3(wx, wy, view) {
   return [(wx - view.x) * view.scale.x, (wy - view.y) * view.scale.y];
 }
-function r2s(radiusWorld, view) {
-  return radiusWorld * meanScale(view.scale);
-}
 var SLOP_FILL = "rgba(255, 80, 140, 0.18)";
 var SLOP_STROKE = "rgba(255, 80, 140, 0.55)";
 function createSlopsDebugLayer(opts) {
@@ -21819,7 +21742,7 @@ function createSlopsDebugLayer(opts) {
     draw: (_data, view) => {
       const out = [];
       const sel = opts.selectionRef.current?.current ?? [];
-      const r = r2s(HANDLE_HIT_RADIUS, view);
+      const r = HANDLE_HIT_RADIUS;
       for (const id of sel) {
         const b = opts.boundsOf(id);
         if (!b) continue;
@@ -21856,6 +21779,7 @@ function createSlopsDebugLayer(opts) {
       }
       const editingId = opts.getEditingId();
       if (editingId) {
+        const anchorR = ANCHOR_HIT_RADIUS;
         const pose = opts.getPose(editingId);
         if (pose && pose.kind === "polygon") {
           const anchors = enumerateAnchors(pose);
@@ -21863,7 +21787,7 @@ function createSlopsDebugLayer(opts) {
             const [sx, sy] = w2s3(a.x, a.y, view);
             out.push({
               kind: "path",
-              path: circlePath(sx, sy, r),
+              path: circlePath(sx, sy, anchorR),
               fill: { fill: "solid", color: SLOP_FILL },
               stroke: { paint: { fill: "solid", color: SLOP_STROKE }, width: 1 }
             });
@@ -21871,7 +21795,7 @@ function createSlopsDebugLayer(opts) {
               const [csx, csy] = w2s3(a.controlIn.x, a.controlIn.y, view);
               out.push({
                 kind: "path",
-                path: circlePath(csx, csy, r),
+                path: circlePath(csx, csy, anchorR),
                 fill: { fill: "solid", color: SLOP_FILL },
                 stroke: { paint: { fill: "solid", color: SLOP_STROKE }, width: 1 }
               });
@@ -21880,7 +21804,7 @@ function createSlopsDebugLayer(opts) {
               const [csx, csy] = w2s3(a.controlOut.x, a.controlOut.y, view);
               out.push({
                 kind: "path",
-                path: circlePath(csx, csy, r),
+                path: circlePath(csx, csy, anchorR),
                 fill: { fill: "solid", color: SLOP_FILL },
                 stroke: { paint: { fill: "solid", color: SLOP_STROKE }, width: 1 }
               });
@@ -21958,9 +21882,9 @@ function DepRegistryProviderIfRoot({ children }) {
 function hitTestArea(scene, bounds) {
   const { x, y, width: w, height: h } = bounds;
   const area = [x, y, x + w, y, x + w, y + h, x, y + h];
-  return hitTestAreaPolygon(scene, area, { x, y, width: w, height: h });
+  return hitTestAreaPolygon(scene, area, { x, y, width: w, height: h }, true);
 }
-function hitTestAreaPolygon(scene, area, areaBounds) {
+function hitTestAreaPolygon(scene, area, areaBounds, areaIsRect = false) {
   const ab = areaBounds ?? boundsOf(area);
   if (!ab) return [];
   const hits = [];
@@ -21977,13 +21901,22 @@ function hitTestAreaPolygon(scene, area, areaBounds) {
     if (b.x >= ab.x + ab.width || b.x + b.width <= ab.x || b.y >= ab.y + ab.height || b.y + b.height <= ab.y) {
       continue;
     }
-    if (!silhouette) {
+    if (areaIsRect && b.x >= ab.x && b.y >= ab.y && b.x + b.width <= ab.x + ab.width && b.y + b.height <= ab.y + ab.height) {
       hits.push(node.id);
       continue;
     }
-    if (silhouetteOverlapsArea(pose.coords, area)) {
-      hits.push(node.id);
+    if (silhouette) {
+      if (silhouetteOverlapsArea(pose.coords, area)) {
+        hits.push(node.id);
+      }
+      continue;
+    }
+    const drawn = findShapeSilhouette(node, pose);
+    if (drawn?.kind === "polygon") {
+      if (silhouetteOverlapsArea(drawn.coords, area)) hits.push(node.id);
+      continue;
     }
+    hits.push(node.id);
   }
   return hits;
 }
@@ -24573,5 +24506,5 @@ function oklchToOklab(L, C, h) {
 }
 
 export { FALLBACK_FIT_VIEW, MinimapCanvas, SceneViewCanvas, UnknownIcon, buildSceneViewCommands, computeFitView2, computeIndicatorCommand, eligibleContribution, evaluateEnabled, oklabToSrgbU8, oklchToOklab, renderSceneToCanvas, rgbaToHex, useActionsRegistry, useOptionalDepRegistry };
-//# sourceMappingURL=chunk-ISEK5LXT.js.map
-//# sourceMappingURL=chunk-ISEK5LXT.js.map
+//# sourceMappingURL=chunk-3WPOGKUP.js.map
+//# sourceMappingURL=chunk-3WPOGKUP.js.map