@weasel-js/labkit 0.7.2 → 0.8.0

package/dist/{chunk-5XDFILHZ.js → chunk-6V7ROR7G.js}

@@ -21,6 +21,7 @@ var GESTURE_DESCRIPTORS = [
   { name: "keyUp", hasTarget: false, arg: { name: "key", values: "free" } },
   { 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"] } }
 ];
 var BY_NAME = new Map(
@@ -318,6 +319,8 @@ function actionClause(parsed, required) {
       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":
@@ -502,6 +505,11 @@ function matchSpec(e, spec, isMac, phaseCtx) {
       if (!matchModifiers(e, spec.mods, isMac)) return false;
       return matchTarget(e.target, spec.target, e.bodyTarget, e.bodyKind);
     }
+    case "longPress": {
+      if (e.kind !== "longpress") return false;
+      if (!matchModifiers(e, spec.mods, isMac)) return false;
+      return matchTarget(e.affordance, spec.target, e.bodyTarget, e.bodyKind);
+    }
     case "drag": {
       if (e.kind !== "pointerdown") return false;
       if (e.stage === "press") return false;
@@ -540,7 +548,7 @@ function matchSpec(e, spec, isMac, phaseCtx) {
 }
 var EMPTY_ENGAGED = /* @__PURE__ */ new Set();
 
-// ../core/dist/chunk-SYM6RAM4.js
+// ../core/dist/chunk-6DAUIMTO.js
 var routing_exports = {};
 __export(routing_exports, {
   GESTURE_DESCRIPTORS: () => GESTURE_DESCRIPTORS,
@@ -613,6 +621,7 @@ var SPEC_KIND_TO_GESTURE = {
   click: "click",
   doubleClick: "dblTap",
   contextMenu: "contextMenu",
+  longPress: "longPress",
   drag: "drag",
   pointerDown: "pointerDown",
   multiTouch: void 0,
@@ -873,7 +882,7 @@ function transformCoords(coords, m) {
   return out;
 }
 
-// ../core/dist/chunk-CQNKCG34.js
+// ../core/dist/chunk-GLZLSPGJ.js
 function resolveUnit(v, unitSystem) {
   if (typeof v === "number") return v;
   if (!unitSystem) {
@@ -1584,7 +1593,7 @@ function createDeleteOp(args) {
 }
 registerOpFactory("delete", (args) => createDeleteOp(args));
 
-// ../core/dist/chunk-VOVKONXA.js
+// ../core/dist/chunk-BPRHGTLQ.js
 function createTransformOp(args) {
   const { id, from, to, label, coalesceKey = `transform:${id}` } = args;
   return {
@@ -1665,7 +1674,7 @@ function snap(strategy, opts = {}) {
   };
 }
 
-// ../core/dist/chunk-BGGZ4CVF.js
+// ../core/dist/chunk-CMBE45MT.js
 function lockAspectWithModifier(opts = {}) {
   const { key = "shift" } = opts;
   return {
@@ -2210,17 +2219,17 @@ function dynamicPageTextureId(page) {
   return `weasel-dyn-sdf-page-${page}`;
 }
 var uploadedVersions = /* @__PURE__ */ new WeakMap();
-function syncDynamicPageTexture(cache5, pageIndex) {
+function syncDynamicPageTexture(cache6, pageIndex) {
   const page = pages[pageIndex];
   if (!page) return false;
   const id = dynamicPageTextureId(pageIndex);
-  let seen = uploadedVersions.get(cache5);
+  let seen = uploadedVersions.get(cache6);
   if (!seen) {
     seen = /* @__PURE__ */ new Map();
-    uploadedVersions.set(cache5, seen);
+    uploadedVersions.set(cache6, seen);
   }
-  if (!cache5.has(id)) {
-    cache5.uploadR8(id, PAGE_SIZE, PAGE_SIZE, page.data);
+  if (!cache6.has(id)) {
+    cache6.uploadR8(id, PAGE_SIZE, PAGE_SIZE, page.data);
     seen.set(pageIndex, page.version);
     return true;
   }
@@ -2233,7 +2242,7 @@ function syncDynamicPageTexture(cache5, pageIndex) {
       const src = (patch.y + row) * PAGE_SIZE + patch.x;
       tight.set(page.data.subarray(src, src + patch.w), row * patch.w);
     }
-    cache5.subImageR8(id, patch.x, patch.y, patch.w, patch.h, tight);
+    cache6.subImageR8(id, patch.x, patch.y, patch.w, patch.h, tight);
   }
   seen.set(pageIndex, page.version);
   return true;
@@ -2441,6 +2450,23 @@ var slots = /* @__PURE__ */ new Map();
 function slotKey(family, weight, style) {
   return `${family}|${weight}|${style}`;
 }
+function closeContours(d) {
+  let out = "";
+  let start = 0;
+  for (let i = 1; i < d.length; i++) {
+    const c = d[i];
+    if (c !== "M" && c !== "m") continue;
+    out += closeOne(d.slice(start, i));
+    start = i;
+  }
+  return out + closeOne(d.slice(start));
+}
+function closeOne(contour) {
+  const trimmed = contour.trimEnd();
+  if (trimmed.length === 0) return "";
+  const last = trimmed[trimmed.length - 1];
+  return last === "Z" || last === "z" ? trimmed : `${trimmed}Z`;
+}
 function glyphOutline(family, weight, style, cp) {
   const slot = slots.get(slotKey(family, weight, style));
   if (!slot) return null;
@@ -2453,7 +2479,8 @@ function glyphOutline(family, weight, style, cp) {
   if (cached2 !== void 0) return cached2;
   let d = null;
   try {
-    d = slot.face.glyphD(cp);
+    const raw = slot.face.glyphD(cp);
+    d = raw === null ? null : closeContours(raw);
   } catch (err) {
     warnOnce(
       `glyph|${slotKey(family, weight, style)}`,
@@ -2982,7 +3009,7 @@ function serialToEntry(se, custom, logger) {
   };
 }
 
-// ../core/dist/chunk-5F3PIERN.js
+// ../core/dist/chunk-DLV5F4NY.js
 function worldToScreen(worldX, worldY, view) {
   return [view.panX + worldX * view.zoom.x, view.panY + worldY * view.zoom.y];
 }
@@ -4355,6 +4382,16 @@ function extractPolygon(p, opts) {
     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);
@@ -4438,7 +4475,10 @@ function extractPolygon(p, opts) {
         break;
       }
       case PATH_Z2: {
-        if (current) current.closed = true;
+        if (current) {
+          current.closed = true;
+          dropDuplicateClosingPoint();
+        }
         break;
       }
       default:
@@ -4919,8 +4959,20 @@ function sameFill(a, b) {
   }
   return false;
 }
-function groupKey(family, weight, style, synthetic, fill, source, page) {
-  return `${family}|${weight}|${style}|${synthetic.bold ? 1 : 0}${synthetic.italic ? 1 : 0}|${fillKey(fill)}|${source}|${page}`;
+function strokeKey(s) {
+  if (!s) return "-";
+  return [
+    fillKey(s.paint),
+    s.width ?? 1,
+    s.join ?? "miter",
+    s.cap ?? "butt",
+    s.miterLimit ?? "",
+    s.align ?? "center",
+    (s.dash ?? []).join(",")
+  ].join(":");
+}
+function groupKey(family, weight, style, synthetic, fill, stroke, source, page) {
+  return `${family}|${weight}|${style}|${synthetic.bold ? 1 : 0}${synthetic.italic ? 1 : 0}|${fillKey(fill)}|${strokeKey(stroke)}|${source}|${page}`;
 }
 function getOrCreateGroup(ctx, run, resolved, page, sourceOverride) {
   const atlasFamily = resolved.resolved.family;
@@ -4933,6 +4985,7 @@ function getOrCreateGroup(ctx, run, resolved, page, sourceOverride) {
     resolvedStyle,
     resolved.synthetic,
     run.fill,
+    source === "outline" ? run.stroke : void 0,
     source,
     page
   );
@@ -4946,6 +4999,9 @@ function getOrCreateGroup(ctx, run, resolved, page, sourceOverride) {
       source,
       page,
       fill: run.fill,
+      // Only the outline tier can paint it, and carrying it on an SDF group
+      // would be a promise the renderer cannot keep.
+      ...source === "outline" && run.stroke !== void 0 ? { stroke: run.stroke } : {},
       quads: [],
       glyphs: []
     };
@@ -5542,6 +5598,34 @@ function outlineMesh(key, d) {
   cache3.set(key, mesh);
   return mesh;
 }
+var OUTLINE_STROKE_MESH_CACHE_LIMIT = 2048;
+var WIDTH_QUANTUM = 1 / 1024;
+var cache4 = /* @__PURE__ */ new Map();
+function quantizeEmWidth(emWidth) {
+  return Math.round(emWidth / WIDTH_QUANTUM) * WIDTH_QUANTUM;
+}
+function outlineStrokeMesh(glyphKey, d, emWidth, stroke) {
+  if (!(emWidth > 0)) return null;
+  const key = [
+    glyphKey,
+    emWidth,
+    stroke.join ?? "miter",
+    stroke.cap ?? "butt",
+    stroke.miterLimit ?? "",
+    stroke.align ?? "center",
+    (stroke.dash ?? []).join(",")
+  ].join("|");
+  const cached2 = cache4.get(key);
+  if (cached2 !== void 0) return cached2.indices.length === 0 ? null : cached2;
+  if (cache4.size >= OUTLINE_STROKE_MESH_CACHE_LIMIT) cache4 = /* @__PURE__ */ new Map();
+  const mesh = tessellateStroke(
+    pathFromD(d),
+    { ...stroke, width: emWidth },
+    { flattenTolerance: OUTLINE_FLATTEN_TOLERANCE }
+  );
+  cache4.set(key, mesh);
+  return mesh.indices.length === 0 ? null : mesh;
+}
 function setColorMatrixUniforms(ctx, prog) {
   const gl = ctx.gl;
   const cm = ctx.state.colorMatrix;
@@ -6115,16 +6199,30 @@ function drawText(ctx, cmd) {
 var SYNTHETIC_ITALIC_RADIANS = 0.2094;
 function drawTextOutlineGroup(ctx, group, dy) {
   const mesh = outlineGroupMesh(group, dy);
-  if (!mesh) return;
-  drawPathFillByKind(ctx, group.fill, ctx.meshCache.uploadTransient(mesh));
+  if (mesh) drawPathFillByKind(ctx, group.fill, ctx.meshCache.uploadTransient(mesh));
+  if (!group.stroke) return;
+  const strokeMesh = outlineGroupStrokeMesh(group, dy);
+  if (strokeMesh) {
+    drawPathFillByKind(ctx, group.stroke.paint, ctx.meshCache.uploadTransient(strokeMesh));
+  }
 }
 function outlineGroupMesh(group, dy) {
+  return mergeGlyphMeshes(group, dy, (glyph) => outlineMesh(glyph.key, glyph.d));
+}
+function outlineGroupStrokeMesh(group, dy) {
+  const stroke = group.stroke;
+  if (!stroke) return null;
+  const width = stroke.width ?? 1;
+  if (!(width > 0)) return null;
+  return mergeGlyphMeshes(group, dy, (glyph) => glyph.scale > 0 ? outlineStrokeMesh(glyph.key, glyph.d, quantizeEmWidth(width / glyph.scale), stroke) : null);
+}
+function mergeGlyphMeshes(group, dy, meshFor) {
   const parts = [];
   let vertexFloats = 0;
   let indexCount = 0;
   for (const glyph of group.glyphs) {
-    const mesh = outlineMesh(glyph.key, glyph.d);
-    if (mesh.indices.length === 0) continue;
+    const mesh = meshFor(glyph);
+    if (!mesh || mesh.indices.length === 0) continue;
     parts.push({ mesh, glyph });
     vertexFloats += mesh.vertices.length;
     indexCount += mesh.indices.length;
@@ -6964,6 +7062,103 @@ function clientToCanvas(canvas, clientX, clientY) {
 function clientToCanvasRect(rect, clientX, clientY) {
   return [clientX - rect.left, clientY - rect.top];
 }
+var COARSE_TARGET_SCALE = 1.75;
+function resolveDeviceProfile(detected, overrides) {
+  const coarsePointer2 = overrides?.coarsePointer ?? detected.coarsePointer;
+  const canHover2 = overrides?.canHover ?? detected.canHover;
+  const dpr = overrides?.dpr ?? detected.dpr;
+  const targetScale = overrides?.targetScale ?? (coarsePointer2 ? COARSE_TARGET_SCALE : 1);
+  return { coarsePointer: coarsePointer2, canHover: canHover2, dpr, targetScale };
+}
+var DEFAULT_DEVICE_PROFILE = resolveDeviceProfile({
+  coarsePointer: false,
+  canHover: true,
+  dpr: 1
+});
+var COARSE_QUERY = "(pointer: coarse)";
+var HOVER_QUERY = "(hover: hover)";
+function hasMatchMedia() {
+  return typeof window !== "undefined" && typeof window.matchMedia === "function";
+}
+function detectOnce() {
+  const dpr = typeof window !== "undefined" && window.devicePixelRatio || 1;
+  if (!hasMatchMedia()) {
+    return {
+      coarsePointer: DEFAULT_DEVICE_PROFILE.coarsePointer,
+      canHover: DEFAULT_DEVICE_PROFILE.canHover,
+      dpr
+    };
+  }
+  return {
+    coarsePointer: window.matchMedia(COARSE_QUERY).matches,
+    canHover: window.matchMedia(HOVER_QUERY).matches,
+    dpr
+  };
+}
+function useDetectedFacts() {
+  const [facts, setFacts] = useState(detectOnce);
+  useEffect(() => {
+    if (!hasMatchMedia()) return;
+    const coarseMq = window.matchMedia(COARSE_QUERY);
+    const hoverMq = window.matchMedia(HOVER_QUERY);
+    const onCoarse = (e) => setFacts((f) => ({ ...f, coarsePointer: e.matches }));
+    const onHover = (e) => setFacts((f) => ({ ...f, canHover: e.matches }));
+    coarseMq.addEventListener("change", onCoarse);
+    hoverMq.addEventListener("change", onHover);
+    let disposed = false;
+    let densityMq = null;
+    const onDensity = () => {
+      if (disposed) return;
+      const next = window.devicePixelRatio || 1;
+      setFacts((f) => f.dpr === next ? f : { ...f, dpr: next });
+      arm();
+    };
+    function arm() {
+      if (disposed) return;
+      densityMq?.removeEventListener("change", onDensity);
+      densityMq = window.matchMedia(
+        `(resolution: ${window.devicePixelRatio || 1}dppx)`
+      );
+      densityMq.addEventListener("change", onDensity);
+    }
+    arm();
+    setFacts({
+      coarsePointer: coarseMq.matches,
+      canHover: hoverMq.matches,
+      dpr: window.devicePixelRatio || 1
+    });
+    return () => {
+      disposed = true;
+      coarseMq.removeEventListener("change", onCoarse);
+      hoverMq.removeEventListener("change", onHover);
+      densityMq?.removeEventListener("change", onDensity);
+    };
+  }, []);
+  return facts;
+}
+var DeviceProfileContext = createContext(null);
+function useDeviceProfile(overrides) {
+  const provided = useContext(DeviceProfileContext);
+  const detected = useDetectedFacts();
+  const base = provided ?? detected;
+  const { coarsePointer: coarsePointer2, canHover: canHover2, dpr, targetScale } = overrides ?? {};
+  return useMemo(
+    () => resolveDeviceProfile(base, {
+      ...coarsePointer2 !== void 0 ? { coarsePointer: coarsePointer2 } : {},
+      ...canHover2 !== void 0 ? { canHover: canHover2 } : {},
+      ...dpr !== void 0 ? { dpr } : {},
+      ...targetScale !== void 0 ? { targetScale } : {}
+    }),
+    [base.coarsePointer, base.canHover, base.dpr, coarsePointer2, canHover2, dpr, targetScale]
+  );
+}
+function DeviceProfileProvider({ value, children }) {
+  const profile = useDeviceProfile(value);
+  return createElement(DeviceProfileContext.Provider, { value: profile }, children);
+}
+var HANDLE_BASE_PX = 8;
+var ANCHOR_HIT_BASE_PX = 8;
+var ROTATION_HANDLE_BASE_PX = 24;
 function zoomAt(view, anchor, factor, opts) {
   const fx = typeof factor === "number" ? factor : factor.x;
   const fy = typeof factor === "number" ? factor : factor.y;
@@ -8694,6 +8889,10 @@ var clearSelectionAction = {
     return true;
   }
 };
+var counter = 0;
+function freshNodeId() {
+  return asNodeId(`n${(counter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`);
+}
 function translatePose(pose, dx, dy) {
   const p = pose;
   return {
@@ -8702,10 +8901,6 @@ function translatePose(pose, dx, dy) {
     y: (p["y"] ?? 0) + dy
   };
 }
-var cloneIdCounter = 0;
-function freshCloneId() {
-  return asNodeId(`n${(cloneIdCounter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`);
-}
 var cloneAction = {
   id: "clone",
   label: "Clone",
@@ -8772,7 +8967,7 @@ var cloneAction = {
             if (origin === void 0 || !originNode) continue;
             const newPose = translatePose(origin, dx, dy);
             const node = {
-              id: freshCloneId(),
+              id: freshNodeId(),
               kind: originNode.kind,
               layer: originNode.layer,
               pose: newPose,
@@ -9555,6 +9750,119 @@ var pinchZoomAction = {
   },
   enabled: () => true
 };
+function hostIndex(scene, id) {
+  const node = scene.get(id);
+  const siblings = node?.parent == null ? scene.roots : scene.childrenOf(node.parent);
+  return siblings.indexOf(id);
+}
+function hasSelectedAncestor(scene, id, set) {
+  let parent = scene.get(id)?.parent ?? null;
+  while (parent != null) {
+    if (set.has(parent)) return true;
+    parent = scene.get(parent)?.parent ?? null;
+  }
+  return false;
+}
+function buildDeleteOps(scene, ids, label) {
+  const set = new Set(ids);
+  const ops = [];
+  for (const id of ids) {
+    const node = scene.get(id);
+    if (!node) continue;
+    if (hasSelectedAncestor(scene, id, set)) continue;
+    ops.push(createDeleteOp({
+      node,
+      index: hostIndex(scene, id),
+      label
+    }));
+  }
+  return ops;
+}
+var deleteAction = {
+  id: "delete",
+  label: "Delete",
+  // Suppressed while any tool is mid-gesture — accidentally hitting
+  // Delete during a drag shouldn't wipe the selection out from under
+  // the in-flight handle.
+  defaultBinding: {
+    kind: "key",
+    key: ["Delete", "Backspace"],
+    phase: [{ channel: "*", phase: "initial" }]
+  },
+  eligible: { capability: "edits-page" },
+  requires: ["scene", "selection", "applyOps"],
+  invoker: {
+    timing: "immediate",
+    run: (deps) => {
+      const selection = deps.selection;
+      const scene = deps.scene;
+      const applyOps = deps.applyOps;
+      if (!selection || !scene) return;
+      const ids = selection.get();
+      if (ids.length === 0) return;
+      const ops = buildDeleteOps(scene, ids, "Delete");
+      if (ops.length > 0) {
+        if (applyOps) applyOps(ops, "Delete");
+        else scene.applyBatch(ops, "Delete", defaultCommitAdapter(scene));
+      }
+      selection.set([]);
+    }
+  },
+  enabled: () => true
+};
+function requiresSelection(deps) {
+  const selection = deps?.selection;
+  if (!selection || selection.get().length === 0) {
+    return ActionDisabledReason.SelectionRequired;
+  }
+  return true;
+}
+var clipboardCopyAction = {
+  id: "clipboard.copy",
+  label: "Copy",
+  defaultBinding: { kind: "key", key: "c", mods: { mod: true } },
+  // Same gate as `duplicate`: a mode that can neither edit the page nor own a
+  // selection has nothing to copy. Notably excludes `text-edit`, where Cmd+C
+  // must stay the browser's own copy of the caret range.
+  eligible: { capability: ["edits-page", "creates-selection"] },
+  // `selection` is read by the `enabled` gate, not the invoker — the
+  // dispatcher builds deps for both, and an undeclared read is undefined.
+  requires: ["clipboard", "selection"],
+  invoker: {
+    timing: "immediate",
+    run: (deps) => {
+      deps.clipboard?.copy();
+    }
+  },
+  enabled: requiresSelection
+};
+var clipboardCutAction = {
+  id: "clipboard.cut",
+  label: "Cut",
+  defaultBinding: { kind: "key", key: "x", mods: { mod: true } },
+  eligible: { capability: "edits-page" },
+  requires: ["clipboard", "scene", "selection", "applyOps"],
+  invoker: {
+    timing: "immediate",
+    run: (deps) => {
+      const clipboard = deps.clipboard;
+      const selection = deps.selection;
+      const scene = deps.scene;
+      const applyOps = deps.applyOps;
+      if (!clipboard || !selection || !scene) return;
+      const ids = selection.get();
+      if (ids.length === 0) return;
+      clipboard.copy();
+      const ops = buildDeleteOps(scene, ids, "Cut");
+      if (ops.length > 0) {
+        if (applyOps) applyOps(ops, "Cut");
+        else scene.applyBatch(ops, "Cut", defaultCommitAdapter(scene));
+      }
+      selection.set([]);
+    }
+  },
+  enabled: requiresSelection
+};
 var enterTextEditAction = {
   id: "enterTextEdit",
   label: "Enter text edit",
@@ -9679,24 +9987,45 @@ var selectAllAction = {
     }
   }
 };
-function hostIndex(scene, id) {
+var DUPLICATE_OFFSET = 12;
+function translatePose2(pose, dx, dy) {
+  const p = pose;
+  return { ...p, x: (p["x"] ?? 0) + dx, y: (p["y"] ?? 0) + dy };
+}
+function hasSelectedAncestor2(scene, id, set) {
+  let parent = scene.get(id)?.parent ?? null;
+  while (parent != null) {
+    if (set.has(parent)) return true;
+    parent = scene.get(parent)?.parent ?? null;
+  }
+  return false;
+}
+function copySubtree(scene, id, parent, offset, offsetDescendants, ops) {
   const node = scene.get(id);
-  const siblings = node?.parent == null ? scene.roots : scene.childrenOf(node.parent);
-  return siblings.indexOf(id);
+  if (!node) return null;
+  const newId = freshNodeId();
+  const copy = {
+    ...node,
+    id: newId,
+    pose: translatePose2(node.pose, offset.dx, offset.dy),
+    parent
+  };
+  ops.push(createInsertOp({ node: copy, label: "Duplicate" }));
+  const childOffset = offsetDescendants ? offset : { dx: 0, dy: 0 };
+  for (const child of scene.childrenOf(id)) {
+    copySubtree(scene, child, newId, childOffset, offsetDescendants, ops);
+  }
+  return newId;
 }
-var deleteAction = {
-  id: "delete",
-  label: "Delete",
-  // Suppressed while any tool is mid-gesture — accidentally hitting
-  // Delete during a drag shouldn't wipe the selection out from under
-  // the in-flight handle.
-  defaultBinding: {
-    kind: "key",
-    key: ["Delete", "Backspace"],
-    phase: [{ channel: "*", phase: "initial" }]
-  },
-  eligible: { capability: "edits-page" },
-  requires: ["scene", "selection", "applyOps"],
+var duplicateAction = {
+  id: "duplicate",
+  label: "Duplicate",
+  defaultBinding: { kind: "key", key: "d", mods: { mod: true } },
+  eligible: { capability: ["edits-page", "creates-selection"] },
+  // `selection` is read by the `enabled` gate as well as the invoker. An
+  // undeclared read throws inside the dev-build deps Proxy before the gate can
+  // answer, which is how this action spent a while doing nothing at all.
+  requires: ["scene", "selection", "applyOps", "poseComposition"],
   invoker: {
     timing: "immediate",
     run: (deps) => {
@@ -9706,40 +10035,22 @@ var deleteAction = {
       if (!selection || !scene) return;
       const ids = selection.get();
       if (ids.length === 0) return;
+      const set = new Set(ids);
+      const offset = { dx: DUPLICATE_OFFSET, dy: DUPLICATE_OFFSET };
       const ops = [];
+      const newIds = [];
       for (const id of ids) {
-        const node = scene.get(id);
+        const nid = asNodeId(id);
+        const node = scene.get(nid);
         if (!node) continue;
-        ops.push(createDeleteOp({
-          node,
-          index: hostIndex(scene, id),
-          label: "Delete"
-        }));
-      }
-      if (ops.length > 0) {
-        if (applyOps) applyOps(ops, "Delete");
-        else scene.applyBatch(ops, "Delete", defaultCommitAdapter(scene));
+        if (hasSelectedAncestor2(scene, nid, set)) continue;
+        const newId = copySubtree(scene, nid, node.parent ?? null, offset, deps.poseComposition === void 0, ops);
+        if (newId) newIds.push(newId);
       }
-      selection.set([]);
-    }
-  },
-  enabled: () => true
-};
-function requiresSelection(deps) {
-  const selection = deps?.selection;
-  if (!selection || selection.get().length === 0) {
-    return ActionDisabledReason.SelectionRequired;
-  }
-  return true;
-}
-var duplicateAction = {
-  id: "duplicate",
-  label: "Duplicate",
-  defaultBinding: { kind: "key", key: "d", mods: { mod: true } },
-  eligible: { capability: ["edits-page", "creates-selection"] },
-  invoker: {
-    timing: "immediate",
-    run: (_deps, params) => {
+      if (ops.length === 0) return;
+      if (applyOps) applyOps(ops, "Duplicate");
+      else scene.applyBatch(ops, "Duplicate", defaultCommitAdapter(scene));
+      selection.set(newIds);
     }
   },
   enabled: requiresSelection
@@ -11719,7 +12030,8 @@ function resolveTextStyle(style) {
     selectionColor: style.selectionColor ?? null,
     letterSpacing: style.letterSpacing ?? DEFAULT_TEXT_STYLE.letterSpacing,
     underline: style.underline ?? DEFAULT_TEXT_STYLE.underline,
-    strikethrough: style.strikethrough ?? DEFAULT_TEXT_STYLE.strikethrough
+    strikethrough: style.strikethrough ?? DEFAULT_TEXT_STYLE.strikethrough,
+    ...style.stroke !== void 0 ? { stroke: style.stroke } : {}
   };
 }
 function numericWeight(w) {
@@ -11740,6 +12052,9 @@ function resolveRuns(runs, style) {
       fontWeight: run.bold ? 700 : baseWeight,
       fontStyle: run.italic ? "italic" : style.fontStyle,
       fill: run.fill ?? style.fill,
+      // Unlike the decorations below, a run's stroke *replaces* the node's
+      // rather than adding to it — there is only one outline to paint.
+      ...(run.stroke ?? style.stroke) !== void 0 ? { stroke: run.stroke ?? style.stroke } : {},
       letterSpacing: run.letterSpacing ?? style.letterSpacing,
       // `||`, not `??`: run-level decorations are additive over the node style.
       underline: run.underline || style.underline,
@@ -12116,7 +12431,9 @@ var KIT_STANDARD_DESCRIPTORS = [
   setStrokeAction,
   setFillOpacityAction,
   setStrokeOpacityAction,
-  ingestAction
+  ingestAction,
+  clipboardCopyAction,
+  clipboardCutAction
 ];
 function useStandardActions(opts) {
   const optsRef = useRef(opts);
@@ -12281,6 +12598,14 @@ function evaluateSelector(s, ctx) {
     const resizable2 = ctx.selectionResizable ?? true;
     if (resizable2 !== s.resizable) return false;
   }
+  if (s.coarsePointer !== void 0) {
+    const device = ctx.device ?? DEFAULT_DEVICE_PROFILE;
+    if (device.coarsePointer !== s.coarsePointer) return false;
+  }
+  if (s.canHover !== void 0) {
+    const device = ctx.device ?? DEFAULT_DEVICE_PROFILE;
+    if (device.canHover !== s.canHover) return false;
+  }
   return true;
 }
 var MAX_RULE_DEPTH = 10;
@@ -12350,6 +12675,8 @@ cond({ selection: { empty: true } });
 cond({ when: (c) => c.multiActive });
 cond({ hovering: true });
 cond({ hoveringSelected: true });
+cond({ coarsePointer: true });
+cond({ canHover: true });
 var DEFAULT_ALLOWED_CAPABILITIES = /* @__PURE__ */ new Set([
   ...NORMAL.allows,
   ...IMPLICIT_TAGS
@@ -13255,6 +13582,44 @@ function useGestureDispatcher(opts) {
     const DRAG_THRESHOLD_PX = 4;
     const bufferedDown = /* @__PURE__ */ new Map();
     const lastPointerDown = /* @__PURE__ */ new Map();
+    const LONG_PRESS_MS = 500;
+    const longPressTimers = /* @__PURE__ */ new Map();
+    const cancelLongPress = (pointerId) => {
+      const t = longPressTimers.get(pointerId);
+      if (t !== void 0) {
+        clearTimeout(t);
+        longPressTimers.delete(pointerId);
+      }
+    };
+    const cancelAllLongPress = () => {
+      for (const t of longPressTimers.values()) clearTimeout(t);
+      longPressTimers.clear();
+    };
+    const fireLongPress = (pointerId) => {
+      const down = lastPointerDown.get(pointerId);
+      if (!down) return;
+      const shared = {
+        target: down.target,
+        altKey: down.altKey,
+        ctrlKey: down.ctrlKey,
+        metaKey: down.metaKey,
+        shiftKey: down.shiftKey,
+        ...down.bodyTarget !== void 0 ? { bodyTarget: down.bodyTarget } : {},
+        ...down.bodyKind !== void 0 ? { bodyKind: down.bodyKind } : {}
+      };
+      const result = dispatch2({
+        kind: "longpress",
+        x: down.worldX,
+        y: down.worldY,
+        clientX: down.clientX,
+        clientY: down.clientY,
+        ...down.affordance !== void 0 ? { affordance: down.affordance } : {},
+        ...shared
+      });
+      if (result === "unhandled") {
+        dispatch2({ kind: "contextmenu", ...shared });
+      }
+    };
     const DOUBLE_CLICK_MAX_MS = 600;
     const DOUBLE_CLICK_MAX_PX = 8;
     const onKeyDown = (e) => {
@@ -13358,6 +13723,7 @@ function useGestureDispatcher(opts) {
       bufferedDown.set(e.pointerId, { ev, clientX: e.clientX, clientY: e.clientY });
       dispatch2({ ...ev, stage: "press" });
       lastPointerDown.set(e.pointerId, {
+        target: e.target,
         clientX: e.clientX,
         clientY: e.clientY,
         worldX: w.x,
@@ -13370,7 +13736,19 @@ function useGestureDispatcher(opts) {
         metaKey: e.metaKey,
         shiftKey: e.shiftKey
       });
+      if ((e.pointerType === "touch" || e.pointerType === "pen") && activePointers.size === 1) {
+        cancelLongPress(e.pointerId);
+        longPressTimers.set(
+          e.pointerId,
+          setTimeout(() => {
+            longPressTimers.delete(e.pointerId);
+            if (disposed) return;
+            fireLongPress(e.pointerId);
+          }, LONG_PRESS_MS)
+        );
+      }
       if (activePointers.size >= 2) {
+        cancelAllLongPress();
         for (const id of activePointers) bufferedDown.delete(id);
         const { centroid, spread } = computeMultiTouchGeometry(pointerPositions);
         if (!multiTouchStart) {
@@ -13401,6 +13779,7 @@ function useGestureDispatcher(opts) {
         const dy = e.clientY - buffered.clientY;
         if (Math.hypot(dx, dy) >= DRAG_THRESHOLD_PX) {
           bufferedDown.delete(e.pointerId);
+          cancelLongPress(e.pointerId);
           dispatch2(buffered.ev);
         }
       }
@@ -13514,6 +13893,7 @@ function useGestureDispatcher(opts) {
       clearHoverCursor();
     };
     const onPointerUp = (e) => {
+      cancelLongPress(e.pointerId);
       const prevSize = activePointers.size;
       activePointers.delete(e.pointerId);
       pointerPositions.delete(e.pointerId);
@@ -13618,6 +13998,7 @@ function useGestureDispatcher(opts) {
       }, 0);
     };
     const onPointerCancel = (e) => {
+      cancelLongPress(e.pointerId);
       activePointers.delete(e.pointerId);
       pointerPositions.delete(e.pointerId);
       lastPointerDown.delete(e.pointerId);
@@ -13740,6 +14121,7 @@ function useGestureDispatcher(opts) {
       window.removeEventListener("paste", onPaste);
       canvas?.classList.remove(DROPOVER_CLASS);
       clearHoverCursor();
+      cancelAllLongPress();
       disposed = true;
       dispatcher.cancelAll("cancel");
     };
@@ -14552,7 +14934,7 @@ function textLineBoxes(pose, opts = {}) {
   }
   return out;
 }
-var cache4 = /* @__PURE__ */ new Map();
+var cache5 = /* @__PURE__ */ new Map();
 var subscribers2 = /* @__PURE__ */ new Set();
 var defaultLoader = async (src) => {
   if (typeof Image === "undefined" || typeof createImageBitmap === "undefined") {
@@ -14570,28 +14952,28 @@ function notify() {
 }
 function startLoad(src) {
   const entry = { status: "loading" };
-  cache4.set(src, entry);
+  cache5.set(src, entry);
   loader(src).then(
     (bitmap) => {
-      if (cache4.get(src) !== entry) return;
-      cache4.set(src, { status: "ready", bitmap });
+      if (cache5.get(src) !== entry) return;
+      cache5.set(src, { status: "ready", bitmap });
       notify();
     },
     () => {
-      if (cache4.get(src) !== entry) return;
-      cache4.set(src, { status: "error" });
+      if (cache5.get(src) !== entry) return;
+      cache5.set(src, { status: "error" });
       notify();
     }
   );
 }
 function getImageBitmap(src) {
-  const entry = cache4.get(src);
+  const entry = cache5.get(src);
   if (entry) return entry.bitmap;
   startLoad(src);
   return void 0;
 }
 function imageStatus(src) {
-  return cache4.get(src)?.status ?? "idle";
+  return cache5.get(src)?.status ?? "idle";
 }
 function subscribeImageReady(cb) {
   subscribers2.add(cb);
@@ -14685,6 +15067,13 @@ function shapeCoversPoint(node, pose, x, y, opts = {}) {
   const reach = ink.strokeWidth / 2 + (opts.tolerance ?? 0);
   return reach > 0 && strokeHitTest(sil, x, y, reach);
 }
+function withLeafStroke(style, stroke, strokeWidth) {
+  if (style?.stroke !== void 0) return style;
+  if (!stroke || stroke === "none") return style;
+  const width = strokeWidth ?? 1;
+  if (width <= 0) return style;
+  return { ...style, stroke: { paint: { color: stroke }, width } };
+}
 var TEXT_PAINTER = {
   id: "kit:text",
   matches: (node) => {
@@ -14703,7 +15092,8 @@ var TEXT_PAINTER = {
     const d = node.data;
     const p = pose;
     const y = p.y;
-    return d.runs && d.runs.length > 0 ? [textCommandFromRuns(p.x, y, d.runs, d.style, void 0, p.height)] : [textCommand(p.x, y, d.text, d.style, void 0, p.height)];
+    const style = withLeafStroke(d.style, d.stroke, d.strokeWidth);
+    return d.runs && d.runs.length > 0 ? [textCommandFromRuns(p.x, y, d.runs, style, void 0, p.height)] : [textCommand(p.x, y, d.text, style, void 0, p.height)];
   }),
   // The pose is a *wrap box*, not a bounding box — "Away" in a 300-unit box
   // leaves most of it empty, and a pose-rect silhouette claims all of it. The
@@ -16753,7 +17143,7 @@ function buildChromeState(args) {
     }
   };
 }
-var DEFAULT_ROTATION_HANDLE_DISTANCE = 24;
+var DEFAULT_ROTATION_HANDLE_DISTANCE = ROTATION_HANDLE_BASE_PX;
 function rotationHandle(pose, distance = DEFAULT_ROTATION_HANDLE_DISTANCE) {
   const rotation = pose.rotation ?? 0;
   const c = aabbCenter(pose);
@@ -16813,7 +17203,7 @@ var DEFAULT_HANDLE_OUTLINE = {
   paint: { fill: "solid", color: "#1a130d" },
   width: 1
 };
-var DEFAULT_HANDLE_SIZE = 8;
+var DEFAULT_HANDLE_SIZE = HANDLE_BASE_PX;
 function defaultHandlesOf(b) {
   return [
     { x: b.x, y: b.y },
@@ -20212,8 +20602,8 @@ var DEFAULT_FILL3 = "#d4c4a8";
 var DEFAULT_STROKE = "#1a130d";
 function createCornerResizeAffordance(opts = {}) {
   const {
-    handleHitRadius = 8,
-    handleSize = 8,
+    handleHitRadius = HANDLE_BASE_PX,
+    handleSize = HANDLE_BASE_PX,
     fill = DEFAULT_FILL3,
     stroke = DEFAULT_STROKE
   } = opts;
@@ -20351,8 +20741,8 @@ function createPathAnchorAffordances(getAnchorState, opts = {}) {
   };
   return [anchors, controls];
 }
-var HANDLE_HIT_RADIUS = 8;
-var ANCHOR_HIT_RADIUS = 8;
+var HANDLE_HIT_RADIUS = HANDLE_BASE_PX;
+var ANCHOR_HIT_RADIUS = ANCHOR_HIT_BASE_PX;
 function buildAffordanceAt(opts) {
   const {
     getChromeState,
@@ -21567,7 +21957,6 @@ function makeGetNodeAtPoint(pickEvery, nodeResolver) {
     return { id, kind, pose, data };
   };
 }
-var DEFAULT_HANDLE_SIZE2 = 8;
 var IS_DEV = (() => {
   try {
     return Boolean(import.meta.env?.DEV);
@@ -21586,10 +21975,10 @@ function recordCoordTrace(entry) {
   coordTrace.push(entry);
   if (coordTrace.length > COORD_TRACE_LIMIT) coordTrace.shift();
 }
-function mergeLayersWithDefaults(user) {
+function mergeLayersWithDefaults(user, targetScale = 1) {
   const defaults = {
     scene: { drawOne: defaultDrawOne },
-    selectionOverlay: { handles: { size: DEFAULT_HANDLE_SIZE2 } }
+    selectionOverlay: { handles: { size: HANDLE_BASE_PX * targetScale } }
   };
   if (!user) return defaults;
   const result = { ...user };
@@ -21677,8 +22066,10 @@ function SceneCanvasInner(props, ref) {
     chromeVisibility,
     getActiveMode,
     getFocused: getFocusedProp,
+    device,
     ...rest
   } = props;
+  const deviceProfile = useDeviceProfile(device);
   const isSerialized = (s) => typeof s === "object" && s != null && s.version === 1 && Array.isArray(s.nodes);
   const [bakedScene] = useState(
     () => isSerialized(sceneInput) ? sceneFromJSON(sceneInput, {}) : null
@@ -21796,7 +22187,7 @@ function SceneCanvasInner(props, ref) {
     }
   }), []);
   const selectToolWithDefaults = useMemo(() => ({
-    handleHitRadius: DEFAULT_HANDLE_SIZE2,
+    handleHitRadius: HANDLE_BASE_PX * deviceProfile.targetScale,
     // Shift-click belongs to the anchor selection while a path is being
     // anchor-edited; see `UseSelectToolOptions.extendClickLocked`.
     extendClickLocked: () => effectivePathEditingId() !== "",
@@ -21806,7 +22197,7 @@ function SceneCanvasInner(props, ref) {
     // pipeline (audit 3.4). The classifier is now `select.pick`, which
     // declares that capability itself — one rule, evaluated in one place.
     ...selectToolOpts
-  }), [selectToolOpts]);
+  }), [selectToolOpts, deviceProfile.targetScale]);
   const selectionRef = useRef(selection);
   selectionRef.current = selection;
   const kindClassifier = useMemo(() => {
@@ -21964,8 +22355,8 @@ function SceneCanvasInner(props, ref) {
     };
   }, [Boolean(onDoubleClick)]);
   const mergedLayers = useMemo(
-    () => mergeLayersWithDefaults(layers),
-    [layers]
+    () => mergeLayersWithDefaults(layers, deviceProfile.targetScale),
+    [layers, deviceProfile.targetScale]
   );
   const resolvedActions = useMemo(() => {
     if (selectToolOpts?.rotate !== false) return actions;
@@ -22024,6 +22415,8 @@ function SceneCanvasInner(props, ref) {
   chromeVisibilityRef.current = effectiveChromeVisibility;
   const getActiveModeRef = useRef(getActiveMode);
   getActiveModeRef.current = getActiveMode;
+  const deviceProfileRef = useRef(deviceProfile);
+  deviceProfileRef.current = deviceProfile;
   const resizablePredRef = useRef(selectToolOpts?.resize?.resizable);
   resizablePredRef.current = selectToolOpts?.resize?.resizable;
   const buildCurrentRuleCtx = useCallback(() => {
@@ -22045,7 +22438,8 @@ function SceneCanvasInner(props, ref) {
       mode: modeInfo.id,
       allowedCapabilities: modeInfo.allowedCapabilities,
       selectionResizable,
-      editingAnchors: effectivePathEditingId() !== ""
+      editingAnchors: effectivePathEditingId() !== "",
+      device: deviceProfileRef.current
     };
   }, [dispatcher, getHover]);
   const anchorEditingAllowed = useMemo(
@@ -22300,7 +22694,7 @@ function SceneCanvasInner(props, ref) {
       testHookRef.current?._markReady();
     }
   }, []);
-  return /* @__PURE__ */ jsx(DepRegistryProviderIfRoot, { children: /* @__PURE__ */ jsx(PointerProviderIfRoot, { children: /* @__PURE__ */ jsxs(ActionsProviderIfRoot, { children: [
+  return /* @__PURE__ */ jsx(DeviceProfileProvider, { value: device, children: /* @__PURE__ */ jsx(DepRegistryProviderIfRoot, { children: /* @__PURE__ */ jsx(PointerProviderIfRoot, { children: /* @__PURE__ */ jsxs(ActionsProviderIfRoot, { children: [
     canvas,
     /* @__PURE__ */ jsx(PointerPublisher, { canvasRef: internalCanvasRef, viewRef: currentViewRef }),
     /* @__PURE__ */ jsx(
@@ -22363,7 +22757,7 @@ function SceneCanvasInner(props, ref) {
       }
     ),
     children
-  ] }) }) });
+  ] }) }) }) });
 }
 function ToolKeybindingsMounter({
   internalTools,
@@ -23152,5 +23546,5 @@ function oklchToOklab(L, C, h) {
 }
 
 export { FALLBACK_FIT_VIEW, MinimapCanvas, SceneViewCanvas, UnknownIcon, buildSceneViewCommands, computeFitView2, computeIndicatorCommand, eligibleTool, evaluateEnabled, oklabToSrgbU8, oklchToOklab, renderSceneToCanvas, rgbaToHex, useActionsRegistry, useOptionalDepRegistry };
-//# sourceMappingURL=chunk-5XDFILHZ.js.map
-//# sourceMappingURL=chunk-5XDFILHZ.js.map
+//# sourceMappingURL=chunk-6V7ROR7G.js.map
+//# sourceMappingURL=chunk-6V7ROR7G.js.map