@pibbl/core 0.0.1

package/dist/lib/manipulation/controller.js

@@ -0,0 +1,464 @@
+import {
+  batch,
+  signal,
+  isSignal,
+  untracked,
+  assertSignalCommandAllowed,
+  assertDirectSignalWriteAllowed
+} from "../signals/graph.js";
+import { resolveSignalValue } from "../signals/resolve-signal-value.js";
+import { requireHookContext, useHookSlot } from "../hooks/hook-slot.js";
+import { queueBeginCommand } from "../scheduler/realm-scheduler.js";
+import {
+  observeGestureInputs,
+  claimGeometryGeneration,
+  restoreReleasedGesture
+} from "./ownership.js";
+import { suppressManipulationActivation } from "../events/dispatch.js";
+import { solveManipulation } from "./solve.js";
+import {
+  currentRootCoordinateMapping,
+  sameRootCoordinateMapping
+} from "./coordinates.js";
+const states = /* @__PURE__ */ new WeakMap();
+const owners = /* @__PURE__ */ new WeakMap();
+const claimedPresses = /* @__PURE__ */ new WeakSet();
+function manipulationState(controller) {
+  const state = states.get(controller);
+  if (!state || !state.alive)
+    throw new Error(
+      "Pibbl manipulation requires a live useManipulation controller."
+    );
+  return state;
+}
+function geometry(state) {
+  return untracked(
+    () => Object.freeze({
+      box: Object.freeze({ ...state.options.box.get() }),
+      rotation: state.options.rotation?.get() ?? 0
+    })
+  );
+}
+function same(a, b) {
+  return a.rotation === b.rotation && a.box.left === b.box.left && a.box.top === b.box.top && a.box.width === b.box.width && a.box.height === b.box.height;
+}
+function event(session) {
+  return Object.freeze({
+    ...session.snapshot,
+    before: session.before,
+    after: session.last
+  });
+}
+function publish(state, next) {
+  assertDirectSignalWriteAllowed(state.options.box);
+  if (state.options.rotation)
+    assertDirectSignalWriteAllowed(state.options.rotation);
+  batch(() => {
+    state.options.box.set(next.box);
+    if (state.options.rotation) state.options.rotation.set(next.rotation);
+  });
+}
+function release(state, session) {
+  if (state.session !== session) return;
+  state.session = void 0;
+  session.releaseObservation?.();
+  session.releaseObservation = void 0;
+  if (state.options.rotation && owners.get(state.options.rotation) === state)
+    owners.delete(state.options.rotation);
+  if (owners.get(state.options.box) === state) owners.delete(state.options.box);
+  if (session.target.hasPointerCapture(session.pointerId))
+    session.target.releasePointerCapture(session.pointerId);
+}
+function cancel(state, reason) {
+  const session = state.session;
+  if (!session) return;
+  const restore = same(geometry(state), session.last) && reason !== "external-change";
+  release(state, session);
+  batch(() => {
+    if (restore && session.started) publish(state, session.before);
+    state.active.set(null);
+  });
+  if (session.started)
+    state.options.onCancel?.(
+      Object.freeze({ ...event(session), after: geometry(state), reason })
+    );
+}
+function detachManipulationFrame(state) {
+  const session = state.session;
+  if (!session) return;
+  const restore = same(geometry(state), session.last);
+  release(state, session);
+  restoreReleasedGesture({
+    box: state.options.box,
+    rotation: state.options.rotation,
+    before: restore ? session.before : geometry(state),
+    active: state.active
+  });
+}
+function dispose(state) {
+  if (!state.alive) return;
+  state.alive = false;
+  detachManipulationFrame(state);
+}
+function useManipulation(options) {
+  const { pibblInstance } = requireHookContext();
+  const slot = useHookSlot("manipulation", (teardowns) => {
+    const state2 = {
+      options,
+      root: pibblInstance.eventRoot.rootInstance ?? pibblInstance,
+      alive: true,
+      parent: new DOMMatrix(),
+      active: signal(null),
+      snapshot: signal(null)
+    };
+    const controller = Object.freeze({
+      active: state2.active.asReadonly(),
+      snapshot: state2.snapshot.asReadonly(),
+      get frameProps() {
+        return frameProps;
+      },
+      cancel() {
+        if (state2.alive) {
+          assertSignalCommandAllowed();
+          cancel(state2, "explicit");
+        }
+      }
+    });
+    const frameProps = Object.freeze({ controller, style: options.box });
+    state2.controller = controller;
+    states.set(controller, state2);
+    teardowns.add(() => dispose(state2));
+    return state2;
+  });
+  const state = slot.value;
+  if (options.rotate && !options.rotation)
+    throw new Error(
+      "useManipulation rotate requires a writable rotation signal in radians."
+    );
+  if (options.box !== state.options.box || options.rotation !== state.options.rotation)
+    throw new Error(
+      "useManipulation geometry signal identity must remain stable."
+    );
+  state.options = options;
+  if (state.session && !enabled(state, state.session.operation)) {
+    const session = state.session;
+    queueBeginCommand(() => {
+      if (state.alive && state.session === session) cancel(state, "disabled");
+    });
+  }
+  return state.controller;
+}
+function enabled(state, operation) {
+  const options = operation === "move" ? state.options.move : operation === "resize" ? state.options.resize : state.options.rotate;
+  return options !== void 0 && resolveSignalValue(options.enabled ?? true);
+}
+function validateSession(state) {
+  const session = state.session;
+  if (!session) return;
+  if (!same(geometry(state), session.last)) {
+    cancel(state, "external-change");
+    return;
+  }
+  if (!enabled(state, session.operation)) {
+    cancel(state, "disabled");
+    return;
+  }
+  if (!sameRootCoordinateMapping(
+    session.coordinateMapping,
+    currentRootCoordinateMapping(state.root)
+  ) || state.coordinateMapping !== void 0 && !sameRootCoordinateMapping(
+    session.coordinateMapping,
+    state.coordinateMapping
+  )) {
+    cancel(state, "coordinate-space-changed");
+    return;
+  }
+  if (["a", "b", "c", "d", "e", "f"].some(
+    (key) => Math.abs(state.parent[key] - session.parent[key]) > 1e-10 * Math.max(
+      1,
+      Math.abs(state.parent[key]),
+      Math.abs(session.parent[key])
+    )
+  )) {
+    cancel(state, "coordinate-space-changed");
+    return;
+  }
+  return session;
+}
+function resolvedOptions(state) {
+  const options = state.options;
+  const move = options.move && {
+    ...options.move,
+    snap: options.move.snap && {
+      ...options.move.snap,
+      enabled: resolveSignalValue(options.move.snap.enabled ?? true)
+    }
+  };
+  const resize = options.resize && {
+    ...options.resize,
+    snap: options.resize.snap && {
+      ...options.resize.snap,
+      enabled: resolveSignalValue(options.resize.snap.enabled ?? true)
+    }
+  };
+  const rotate = options.rotate && {
+    ...options.rotate,
+    snap: options.rotate.snap && {
+      ...options.rotate.snap,
+      enabled: resolveSignalValue(options.rotate.snap.enabled ?? true)
+    }
+  };
+  return { move, resize, rotate };
+}
+function apply(state, pointer) {
+  const session = validateSession(state);
+  if (!session || pointer.pointerId !== session.pointerId) return;
+  session.sample = {
+    pointerId: pointer.pointerId,
+    x: pointer.x,
+    y: pointer.y,
+    clientX: pointer.clientX,
+    clientY: pointer.clientY,
+    shiftKey: pointer.shiftKey,
+    altKey: pointer.altKey,
+    ctrlKey: pointer.ctrlKey,
+    metaKey: pointer.metaKey
+  };
+  if (!session.started) {
+    if (Math.hypot(
+      pointer.clientX - session.clientX,
+      pointer.clientY - session.clientY
+    ) < 3)
+      return;
+    session.started = true;
+    suppressManipulationActivation(state.root, session.pointerId);
+    state.active.set(
+      Object.freeze({
+        operation: session.operation,
+        handle: session.handle ?? null,
+        pointerId: session.pointerId
+      })
+    );
+    state.options.onStart?.(event(session));
+    if (validateSession(state) !== session) return;
+  }
+  const { move, resize, rotate } = resolvedOptions(state);
+  const currentPoint = session.parent.inverse().transformPoint(new DOMPoint(pointer.x, pointer.y));
+  if (session.operation === "rotate") {
+    const centerX = session.before.box.left + session.before.box.width / 2;
+    const centerY = session.before.box.top + session.before.box.height / 2;
+    if (currentPoint.x !== centerX || currentPoint.y !== centerY) {
+      const angle = Math.atan2(
+        currentPoint.y - centerY,
+        currentPoint.x - centerX
+      );
+      const delta = angle - session.angle;
+      session.rotationDelta += Math.atan2(Math.sin(delta), Math.cos(delta));
+      session.angle = angle;
+    }
+  }
+  let result;
+  try {
+    result = solveManipulation({
+      operation: session.operation,
+      handle: session.handle,
+      initial: session.before.box,
+      initialPoint: session.point,
+      currentPoint,
+      initialRotation: session.before.rotation,
+      rotationDelta: session.rotationDelta,
+      modifiers: {
+        shift: pointer.shiftKey,
+        alt: pointer.altKey,
+        ctrl: pointer.ctrlKey,
+        meta: pointer.metaKey
+      },
+      move,
+      resize,
+      rotate
+    });
+  } catch {
+    cancel(state, "constraints-unsatisfiable");
+    return;
+  }
+  const next = Object.freeze({
+    box: result.applied,
+    rotation: result.appliedRotation
+  });
+  const changed = !same(next, session.last);
+  session.last = next;
+  session.snapshot = Object.freeze({
+    operation: session.operation,
+    handle: session.handle ?? null,
+    initial: session.before,
+    proposed: Object.freeze({
+      box: result.proposed,
+      rotation: result.proposedRotation
+    }),
+    applied: next,
+    snapActive: result.snapActive,
+    snapSatisfied: result.snapSatisfied
+  });
+  batch(() => {
+    if (changed) publish(state, next);
+    state.snapshot.set(session.snapshot);
+  });
+  if (validateSession(state) !== session) return;
+  if (changed) state.options.onChange?.(event(session));
+}
+function applySafely(state, pointer) {
+  try {
+    apply(state, pointer);
+  } catch (error) {
+    try {
+      cancel(state, "explicit");
+    } catch (cleanupError) {
+      throw new AggregateError(
+        [error, cleanupError],
+        "Manipulation callback and cleanup failed.",
+        { cause: cleanupError }
+      );
+    }
+    throw error;
+  }
+}
+function updateModifiers(state, key) {
+  const sample = state.session?.sample;
+  if (!sample || !["Shift", "Alt", "Control", "Meta"].includes(key.key)) return;
+  applySafely(state, {
+    ...sample,
+    shiftKey: key.shiftKey,
+    altKey: key.altKey,
+    ctrlKey: key.ctrlKey,
+    metaKey: key.metaKey
+  });
+}
+function isManipulationSourceActive(controller, source) {
+  const state = manipulationState(controller);
+  return state.session?.started === true && state.session.source === source;
+}
+function manipulationHandlers(controller, operation, handle, source) {
+  const state = manipulationState(controller);
+  return {
+    onPointerDown(pointer) {
+      if (!state.alive || state.session || pointer.defaultPrevented || claimedPresses.has(pointer.originalEvent) || pointer.button !== 0 || !enabled(state, operation))
+        return;
+      if (owners.has(state.options.box) || state.options.rotation && owners.has(state.options.rotation))
+        throw new Error(
+          "Pibbl manipulation geometry already has an active owner."
+        );
+      const before = geometry(state);
+      const point = state.parent.inverse().transformPoint(new DOMPoint(pointer.x, pointer.y));
+      if (!Number.isFinite(point.x) || !Number.isFinite(point.y))
+        throw new Error(
+          "Pibbl manipulation cannot use a singular parent transform."
+        );
+      assertDirectSignalWriteAllowed(state.options.box);
+      if (state.options.rotation)
+        assertDirectSignalWriteAllowed(state.options.rotation);
+      const resolved = resolvedOptions(state);
+      if (operation === "resize" && resolved.resize?.snap?.target === "grid" && (Math.abs(state.parent.b) > 1e-10 || Math.abs(state.parent.c) > 1e-10)) {
+        throw new Error(
+          "Grid resize snapping requires an aligned parent coordinate mapping."
+        );
+      }
+      solveManipulation({
+        operation,
+        handle,
+        initial: before.box,
+        initialRotation: before.rotation,
+        initialPoint: point,
+        currentPoint: point,
+        modifiers: {},
+        ...resolved
+      });
+      pointer.currentTarget.setPointerCapture(pointer.pointerId);
+      if (!pointer.currentTarget.hasPointerCapture(pointer.pointerId)) return;
+      const snapshot = Object.freeze({
+        operation,
+        handle: handle ?? null,
+        initial: before,
+        proposed: before,
+        applied: before,
+        snapActive: false,
+        snapSatisfied: false
+      });
+      state.session = {
+        operation,
+        handle,
+        pointerId: pointer.pointerId,
+        target: pointer.currentTarget,
+        before,
+        last: before,
+        point,
+        clientX: pointer.clientX,
+        clientY: pointer.clientY,
+        parent: DOMMatrix.fromMatrix(state.parent),
+        started: false,
+        angle: Math.atan2(
+          point.y - before.box.top - before.box.height / 2,
+          point.x - before.box.left - before.box.width / 2
+        ),
+        rotationDelta: 0,
+        snapshot,
+        coordinateMapping: currentRootCoordinateMapping(state.root),
+        source
+      };
+      owners.set(state.options.box, state);
+      if (state.options.rotation) owners.set(state.options.rotation, state);
+      claimGeometryGeneration(state.options.box, state.options.rotation);
+      const operationOptions = operation === "move" ? state.options.move : operation === "resize" ? state.options.resize : state.options.rotate;
+      const values = [
+        state.options.box,
+        state.options.rotation,
+        operationOptions?.enabled
+      ];
+      const inputs = values.filter(isSignal);
+      state.session.releaseObservation = observeGestureInputs(inputs, () => {
+        validateSession(state);
+      });
+      claimedPresses.add(pointer.originalEvent);
+    },
+    onPointerMove(pointer) {
+      applySafely(state, pointer);
+    },
+    onPointerUp(pointer) {
+      if (state.session?.pointerId !== pointer.pointerId) return;
+      applySafely(state, pointer);
+      const session = state.session;
+      if (!session) return;
+      release(state, session);
+      state.active.set(null);
+      if (session.started)
+        state.options.onCommit?.(
+          Object.freeze({
+            ...event(session),
+            changed: !same(session.before, session.last)
+          })
+        );
+    },
+    onPointerCancel(pointer) {
+      if (state.session?.pointerId === pointer.pointerId)
+        cancel(state, "pointer-cancel");
+    },
+    onLostPointerCapture(pointer) {
+      if (state.session?.pointerId === pointer.pointerId)
+        cancel(state, "capture-lost");
+    },
+    onKeyUp(key) {
+      updateModifiers(state, key);
+    },
+    onKeyDown(key) {
+      if (key.key === "Escape") cancel(state, "escape");
+      else updateModifiers(state, key);
+    }
+  };
+}
+export {
+  detachManipulationFrame,
+  isManipulationSourceActive,
+  manipulationHandlers,
+  manipulationState,
+  useManipulation
+};
+//# sourceMappingURL=controller.js.map

package/dist/lib/manipulation/controller.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/manipulation/controller.ts"],
+  "sourcesContent": ["import {\n  batch,\n  signal,\n  isSignal,\n  untracked,\n  assertSignalCommandAllowed,\n  assertDirectSignalWriteAllowed,\n} from \"../signals/graph.js\";\nimport { resolveSignalValue } from \"../signals/resolve-signal-value.js\";\nimport { requireHookContext, useHookSlot } from \"../hooks/hook-slot.js\";\nimport { queueBeginCommand } from \"../scheduler/realm-scheduler.js\";\nimport type {\n  PibblEventHandlers,\n  PibblEventTarget,\n  PibblPointerEvent,\n  PibblKeyboardEvent,\n} from \"../events/types.js\";\nimport type { PibblComponentRefs, PibblInstance } from \"../types.js\";\nimport type { WritableSignal } from \"../signals/types.js\";\nimport {\n  observeGestureInputs,\n  claimGeometryGeneration,\n  restoreReleasedGesture,\n} from \"./ownership.js\";\nimport { suppressManipulationActivation } from \"../events/dispatch.js\";\nimport { solveManipulation } from \"./solve.js\";\nimport {\n  currentRootCoordinateMapping,\n  sameRootCoordinateMapping,\n} from \"./coordinates.js\";\nimport type { PibblResizePosition } from \"./types.js\";\nimport type {\n  PibblManipulationActive,\n  PibblManipulationCancelReason,\n  PibblManipulationController,\n  PibblManipulationEvent,\n  PibblManipulationGeometry,\n  PibblManipulationOperation,\n  PibblManipulationOptions,\n  PibblManipulationSnapshot,\n} from \"./controller-types.js\";\n\ntype PointerSample = Pick<\n  PibblPointerEvent,\n  | \"pointerId\"\n  | \"x\"\n  | \"y\"\n  | \"clientX\"\n  | \"clientY\"\n  | \"shiftKey\"\n  | \"altKey\"\n  | \"ctrlKey\"\n  | \"metaKey\"\n>;\ninterface Session {\n  operation: PibblManipulationOperation;\n  handle?: PibblResizePosition;\n  pointerId: number;\n  target: PibblEventTarget;\n  before: PibblManipulationGeometry;\n  last: PibblManipulationGeometry;\n  point: DOMPoint;\n  clientX: number;\n  clientY: number;\n  parent: DOMMatrix;\n  started: boolean;\n  angle: number;\n  rotationDelta: number;\n  snapshot: PibblManipulationSnapshot;\n  coordinateMapping: readonly number[];\n  source?: object;\n  releaseObservation?: () => void;\n  sample?: PointerSample;\n}\nexport interface ManipulationState {\n  controller: PibblManipulationController;\n  options: PibblManipulationOptions;\n  alive: boolean;\n  root: PibblInstance;\n  frame?: PibblComponentRefs<any>;\n  parent: DOMMatrix;\n  coordinateMapping?: readonly number[];\n  session?: Session;\n  active: WritableSignal<PibblManipulationActive | null>;\n  snapshot: WritableSignal<PibblManipulationSnapshot | null>;\n}\nconst states = new WeakMap<PibblManipulationController, ManipulationState>();\nconst owners = new WeakMap<object, ManipulationState>();\nconst claimedPresses = new WeakSet<Event>();\nexport function manipulationState(\n  controller: PibblManipulationController,\n): ManipulationState {\n  const state = states.get(controller);\n  if (!state || !state.alive)\n    throw new Error(\n      \"Pibbl manipulation requires a live useManipulation controller.\",\n    );\n  return state;\n}\nfunction geometry(state: ManipulationState): PibblManipulationGeometry {\n  return untracked(() =>\n    Object.freeze({\n      box: Object.freeze({ ...state.options.box.get() }),\n      rotation: state.options.rotation?.get() ?? 0,\n    }),\n  );\n}\nfunction same(a: PibblManipulationGeometry, b: PibblManipulationGeometry): boolean {\n  return (\n    a.rotation === b.rotation &&\n    a.box.left === b.box.left &&\n    a.box.top === b.box.top &&\n    a.box.width === b.box.width &&\n    a.box.height === b.box.height\n  );\n}\nfunction event(session: Session): PibblManipulationEvent {\n  return Object.freeze({\n    ...session.snapshot,\n    before: session.before,\n    after: session.last,\n  });\n}\nfunction publish(\n  state: ManipulationState,\n  next: PibblManipulationGeometry,\n): void {\n  assertDirectSignalWriteAllowed(state.options.box);\n  if (state.options.rotation)\n    assertDirectSignalWriteAllowed(state.options.rotation);\n  batch(() => {\n    state.options.box.set(next.box);\n    if (state.options.rotation) state.options.rotation.set(next.rotation);\n  });\n}\nfunction release(state: ManipulationState, session: Session): void {\n  if (state.session !== session) return;\n  state.session = undefined;\n  session.releaseObservation?.();\n  session.releaseObservation = undefined;\n  if (state.options.rotation && owners.get(state.options.rotation) === state)\n    owners.delete(state.options.rotation);\n  if (owners.get(state.options.box) === state) owners.delete(state.options.box);\n  if (session.target.hasPointerCapture(session.pointerId))\n    session.target.releasePointerCapture(session.pointerId);\n}\nfunction cancel(\n  state: ManipulationState,\n  reason: PibblManipulationCancelReason,\n): void {\n  const session = state.session;\n  if (!session) return;\n  const restore =\n    same(geometry(state), session.last) && reason !== \"external-change\";\n  release(state, session);\n  batch(() => {\n    if (restore && session.started) publish(state, session.before);\n    state.active.set(null);\n  });\n  if (session.started)\n    state.options.onCancel?.(\n      Object.freeze({ ...event(session), after: geometry(state), reason }),\n    );\n}\n/** Release capture synchronously; rollback can defer under renderer write guards. */\nexport function detachManipulationFrame(state: ManipulationState): void {\n  const session = state.session;\n  if (!session) return;\n  const restore = same(geometry(state), session.last);\n  release(state, session);\n  restoreReleasedGesture({\n    box: state.options.box,\n    rotation: state.options.rotation,\n    before: restore ? session.before : geometry(state),\n    active: state.active,\n  });\n}\nfunction dispose(state: ManipulationState): void {\n  if (!state.alive) return;\n  state.alive = false;\n  detachManipulationFrame(state);\n}\n/**\n * Creates a mount-owned controller for moving, resizing, and rotating declared geometry.\n *\n * @param options - Target state, enabled operations, constraints, and lifecycle callbacks. See\n * {@link PibblManipulationOptions} .\n * @returns Stable controls and state for the mounted manipulation interaction. See\n * {@link PibblManipulationController} .\n *\n * @see {@link PibblManipulationOptions}\n * @see {@link PibblManipulationController}\n */\nexport function useManipulation(\n  options: PibblManipulationOptions,\n): PibblManipulationController {\n  const { pibblInstance } = requireHookContext();\n  const slot = useHookSlot<ManipulationState>(\"manipulation\", (teardowns) => {\n    const state = {\n      options,\n      root: pibblInstance.eventRoot.rootInstance ?? pibblInstance,\n      alive: true,\n      parent: new DOMMatrix(),\n      active: signal<PibblManipulationActive | null>(null),\n      snapshot: signal<PibblManipulationSnapshot | null>(null),\n    } as ManipulationState;\n    const controller: PibblManipulationController = Object.freeze({\n      active: state.active.asReadonly(),\n      snapshot: state.snapshot.asReadonly(),\n      get frameProps() {\n        return frameProps;\n      },\n      cancel() {\n        if (state.alive) {\n          assertSignalCommandAllowed();\n          cancel(state, \"explicit\");\n        }\n      },\n    });\n    const frameProps = Object.freeze({ controller, style: options.box });\n    state.controller = controller;\n    states.set(controller, state);\n    teardowns.add(() => dispose(state));\n    return state;\n  });\n  const state = slot.value;\n  if (options.rotate && !options.rotation)\n    throw new Error(\n      \"useManipulation rotate requires a writable rotation signal in radians.\",\n    );\n  if (\n    options.box !== state.options.box ||\n    options.rotation !== state.options.rotation\n  )\n    throw new Error(\n      \"useManipulation geometry signal identity must remain stable.\",\n    );\n  state.options = options;\n  if (state.session && !enabled(state, state.session.operation)) {\n    const session = state.session;\n    queueBeginCommand(() => {\n      if (state.alive && state.session === session) cancel(state, \"disabled\");\n    });\n  }\n  return state.controller;\n}\nfunction enabled(\n  state: ManipulationState,\n  operation: PibblManipulationOperation,\n): boolean {\n  const options =\n    operation === \"move\"\n      ? state.options.move\n      : operation === \"resize\"\n        ? state.options.resize\n        : state.options.rotate;\n  return options !== undefined && resolveSignalValue(options.enabled ?? true);\n}\nfunction validateSession(state: ManipulationState): Session | undefined {\n  const session = state.session;\n  if (!session) return;\n  if (!same(geometry(state), session.last)) {\n    cancel(state, \"external-change\");\n    return;\n  }\n  if (!enabled(state, session.operation)) {\n    cancel(state, \"disabled\");\n    return;\n  }\n  if (\n    !sameRootCoordinateMapping(\n      session.coordinateMapping,\n      currentRootCoordinateMapping(state.root),\n    ) ||\n    (state.coordinateMapping !== undefined &&\n      !sameRootCoordinateMapping(\n        session.coordinateMapping,\n        state.coordinateMapping,\n      ))\n  ) {\n    cancel(state, \"coordinate-space-changed\");\n    return;\n  }\n  if (\n    [\"a\", \"b\", \"c\", \"d\", \"e\", \"f\"].some(\n      (key) =>\n        Math.abs(state.parent[key as \"a\"] - session.parent[key as \"a\"]) >\n        1e-10 *\n          Math.max(\n            1,\n            Math.abs(state.parent[key as \"a\"]),\n            Math.abs(session.parent[key as \"a\"]),\n          ),\n    )\n  ) {\n    cancel(state, \"coordinate-space-changed\");\n    return;\n  }\n  return session;\n}\nfunction resolvedOptions(state: ManipulationState) {\n  const options = state.options;\n  const move = options.move && {\n    ...options.move,\n    snap: options.move.snap && {\n      ...options.move.snap,\n      enabled: resolveSignalValue(options.move.snap.enabled ?? true),\n    },\n  };\n  const resize = options.resize && {\n    ...options.resize,\n    snap: options.resize.snap && {\n      ...options.resize.snap,\n      enabled: resolveSignalValue(options.resize.snap.enabled ?? true),\n    },\n  };\n  const rotate = options.rotate && {\n    ...options.rotate,\n    snap: options.rotate.snap && {\n      ...options.rotate.snap,\n      enabled: resolveSignalValue(options.rotate.snap.enabled ?? true),\n    },\n  };\n  return { move, resize, rotate };\n}\nfunction apply(state: ManipulationState, pointer: PointerSample): void {\n  const session = validateSession(state);\n  if (!session || pointer.pointerId !== session.pointerId) return;\n  session.sample = {\n    pointerId: pointer.pointerId,\n    x: pointer.x,\n    y: pointer.y,\n    clientX: pointer.clientX,\n    clientY: pointer.clientY,\n    shiftKey: pointer.shiftKey,\n    altKey: pointer.altKey,\n    ctrlKey: pointer.ctrlKey,\n    metaKey: pointer.metaKey,\n  };\n  if (!session.started) {\n    if (\n      Math.hypot(\n        pointer.clientX - session.clientX,\n        pointer.clientY - session.clientY,\n      ) < 3\n    )\n      return;\n    session.started = true;\n    suppressManipulationActivation(state.root, session.pointerId);\n    state.active.set(\n      Object.freeze({\n        operation: session.operation,\n        handle: session.handle ?? null,\n        pointerId: session.pointerId,\n      }),\n    );\n    state.options.onStart?.(event(session));\n    if (validateSession(state) !== session) return;\n  }\n  const { move, resize, rotate } = resolvedOptions(state);\n  const currentPoint = session.parent\n    .inverse()\n    .transformPoint(new DOMPoint(pointer.x, pointer.y));\n  if (session.operation === \"rotate\") {\n    const centerX = session.before.box.left + session.before.box.width / 2;\n    const centerY = session.before.box.top + session.before.box.height / 2;\n    if (currentPoint.x !== centerX || currentPoint.y !== centerY) {\n      const angle = Math.atan2(\n        currentPoint.y - centerY,\n        currentPoint.x - centerX,\n      );\n      const delta = angle - session.angle;\n      session.rotationDelta += Math.atan2(Math.sin(delta), Math.cos(delta));\n      session.angle = angle;\n    }\n  }\n  let result: ReturnType<typeof solveManipulation>;\n  try {\n    result = solveManipulation({\n      operation: session.operation,\n      handle: session.handle,\n      initial: session.before.box,\n      initialPoint: session.point,\n      currentPoint,\n      initialRotation: session.before.rotation,\n      rotationDelta: session.rotationDelta,\n      modifiers: {\n        shift: pointer.shiftKey,\n        alt: pointer.altKey,\n        ctrl: pointer.ctrlKey,\n        meta: pointer.metaKey,\n      },\n      move,\n      resize,\n      rotate,\n    });\n  } catch {\n    // Options can change after activation; the original preview still belongs\n    // to this gesture and must be restored through the normal terminal path.\n    cancel(state, \"constraints-unsatisfiable\");\n    return;\n  }\n  const next = Object.freeze({\n    box: result.applied,\n    rotation: result.appliedRotation,\n  });\n  const changed = !same(next, session.last);\n  session.last = next;\n  session.snapshot = Object.freeze({\n    operation: session.operation,\n    handle: session.handle ?? null,\n    initial: session.before,\n    proposed: Object.freeze({\n      box: result.proposed,\n      rotation: result.proposedRotation,\n    }),\n    applied: next,\n    snapActive: result.snapActive,\n    snapSatisfied: result.snapSatisfied,\n  });\n  batch(() => {\n    if (changed) publish(state, next);\n    state.snapshot.set(session.snapshot);\n  });\n  if (validateSession(state) !== session) return;\n  if (changed) state.options.onChange?.(event(session));\n}\nfunction applySafely(state: ManipulationState, pointer: PointerSample): void {\n  try {\n    apply(state, pointer);\n  } catch (error) {\n    try {\n      cancel(state, \"explicit\");\n    } catch (cleanupError) {\n      throw new AggregateError(\n        [error, cleanupError],\n        \"Manipulation callback and cleanup failed.\",\n        { cause: cleanupError },\n      );\n    }\n    throw error;\n  }\n}\nfunction updateModifiers(\n  state: ManipulationState,\n  key: PibblKeyboardEvent,\n): void {\n  const sample = state.session?.sample;\n  if (!sample || ![\"Shift\", \"Alt\", \"Control\", \"Meta\"].includes(key.key)) return;\n  applySafely(state, {\n    ...sample,\n    shiftKey: key.shiftKey,\n    altKey: key.altKey,\n    ctrlKey: key.ctrlKey,\n    metaKey: key.metaKey,\n  });\n}\n\n/** @internal Identifies one private handle source for readout presentation. */\nexport function isManipulationSourceActive(\n  controller: PibblManipulationController,\n  source: object,\n): boolean {\n  const state = manipulationState(controller);\n  return state.session?.started === true && state.session.source === source;\n}\n\nexport function manipulationHandlers(\n  controller: PibblManipulationController,\n  operation: PibblManipulationOperation,\n  handle?: PibblResizePosition,\n  source?: object,\n): PibblEventHandlers {\n  const state = manipulationState(controller);\n  return {\n    onPointerDown(pointer) {\n      if (\n        !state.alive ||\n        state.session ||\n        pointer.defaultPrevented ||\n        claimedPresses.has(pointer.originalEvent) ||\n        pointer.button !== 0 ||\n        !enabled(state, operation)\n      )\n        return;\n      if (\n        owners.has(state.options.box) ||\n        (state.options.rotation && owners.has(state.options.rotation))\n      )\n        throw new Error(\n          \"Pibbl manipulation geometry already has an active owner.\",\n        );\n      const before = geometry(state);\n      const point = state.parent\n        .inverse()\n        .transformPoint(new DOMPoint(pointer.x, pointer.y));\n      if (!Number.isFinite(point.x) || !Number.isFinite(point.y))\n        throw new Error(\n          \"Pibbl manipulation cannot use a singular parent transform.\",\n        );\n      assertDirectSignalWriteAllowed(state.options.box);\n      if (state.options.rotation)\n        assertDirectSignalWriteAllowed(state.options.rotation);\n      const resolved = resolvedOptions(state);\n      if (\n        operation === \"resize\" &&\n        resolved.resize?.snap?.target === \"grid\" &&\n        (Math.abs(state.parent.b) > 1e-10 || Math.abs(state.parent.c) > 1e-10)\n      ) {\n        throw new Error(\n          \"Grid resize snapping requires an aligned parent coordinate mapping.\",\n        );\n      }\n      solveManipulation({\n        operation,\n        handle,\n        initial: before.box,\n        initialRotation: before.rotation,\n        initialPoint: point,\n        currentPoint: point,\n        modifiers: {},\n        ...resolved,\n      });\n      pointer.currentTarget.setPointerCapture(pointer.pointerId);\n      if (!pointer.currentTarget.hasPointerCapture(pointer.pointerId)) return;\n      const snapshot = Object.freeze({\n        operation,\n        handle: handle ?? null,\n        initial: before,\n        proposed: before,\n        applied: before,\n        snapActive: false,\n        snapSatisfied: false,\n      });\n      state.session = {\n        operation,\n        handle,\n        pointerId: pointer.pointerId,\n        target: pointer.currentTarget,\n        before,\n        last: before,\n        point,\n        clientX: pointer.clientX,\n        clientY: pointer.clientY,\n        parent: DOMMatrix.fromMatrix(state.parent),\n        started: false,\n        angle: Math.atan2(\n          point.y - before.box.top - before.box.height / 2,\n          point.x - before.box.left - before.box.width / 2,\n        ),\n        rotationDelta: 0,\n        snapshot,\n        coordinateMapping: currentRootCoordinateMapping(state.root),\n        source,\n      };\n      owners.set(state.options.box, state);\n      if (state.options.rotation) owners.set(state.options.rotation, state);\n      claimGeometryGeneration(state.options.box, state.options.rotation);\n      const operationOptions =\n        operation === \"move\"\n          ? state.options.move\n          : operation === \"resize\"\n            ? state.options.resize\n            : state.options.rotate;\n      const values: unknown[] = [\n        state.options.box,\n        state.options.rotation,\n        operationOptions?.enabled,\n      ];\n      const inputs = values.filter(isSignal);\n      state.session.releaseObservation = observeGestureInputs(inputs, () => {\n        validateSession(state);\n      });\n      claimedPresses.add(pointer.originalEvent);\n    },\n    onPointerMove(pointer) {\n      applySafely(state, pointer);\n    },\n    onPointerUp(pointer) {\n      if (state.session?.pointerId !== pointer.pointerId) return;\n      applySafely(state, pointer);\n      const session = state.session;\n      if (!session) return;\n      release(state, session);\n      state.active.set(null);\n      if (session.started)\n        state.options.onCommit?.(\n          Object.freeze({\n            ...event(session),\n            changed: !same(session.before, session.last),\n          }),\n        );\n    },\n    onPointerCancel(pointer) {\n      if (state.session?.pointerId === pointer.pointerId)\n        cancel(state, \"pointer-cancel\");\n    },\n    onLostPointerCapture(pointer) {\n      if (state.session?.pointerId === pointer.pointerId)\n        cancel(state, \"capture-lost\");\n    },\n    onKeyUp(key) {\n      updateModifiers(state, key);\n    },\n    onKeyDown(key) {\n      if (key.key === \"Escape\") cancel(state, \"escape\");\n      else updateModifiers(state, key);\n    },\n  };\n}\n"],
+  "mappings": "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",
+  "names": ["state"]
+}

package/dist/lib/manipulation/coordinates.d.ts

@@ -0,0 +1,9 @@
+import type { PibblInstance } from "../types.js";
+/**
+ * Captures every input that maps a browser pointer into root-logical space.
+ *
+ * The content box comes from the live canvas because a stylesheet can change it
+ * before the next root surface commit updates the cached surface snapshot.
+ */
+export declare function currentRootCoordinateMapping(root: PibblInstance): readonly number[];
+export declare function sameRootCoordinateMapping(left: readonly number[] | undefined, right: readonly number[] | undefined): boolean;

package/dist/lib/manipulation/coordinates.js

@@ -0,0 +1,55 @@
+import { getSurfaceSnapshot } from "../surface/transform.js";
+function currentRootCoordinateMapping(root) {
+  const surface = getSurfaceSnapshot(root);
+  const [contentLeft, contentTop, contentWidth, contentHeight] = currentCanvasContentBox(
+    root.canvas,
+    surface.displayWidth,
+    surface.displayHeight
+  );
+  const inverse = surface.inverseRenderTransform;
+  return Object.freeze([
+    contentLeft,
+    contentTop,
+    contentWidth,
+    contentHeight,
+    surface.backingPixelsPerCssPixelX,
+    surface.backingPixelsPerCssPixelY,
+    surface.backingWidth,
+    surface.backingHeight,
+    surface.logicalWidth,
+    surface.logicalHeight,
+    inverse.a,
+    inverse.b,
+    inverse.c,
+    inverse.d,
+    inverse.e,
+    inverse.f
+  ]);
+}
+function sameRootCoordinateMapping(left, right) {
+  return left !== void 0 && right !== void 0 && left.length === right.length && left.every((value, index) => Object.is(value, right[index]));
+}
+function currentCanvasContentBox(canvas, fallbackWidth, fallbackHeight) {
+  if (typeof HTMLCanvasElement === "undefined" || !(canvas instanceof HTMLCanvasElement))
+    return [0, 0, fallbackWidth, fallbackHeight];
+  const bounds = canvas.getBoundingClientRect();
+  const style = getComputedStyle(canvas);
+  const leftInset = px(style.borderLeftWidth) + px(style.paddingLeft);
+  const topInset = px(style.borderTopWidth) + px(style.paddingTop);
+  const rightInset = px(style.borderRightWidth) + px(style.paddingRight);
+  const bottomInset = px(style.borderBottomWidth) + px(style.paddingBottom);
+  return [
+    bounds.left + leftInset,
+    bounds.top + topInset,
+    Math.max(0, bounds.width - leftInset - rightInset),
+    Math.max(0, bounds.height - topInset - bottomInset)
+  ];
+}
+function px(value) {
+  return Number.parseFloat(value) || 0;
+}
+export {
+  currentRootCoordinateMapping,
+  sameRootCoordinateMapping
+};
+//# sourceMappingURL=coordinates.js.map

package/dist/lib/manipulation/coordinates.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/manipulation/coordinates.ts"],
+  "sourcesContent": ["import { getSurfaceSnapshot } from \"../surface/transform.js\";\nimport type { PibblInstance } from \"../types.js\";\n\n/**\n * Captures every input that maps a browser pointer into root-logical space.\n *\n * The content box comes from the live canvas because a stylesheet can change it\n * before the next root surface commit updates the cached surface snapshot.\n */\nexport function currentRootCoordinateMapping(\n  root: PibblInstance,\n): readonly number[] {\n  const surface = getSurfaceSnapshot(root);\n  const [contentLeft, contentTop, contentWidth, contentHeight] =\n    currentCanvasContentBox(\n      root.canvas,\n      surface.displayWidth,\n      surface.displayHeight,\n    );\n  const inverse = surface.inverseRenderTransform;\n  return Object.freeze([\n    contentLeft,\n    contentTop,\n    contentWidth,\n    contentHeight,\n    surface.backingPixelsPerCssPixelX,\n    surface.backingPixelsPerCssPixelY,\n    surface.backingWidth,\n    surface.backingHeight,\n    surface.logicalWidth,\n    surface.logicalHeight,\n    inverse.a,\n    inverse.b,\n    inverse.c,\n    inverse.d,\n    inverse.e,\n    inverse.f,\n  ]);\n}\n\nexport function sameRootCoordinateMapping(\n  left: readonly number[] | undefined,\n  right: readonly number[] | undefined,\n): boolean {\n  return (\n    left !== undefined &&\n    right !== undefined &&\n    left.length === right.length &&\n    left.every((value, index) => Object.is(value, right[index]))\n  );\n}\n\nfunction currentCanvasContentBox(\n  canvas: PibblInstance[\"canvas\"],\n  fallbackWidth: number,\n  fallbackHeight: number,\n): readonly [number, number, number, number] {\n  if (\n    typeof HTMLCanvasElement === \"undefined\" ||\n    !(canvas instanceof HTMLCanvasElement)\n  )\n    return [0, 0, fallbackWidth, fallbackHeight];\n  const bounds = canvas.getBoundingClientRect();\n  const style = getComputedStyle(canvas);\n  const leftInset = px(style.borderLeftWidth) + px(style.paddingLeft);\n  const topInset = px(style.borderTopWidth) + px(style.paddingTop);\n  const rightInset = px(style.borderRightWidth) + px(style.paddingRight);\n  const bottomInset = px(style.borderBottomWidth) + px(style.paddingBottom);\n  return [\n    bounds.left + leftInset,\n    bounds.top + topInset,\n    Math.max(0, bounds.width - leftInset - rightInset),\n    Math.max(0, bounds.height - topInset - bottomInset),\n  ];\n}\n\nfunction px(value: string): number {\n  return Number.parseFloat(value) || 0;\n}\n"],
+  "mappings": "AAAA,SAAS,0BAA0B;AAS5B,SAAS,6BACd,MACmB;AACnB,QAAM,UAAU,mBAAmB,IAAI;AACvC,QAAM,CAAC,aAAa,YAAY,cAAc,aAAa,IACzD;AAAA,IACE,KAAK;AAAA,IACL,QAAQ;AAAA,IACR,QAAQ;AAAA,EACV;AACF,QAAM,UAAU,QAAQ;AACxB,SAAO,OAAO,OAAO;AAAA,IACnB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,QAAQ;AAAA,EACV,CAAC;AACH;AAEO,SAAS,0BACd,MACA,OACS;AACT,SACE,SAAS,UACT,UAAU,UACV,KAAK,WAAW,MAAM,UACtB,KAAK,MAAM,CAAC,OAAO,UAAU,OAAO,GAAG,OAAO,MAAM,KAAK,CAAC,CAAC;AAE/D;AAEA,SAAS,wBACP,QACA,eACA,gBAC2C;AAC3C,MACE,OAAO,sBAAsB,eAC7B,EAAE,kBAAkB;AAEpB,WAAO,CAAC,GAAG,GAAG,eAAe,cAAc;AAC7C,QAAM,SAAS,OAAO,sBAAsB;AAC5C,QAAM,QAAQ,iBAAiB,MAAM;AACrC,QAAM,YAAY,GAAG,MAAM,eAAe,IAAI,GAAG,MAAM,WAAW;AAClE,QAAM,WAAW,GAAG,MAAM,cAAc,IAAI,GAAG,MAAM,UAAU;AAC/D,QAAM,aAAa,GAAG,MAAM,gBAAgB,IAAI,GAAG,MAAM,YAAY;AACrE,QAAM,cAAc,GAAG,MAAM,iBAAiB,IAAI,GAAG,MAAM,aAAa;AACxE,SAAO;AAAA,IACL,OAAO,OAAO;AAAA,IACd,OAAO,MAAM;AAAA,IACb,KAAK,IAAI,GAAG,OAAO,QAAQ,YAAY,UAAU;AAAA,IACjD,KAAK,IAAI,GAAG,OAAO,SAAS,WAAW,WAAW;AAAA,EACpD;AACF;AAEA,SAAS,GAAG,OAAuB;AACjC,SAAO,OAAO,WAAW,KAAK,KAAK;AACrC;",
+  "names": []
+}

package/dist/lib/manipulation/degrees.d.ts

@@ -0,0 +1,10 @@
+import type { PibblManipulationGeometry } from "./controller-types.js";
+/**
+ * Convert a finite degree angle to radians.
+ *
+ * @param value - Angle in degrees.
+ * @returns The equivalent angle in radians.
+ *
+ * @see {@link PibblManipulationGeometry}
+ */
+export declare function degrees(value: number): number;

package/dist/lib/manipulation/degrees.js

@@ -0,0 +1,9 @@
+function degrees(value) {
+  if (!Number.isFinite(value))
+    throw new Error("degrees requires a finite angle.");
+  return value * (Math.PI / 180);
+}
+export {
+  degrees
+};
+//# sourceMappingURL=degrees.js.map

package/dist/lib/manipulation/degrees.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/manipulation/degrees.ts"],
+  "sourcesContent": ["import type { PibblManipulationGeometry } from './controller-types.js';\n/**\n * Convert a finite degree angle to radians.\n *\n * @param value - Angle in degrees.\n * @returns The equivalent angle in radians.\n *\n * @see {@link PibblManipulationGeometry}\n */\nexport function degrees(value: number): number {\n  if (!Number.isFinite(value))\n    throw new Error(\"degrees requires a finite angle.\");\n  return value * (Math.PI / 180);\n}\n"],
+  "mappings": "AASO,SAAS,QAAQ,OAAuB;AAC7C,MAAI,CAAC,OAAO,SAAS,KAAK;AACxB,UAAM,IAAI,MAAM,kCAAkC;AACpD,SAAO,SAAS,KAAK,KAAK;AAC5B;",
+  "names": []
+}

package/dist/lib/manipulation/frame.d.ts

@@ -0,0 +1,24 @@
+import type { PibblManipulationFrameProps } from "./controller-types.js";
+import type { PibblNode } from "../element/types.js";
+import type { SystemStyle } from "../types.js";
+import type { PibblManipulationBox } from "./types.js";
+import type { PibblManipulationController } from "./controller-types.js";
+import { type ManipulationState } from "./controller.js";
+export declare function requireManipulationFrame(controller: PibblManipulationController): ManipulationState;
+interface FrameProps {
+    readonly controller: PibblManipulationController;
+    readonly children?: PibblNode;
+}
+interface FrameStyle extends SystemStyle, PibblManipulationBox {
+}
+/**
+ * Provides a manipulation controller and its presentation frame to descendant handles.
+ *
+ * @param props - Authored component inputs, supplied through JSX or createElement. See the linked
+ * props and style types.
+ * @throws When called directly; Pibbl mounts this component through JSX or createElement.
+ *
+ * @see {@link PibblManipulationFrameProps}
+ */
+export declare const ManipulationFrame: import("@pibbl/core").PibblPrimitiveComponent<FrameProps, import("@pibbl/core").PrimitiveInput<FrameProps, FrameStyle>>;
+export {};