"use strict";

// Layer: physics/mechanical-body
// Common body, footprint, motion, and contact runtime for \u56de\u8ee2\u4f53, \u6bd2\u30d6\u30ed\u30c3\u30af, and \u5f80\u5fa9\u4f53.
(function (global) {
  const footprints = global.TarinaiCollisionFootprints;
  const num = global.TarinaiCoreHelpers?.finiteOr || ((v, fallback = 0) => {
    const n = Number(v);
    return Number.isFinite(n) ? n : fallback;
  });

  function rectCorners(rect, padding = 0) {
    return footprints?.rectCorners?.(rect, padding) || [];
  }

  function rectAxes(rect) {
    return footprints?.rectAxes?.(rect) || [{ x: 1, y: 0 }, { x: 0, y: 1 }];
  }

  function projectPoints(points, axis) {
    return footprints?.projectPoints?.(points, axis) || { min: Infinity, max: -Infinity };
  }


  function rectOverlapInfo(a, b, padding = 0) {
    return footprints?.rectOverlapInfo?.(a, b, padding) || null;
  }
  function typeOf(itemOrType) { return typeof itemOrType === "string" ? itemOrType : String(itemOrType?.type || ""); }
  function isMechanicalType(itemOrType) { const t = typeOf(itemOrType); return t === "rotator" || t === "poison_block" || t === "reciprocator"; }
  function motionType(itemOrType) { const t = typeOf(itemOrType); return t === "rotator" ? "rotate" : (t === "reciprocator" ? "reciprocate" : (t === "poison_block" ? "passive" : "none")); }
  function normalizeAngle(angle = 0) { return typeof global.normalizedItemAngle === "function" ? global.normalizedItemAngle(angle, 0) : angle; }

  function bodySystem() { return global.TarinaiPhysicsBodySystem || null; }
  function ps(item, key, fallback = 0) { return bodySystem()?.scalar?.(item, key, fallback) ?? fallback; }
  function pset(item, key, value, reason = "mechanical-write") { return bodySystem()?.setScalar?.(item, key, value, reason) || false; }
  function ensureBody(item, opts = {}) {
    if (!item || item.dead || !isMechanicalType(item)) return null;
    const api = bodySystem();
    return api?.ensureBody?.(item, item.world || null, { syncFromLegacy: opts.syncFromLegacy === true }) || item.physicsBody || null;
  }
  function bodyOf(item) { return ensureBody(item, { syncFromLegacy: false }); }
  function usingStepScratch(item) { return item?._physicsStepScratch === true; }
  function runMechanicalStep(item, fn) {
    const prevScratch = item._physicsStepScratch === true;
    item._physicsStepScratch = true;
    try {
      return fn();
    } finally {
      item._physicsStepScratch = prevScratch;
      commitBody(item);
    }
  }
  function bodyPose(item) { return usingStepScratch(item) ? null : (bodyOf(item)?.pose || null); }
  function bodyVelocity(item) { return bodyOf(item)?.velocity || null; }
  function bodyMotor(item) { return bodyOf(item)?.motor || null; }
  function bodyRail(item) { return bodyOf(item)?.rail || null; }
  function bodyShape(item) { return bodyOf(item)?.shape || null; }
  function applyBodyState(item, opts = {}) { return bodySystem()?.applyBodyState?.(item, item?.physicsBody, opts) || false; }
  function commitBody(item) {
    if (!item || !isMechanicalType(item)) return null;
    // Capture the scratch pose before writing it back to the authoritative body.
    const sx = num(item.x);
    const sy = num(item.y);
    const sa = num(item.angle);
    let body = item.physicsBody && item.physicsBody.type === item.type ? item.physicsBody : null;
    if (!body) body = ensureBody(item, { syncFromLegacy: false });
    if (!body) return null;
    body.pose = body.pose || { x: sx, y: sy, angle: sa };
    body.pose.x = sx;
    body.pose.y = sy;
    body.pose.angle = sa;
    item.x = sx;
    item.y = sy;
    item.angle = sa;
    return body;
  }
  function isPowered(item) {
    const signalOverride = global.TarinaiSignalSystem?.powerOverride?.(item);
    if (signalOverride != null) return Boolean(signalOverride);
    const motor = bodyMotor(item);
    if (motor) return item?.type === "poison_block" ? false : motor.powered !== false;
    return item?.type === "rotator" ? ps(item, "motorOn", true) !== false : (item?.type === "reciprocator" ? ps(item, "railOn", true) !== false : false);
  }
  function itemAngle(item) {
    const pose = bodyPose(item);
    if (pose && Number.isFinite(Number(pose.angle))) return num(pose.angle);
    return typeof global.itemAngleFor === "function" ? global.itemAngleFor(item) : num(item?.angle, 0);
  }

  function geomCache(item) {
    if (!item) return null;
    return item._mechanicalGeomCache || (item._mechanicalGeomCache = Object.create(null));
  }

  function shapeVersion(item) {
    const shape = bodyShape(item);
    return Number(shape?.version ?? item?._mechanicalShapeVersion ?? 0) || 0;
  }

  function invalidateGeometry(item) {
    if (!item) return false;
    const nextVersion = (Number(shapeVersion(item) || 0) || 0) + 1;
    const body = ensureBody(item, { syncFromLegacy: true });
    if (body) {
      body.shape = body.shape || {};
      body.shape.version = nextVersion;
    }
    item._mechanicalShapeVersion = nextVersion;
    item._mechanicalGeomCache = null;
    item.world?.markSpatialDirty?.("mechanical-geometry-edited");
    item.world?.markItemBucketsDirty?.("mechanical-geometry-edited");
    return true;
  }

  function wakeItem(item, reason = "mechanical-wake") {
    if (!item || item.dead) return false;
    const now = Number(item.world?.time || 0) || 0;
    const awakeUntil = Math.max(ps(item, "awakeUntil", 0), now + 0.45);
    pset(item, "awakeUntil", awakeUntil, reason);
    const body = ensureBody(item, { syncFromLegacy: false });
    if (body) {
      body.sleep = body.sleep || {};
      body.sleep.awakeUntil = Math.max(num(body.sleep.awakeUntil), awakeUntil);
    }
    if (item.world) {
      item.world._itemUpdateScheduler = null;
      item.world.markSpatialDirty?.(reason);
    }
    return true;
  }

  function passiveItemAwake(item) {
    if (!item || item.dead) return false;
    if (item.playerHeld || item._heldByPlayer) return true;
    const body = bodyOf(item);
    const sleep = body?.sleep || null;
    const vel = body?.velocity || null;
    const awakeUntil = Math.max(num(sleep?.awakeUntil), ps(item, "awakeUntil", 0));
    if (awakeUntil > (Number(item.world?.time || 0) || 0)) return true;
    if (Math.hypot(num(vel?.x, ps(item, "xv", 0)), num(vel?.y, ps(item, "yv", 0))) > 0.035) return true;
    if (Math.abs(num(vel?.angular, ps(item, "spin", 0))) > 0.0015) return true;
    return false;
  }

  function railAxisAngle(item) {
    const fallback = itemAngle(item);
    return normalizeAngle(num(bodyRail(item)?.axisAngle, ps(item, "railAxis", fallback)));
  }

  function rawSegmentSignature(raw) {
    if (!Array.isArray(raw) || !raw.length) return "0";
    // Cheap edit detection for older save/editor paths that do not bump the
    // mechanical shape version. This runs only until the local cache is valid.
    let h = raw.length * 2166136261;
    const step = Math.max(1, Math.floor(raw.length / 24));
    for (let i = 0; i < raw.length; i += step) {
      const seg = raw[i];
      if (!Array.isArray(seg)) continue;
      for (let j = 0; j < 4; j += 1) {
        h ^= Math.round(num(seg[j]) * 10) & 0xffff;
        h = Math.imul(h, 16777619);
      }
    }
    return String(h >>> 0);
  }

  function normalizeRawSegments(item) {
    const shape = bodyShape(item);
    const raw = Array.isArray(shape?.segments) ? shape.segments : [];
    const out = [];
    const clampCoord = (v) => Math.max(-420, Math.min(420, num(v)));
    for (const seg of raw) {
      if (!Array.isArray(seg) || seg.length < 4) continue;
      const x1 = clampCoord(seg[0]), y1 = clampCoord(seg[1]), x2 = clampCoord(seg[2]), y2 = clampCoord(seg[3]);
      if (Math.hypot(x2 - x1, y2 - y1) < 4) continue;
      out.push([x1, y1, x2, y2]);
      if (out.length >= 128) break;
    }
    if (!out.length) {
      if (item?.type === "poison_block") out.push([-52, -20, 52, -20], [52, -20, 52, 20], [52, 20, -52, 20], [-52, 20, -52, -20]);
      else out.push(item?.type === "rotator" ? [-78, 0, 78, 0] : [-78, 0, 78, 0], ...(item?.type === "rotator" ? [[0, -52, 0, 52]] : []));
    }
    return out;
  }

  function physicsSegmentLimit(item, normalizedCount = 0) {
    const base = item?.type === "reciprocator" ? 34 : (item?.type === "poison_block" ? 48 : 58);
    // Keep small hand-made shapes exact. Simplification is only for dense free-draw shapes.
    if (normalizedCount <= base) return normalizedCount;
    return base;
  }

  function simplifySegmentsForPhysics(item, segments) {
    const limit = physicsSegmentLimit(item, segments.length);
    if (segments.length <= limit) return segments;
    const minLen = item?.type === "poison_block" ? 5.2 : 5.8;
    const merged = [];
    const angleEps = 0.15;
    const joinEps = 7.5;
    for (const seg of segments) {
      const x1 = seg[0], y1 = seg[1], x2 = seg[2], y2 = seg[3];
      const len = Math.hypot(x2 - x1, y2 - y1);
      if (len < minLen) continue;
      const last = merged[merged.length - 1];
      if (last) {
        const ldx = last[2] - last[0], ldy = last[3] - last[1];
        const dx = x2 - x1, dy = y2 - y1;
        const llen = Math.max(0.001, Math.hypot(ldx, ldy));
        const dlen = Math.max(0.001, Math.hypot(dx, dy));
        const dot = (ldx / llen) * (dx / dlen) + (ldy / llen) * (dy / dlen);
        if (Math.hypot(last[2] - x1, last[3] - y1) <= joinEps && dot > 1 - angleEps) {
          last[2] = x2;
          last[3] = y2;
          continue;
        }
      }
      merged.push([x1, y1, x2, y2]);
    }
    const source = merged.length ? merged : segments;
    if (source.length <= limit) return source;
    // Preserve coverage rather than perfect ordering: choose the longest segments,
    // then restore original order so free-drawn outlines remain visually coherent to physics.
    const ranked = source.map((seg, index) => ({
      index,
      seg,
      score: Math.hypot(seg[2] - seg[0], seg[3] - seg[1]) + Math.hypot(seg[0], seg[1]) * 0.015 + Math.hypot(seg[2], seg[3]) * 0.015,
    })).sort((a, b) => b.score - a.score).slice(0, limit).sort((a, b) => a.index - b.index);
    return ranked.map(e => e.seg);
  }

  function sanitizeSegments(item) {
    const cache = geomCache(item);
    const shape = bodyShape(item);
    const raw = Array.isArray(shape?.segments) ? shape.segments : [];
    const thickKey = Number.isFinite(Number(shape?.thickness)) ? shape.thickness : ps(item, "thickness", item?.type === "poison_block" ? 11 : 12);
    const key = `${item?.type || ""}|${shapeVersion(item)}|${raw.length}|${rawSegmentSignature(raw)}|${thickKey || ""}`;
    if (cache?.localKey === key && cache.localSegments) return cache.localSegments;
    const normalized = normalizeRawSegments(item);
    const out = simplifySegmentsForPhysics(item, normalized);
    if (cache) {
      cache.localKey = key;
      cache.localSegments = out;
    }
    return out;
  }

  function thickness(item) { return Math.max(4, Math.min(34, num(bodyShape(item)?.thickness, ps(item, "thickness", item?.type === "poison_block" ? 11 : 12)))); }

  function extent(item) {
    const cache = geomCache(item);
    const local = sanitizeSegments(item);
    const key = `${cache?.localKey || ""}|${shapeVersion(item)}|${item?.type || ""}|${thickness(item)}`;
    if (cache?.extentKey === key && Number.isFinite(cache.extent)) return cache.extent;
    let maxD = 48;
    for (const seg of local) maxD = Math.max(maxD, Math.hypot(seg[0], seg[1]), Math.hypot(seg[2], seg[3]));
    const value = Math.min(460, maxD + Math.max(8, thickness(item)) + 8);
    if (cache) { cache.extentKey = key; cache.extent = value; }
    return value;
  }

  function worldSegments(item) {
    if (!item || item.dead || !isMechanicalType(item)) return [];
    const cache = geomCache(item);
    const local = sanitizeSegments(item);
    const a = itemAngle(item);
    const key = `${cache?.localKey || ""}|${shapeVersion(item)}|${num(item.x).toFixed(3)}|${num(item.y).toFixed(3)}|${a.toFixed(5)}`;
    if (cache?.worldKey === key && cache.worldSegments) return cache.worldSegments;
    const c = Math.cos(a), s = Math.sin(a);
    const pose = bodyPose(item);
    const cx = num(pose?.x, item.x), cy = num(pose?.y, item.y);
    const segments = local.map(([x1, y1, x2, y2]) => [
      cx + x1 * c - y1 * s,
      cy + x1 * s + y1 * c,
      cx + x2 * c - y2 * s,
      cy + x2 * s + y2 * c,
    ]);
    if (cache) { cache.worldKey = key; cache.worldSegments = segments; }
    return segments;
  }

  function axis(item) {
    const a = item?.type === "reciprocator" ? railAxisAngle(item) : itemAngle(item);
    return { x: Math.cos(a), y: Math.sin(a), angle: a };
  }

  function halfTravel(item) { return Math.max(24, num(bodyRail(item)?.travel, ps(item, "railTravel", 150))) * 0.5; }

  function resetAnchor(item) {
    if (!item) return;
    const body = ensureBody(item, { syncFromLegacy: false });
    const rail = body?.rail || null;
    const pose = body?.pose || null;
    if (rail) {
      if (!Number.isFinite(Number(rail.anchorX))) rail.anchorX = num(pose?.x, item.x);
      if (!Number.isFinite(Number(rail.anchorY))) rail.anchorY = num(pose?.y, item.y);
      pset(item, "railAnchorX", rail.anchorX, "rail-anchor-init");
      pset(item, "railAnchorY", rail.anchorY, "rail-anchor-init");
      return;
    }
    if (!Number.isFinite(Number(rail?.anchorX))) pset(item, "railAnchorX", num(item.x), "rail-anchor-init");
    if (!Number.isFinite(Number(rail?.anchorY))) pset(item, "railAnchorY", num(item.y), "rail-anchor-init");
  }

  function positionFromPhase(item) {
    resetAnchor(item);
    const a = axis(item);
    const travel = halfTravel(item);
    const rail = bodyRail(item);
    const phase = Math.max(-1, Math.min(1, num(rail?.phase, ps(item, "railPhase", 0))));
    return { x: num(rail?.anchorX, ps(item, "railAnchorX", item.x)) + a.x * travel * phase, y: num(rail?.anchorY, ps(item, "railAnchorY", item.y)) + a.y * travel * phase };
  }


  function signedDrive(item) {
    if (!item) return 0;
    const vel = bodyVelocity(item);
    const motor = bodyMotor(item);
    if (item.type === "rotator") return (isPowered(item) ? num(motor?.speed, ps(item, "motorSpeed", 0)) : 0) + num(vel?.angular, ps(item, "spin", 0));
    if (item.type === "poison_block") return num(vel?.angular, ps(item, "spin", 0));
    if (item.type === "reciprocator") {
      const dir = Math.sign(num(motor?.direction, ps(item, "railDir", 1))) || 1;
      return (isPowered(item) ? dir * Math.max(0, num(motor?.speed, ps(item, "railMotorSpeed", 0))) : 0) + num(vel?.linear, ps(item, "slideSpeed", 0));
    }
    return 0;
  }

  function motionLevel(item, dt = 0.016) {
    if (!item || item.dead || !isMechanicalType(item)) return 0;
    const speed = Math.abs(signedDrive(item));
    if (item.type === "rotator" || item.type === "poison_block") return speed * Math.max(48, extent(item));
    return speed;
  }

  function pointVelocity(item, x, y) {
    if (!item) return { x: 0, y: 0 };
    if (item.type === "rotator" || item.type === "poison_block") {
      const omega = signedDrive(item);
      const pose = bodyPose(item);
      const vel = bodyVelocity(item);
      const rx = num(x) - num(pose?.x, item.x);
      const ry = num(y) - num(pose?.y, item.y);
      const baseX = item.type === "poison_block" ? num(vel?.x, ps(item, "xv", 0)) : 0;
      const baseY = item.type === "poison_block" ? num(vel?.y, ps(item, "yv", 0)) : 0;
      return { x: baseX - ry * omega, y: baseY + rx * omega };
    }
    if (item.type === "reciprocator") {
      const a = axis(item);
      const v = signedDrive(item);
      return { x: a.x * v, y: a.y * v };
    }
    return { x: 0, y: 0 };
  }

  function segmentRect(item, x1, y1, x2, y2) {
    const len = Math.max(4, Math.hypot(x2 - x1, y2 - y1));
    const angle = Math.atan2(y2 - y1, x2 - x1);
    const halfW = len / 2;
    // Keep mechanical collision close to the drawn stroke.  Earlier large
    // skins made rotators/reciprocators feel visually offset; tunneling is
    // handled by the central substep pair pass instead of over-thick shapes.
    const visualThickness = thickness(item);
    const collisionSkin = item.type === "poison_block" ? 1.5 : 1.0;
    const halfH = visualThickness / 2 + collisionSkin;
    const cx = (x1 + x2) / 2;
    const cy = (y1 + y2) / 2;
    const aabb = global.TarinaiGeometry.orientedRectAabb(cx, cy, halfW, halfH, angle);
    const base = {
      left: aabb.left, right: aabb.right, top: aabb.top, bottom: aabb.bottom,
      cx, cy, halfW, halfH, angle, cos: aabb.cos, sin: aabb.sin, oriented: true,
      type: item.type, item, mechanical: true, motionType: motionType(item), restitution: item.type === "rotator" ? 0.72 : 0.70,
    };
    if (item.type === "rotator") {
      return {
        ...base,
        rotator: true,
        angularVelocity: signedDrive(item),
        centerX: num(bodyPose(item)?.x, item.x), centerY: num(bodyPose(item)?.y, item.y),
      };
    }
    if (item.type === "poison_block") {
      return {
        ...base,
        poisonBlock: true,
        passiveBlock: true,
        restitution: 0.62,
        motionVelocityX: num(bodyVelocity(item)?.x, item.vx),
        motionVelocityY: num(bodyVelocity(item)?.y, item.vy),
        angularVelocity: signedDrive(item),
        centerX: num(bodyPose(item)?.x, item.x), centerY: num(bodyPose(item)?.y, item.y),
      };
    }
    const a = axis(item);
    const v = signedDrive(item);
    return { ...base, reciprocator: true, motionVelocityX: a.x * v, motionVelocityY: a.y * v, axisX: a.x, axisY: a.y };
  }

  function rectCacheKey(item, kind = "obstacle") {
    const cache = geomCache(item);
    const body = bodyOf(item);
    const pose = body?.pose || {};
    const vel = body?.velocity || {};
    const motor = body?.motor || {};
    const rail = body?.rail || {};
    const collision = body?.collision || {};
    sanitizeSegments(item);
    return [
      kind,
      cache?.localKey || "",
      item?.type || "",
      shapeVersion(item),
      num(pose.x, item?.x).toFixed(3),
      num(pose.y, item?.y).toFixed(3),
      itemAngle(item).toFixed(5),
      thickness(item).toFixed(2),
      collision.solid === false ? 0 : 1,
      motor.powered === false ? 0 : 1,
      num(motor.speed, ps(item, "motorSpeed", 0)).toFixed(4),
      num(vel.angular, ps(item, "spin", 0)).toFixed(5),
      motor.powered === false ? 0 : 1,
      num(rail.axisAngle, itemAngle(item)).toFixed(5),
      num(motor.speed, ps(item, "railMotorSpeed", 92)).toFixed(3),
      num(motor.direction, 1),
      num(vel.linear, ps(item, "slideSpeed", 0)).toFixed(3),
      num(vel.x, item?.vx).toFixed(3),
      num(vel.y, item?.vy).toFixed(3),
    ].join("|");
  }

  function rectsFor(item, kind) {
    const cache = geomCache(item);
    const key = rectCacheKey(item, kind);
    const prop = kind === "hazard" ? "hazardRects" : "obstacleRects";
    const keyProp = `${prop}Key`;
    if (cache?.[keyProp] === key && cache[prop]) return cache[prop];
    const rects = worldSegments(item).map(seg => segmentRect(item, seg[0], seg[1], seg[2], seg[3]));
    if (cache) { cache[keyProp] = key; cache[prop] = rects; }
    return rects;
  }

  function obstacleRects(item) {
    if (!item || item.dead || !isMechanicalType(item)) return [];
    if (bodyOf(item)?.collision?.solid === false) return [];
    return rectsFor(item, "obstacle");
  }

  function placementRects(item) {
    if (!item || item.dead || !isMechanicalType(item)) return [];
    return rectsFor(item, "obstacle");
  }

  function poisonHazardRects(item) {
    if (!item || item.dead || item.type !== "poison_block") return [];
    return rectsFor(item, "hazard");
  }

  function aabbFromRects(item, rects, kind = "obstacle") {
    if (!rects || !rects.length) return null;
    const cache = geomCache(item);
    const key = `${kind}|${rectCacheKey(item, kind)}|aabb`;
    const prop = kind === "hazard" ? "hazardAabb" : "obstacleAabb";
    const keyProp = `${prop}Key`;
    if (cache?.[keyProp] === key && cache[prop]) return cache[prop];
    const out = {
      left: Infinity, right: -Infinity, top: Infinity, bottom: -Infinity,
      type: item.type, item,
    };
    for (const r of rects) {
      out.left = Math.min(out.left, r.left);
      out.right = Math.max(out.right, r.right);
      out.top = Math.min(out.top, r.top);
      out.bottom = Math.max(out.bottom, r.bottom);
    }
    if (!Number.isFinite(out.left) || !Number.isFinite(out.right) || !Number.isFinite(out.top) || !Number.isFinite(out.bottom)) return null;
    if (cache) { cache[keyProp] = key; cache[prop] = out; }
    return out;
  }

  function boundsAabb(item) {
    return aabbFromRects(item, obstacleRects(item), "obstacle");
  }

  function reach(item) {
    if (!item) return 64;
    const base = Math.max(num(item.r, 64), extent(item));
    if (item.type === "reciprocator") return Math.max(90, base + num(bodyRail(item)?.travel, ps(item, "railTravel", 150)) * 0.55);
    return base;
  }

  function applyImpulse(item, contactX, contactY, fx, fy, scale = 1) {
    if (!item || item.dead || !isMechanicalType(item)) return false;
    const powered = isPowered(item);
    if (item.type === "poison_block") {
      const body = ensureBody(item, { syncFromLegacy: false });
      if (!body) return false;
      body.velocity = body.velocity || { x: 0, y: 0, angular: 0, linear: 0 };
      const vel = body.velocity;
      const pose = body.pose || {};
      const mass = Math.max(0.20, ps(item, "mass", 0.45));
      const prevVx = num(vel.x, item.vx);
      const prevVy = num(vel.y, item.vy);
      const nextVx = clamp(prevVx + num(fx) * 0.42 * scale / mass, -260, 260);
      const nextVy = clamp(prevVy + num(fy) * 0.42 * scale / mass, -260, 260);
      vel.x = nextVx;
      vel.y = nextVy;
      // Keep the legacy Canvas scratch velocity in sync for non-physics helpers
      // that still render effects from item.vx/vy, but physics reads body.velocity.
      item.vx = nextVx;
      item.vy = nextVy;
      const rx = num(contactX) - num(pose.x, item.x);
      const ry = num(contactY) - num(pose.y, item.y);
      const torque = rx * num(fy) - ry * num(fx);
      const inertia = Math.max(1200, ps(item, "inertia", 3200));
      vel.angular = clamp(num(vel.angular, ps(item, "spin", 0)) + torque / inertia * scale, -2.2, 2.2);
      const changed = Math.hypot(nextVx - prevVx, nextVy - prevVy) > 0.002 || Math.abs(torque) > 0.001;
      if (changed) { commitBody(item); wakeItem(item, "poison-block-impulse"); }
      return changed;
    }
    if (item.type === "rotator") {
      const rx = num(contactX) - num(item.x);
      const ry = num(contactY) - num(item.y);
      const torque = rx * num(fy) - ry * num(fx);
      const denom = powered ? 38000 : 15000;
      const delta = clamp(torque / denom * scale, -0.46, 0.46);
      if (!Number.isFinite(delta) || Math.abs(delta) < 0.0008) return false;
      const limit = powered ? 3.2 : 2.25;
      pset(item, "spin", clamp(num(bodyVelocity(item)?.angular, ps(item, "spin", 0)) + delta, -limit, limit), "rotator-torque");
      commitBody(item);
      return true;
    }
    const a = axis(item);
    const along = num(fx) * a.x + num(fy) * a.y;
    let delta = along * (powered ? 0.28 : 0.52) * scale;
    if (powered) {
      // A powered reciprocator should not lose its motor drive the instant it
      // touches something.  Contact impulses are kept as a small secondary
      // slide component; hard physical blocking is handled by immediate contact reversal.
      const driveDir = Math.sign(ps(item, "railDir", 1)) || 1;
      const motorSpeed = Math.max(0, ps(item, "railMotorSpeed", 92));
      const current = num(bodyVelocity(item)?.linear, ps(item, "slideSpeed", 0));
      const opposing = Math.sign(delta || 0) === -driveDir && Math.abs(delta) > motorSpeed * 0.18;
      delta = clamp(delta * (opposing ? 0.10 : 0.18), -14, 14);
      const next = clamp(current * 0.62 + delta, -Math.max(18, motorSpeed * 0.32), Math.max(18, motorSpeed * 0.32));
      if (!Number.isFinite(next) || Math.abs(next - current) < 0.03) return false;
      pset(item, "slideSpeed", next, "slide-contact-trim");
    } else {
      delta = clamp(delta, -52, 52);
      if (!Number.isFinite(delta) || Math.abs(delta) < 0.05) return false;
      pset(item, "slideSpeed", clamp(num(bodyVelocity(item)?.linear, ps(item, "slideSpeed", 0)) + delta, -150, 150), "slide-impulse");
    }
    commitBody(item);
    return true;
  }

  function applyPassiveReciprocatorImpulse(item, axisX, axisY, nx, ny, vx, vy, scale = 1) {
    if (!item || isPowered(item)) return false;
    const ax = num(axisX, 1), ay = num(axisY, 0), nX = num(nx), nY = num(ny);
    const hitVx = num(vx), hitVy = num(vy);
    const incomingNormal = Math.max(0, -(hitVx * nX + hitVy * nY));
    const axisVel = hitVx * ax + hitVy * ay;
    const normalDrive = -(nX * ax + nY * ay) * incomingNormal;
    const axisDrive = Math.abs(axisVel) >= 3 ? axisVel : 0;
    const delta = clamp((axisDrive * 0.030 + normalDrive * 0.080) * scale, -24, 24);
    if (!Number.isFinite(delta) || Math.abs(delta) < 0.08) return false;
    pset(item, "slideSpeed", clamp(num(bodyVelocity(item)?.linear, ps(item, "slideSpeed", 0)) * 0.84 + delta, -125, 125), "passive-slide-impulse");
    commitBody(item);
    return true;
  }

  function applyPassiveRotatorImpulse(item, rx, ry, nx, ny, vx, vy, scale = 1) {
    if (!item || isPowered(item)) return false;
    const hitVx = num(vx), hitVy = num(vy), nX = num(nx), nY = num(ny);
    const arm2 = Math.max(4200, rx * rx + ry * ry);
    const tangential = (hitVx * -ry + hitVy * rx) / arm2;
    const incomingNormal = Math.max(0, -(hitVx * nX + hitVy * nY));
    const normalTorque = ((-nX) * -ry + (-nY) * rx) / Math.max(28, Math.hypot(rx, ry));
    const delta = clamp((tangential * 0.14 + normalTorque * incomingNormal * 0.0016) * scale, -0.18, 0.18);
    if (!Number.isFinite(delta) || Math.abs(delta) < 0.002) return false;
    pset(item, "spin", clamp(num(bodyVelocity(item)?.angular, ps(item, "spin", 0)) * 0.86 + delta, -1.75, 1.75), "passive-spin-impulse");
    commitBody(item);
    return true;
  }


  function applySurfaceVelocityToCircle(obj, rect, nx, ny, preVx = 0, preVy = 0, opts = {}) {
    if (!obj || !rect || !rect.mechanical) return false;
    const nX = num(nx);
    const nY = num(ny);
    const vx = num(preVx, num(obj.vx));
    const vy = num(preVy, num(obj.vy));
    const maxSpeed = Math.max(80, num(opts.maxSpeed, 900));
    const normalBoost = num(opts.normalBoost, rect.rotator ? 20 : 14);
    const surfaceScale = num(opts.surfaceScale, rect.rotator ? 0.28 : 0.30);
    const damping = clamp(num(opts.damping, 1), 0, 1.2);
    let applied = false;
    if (rect.rotator) {
      const omega = clamp(num(rect.angularVelocity), -8, 8);
      const rx = num(obj.x) - num(rect.centerX, num(rect.item?.x, num(rect.cx)));
      const ry = num(obj.y) - num(rect.centerY, num(rect.item?.y, num(rect.cy)));
      const tvx = -ry * omega;
      const tvy = rx * omega;
      obj.vx = clamp(num(obj.vx) * damping + tvx * surfaceScale + nX * normalBoost, -maxSpeed, maxSpeed);
      obj.vy = clamp(num(obj.vy) * damping + tvy * surfaceScale + nY * normalBoost, -maxSpeed, maxSpeed);
      if (opts.impulseVScale) {
        obj.impulseVx = clamp(num(obj.impulseVx) + tvx * num(opts.impulseVScale), -num(opts.impulseMax, 360), num(opts.impulseMax, 360));
        obj.impulseVy = clamp(num(obj.impulseVy) + tvy * num(opts.impulseVScale), -num(opts.impulseMax, 360), num(opts.impulseMax, 360));
      }
      applyPassiveRotatorImpulse(rect.item, rx, ry, nX, nY, vx, vy, num(opts.passiveImpulseScale, 1));
      applied = true;
    } else if (rect.reciprocator) {
      const mvx = clamp(num(rect.motionVelocityX), -360, 360);
      const mvy = clamp(num(rect.motionVelocityY), -360, 360);
      obj.vx = clamp(num(obj.vx) * damping + mvx * surfaceScale + nX * normalBoost, -maxSpeed, maxSpeed);
      obj.vy = clamp(num(obj.vy) * damping + mvy * surfaceScale + nY * normalBoost, -maxSpeed, maxSpeed);
      if (opts.impulseVScale) {
        obj.impulseVx = clamp(num(obj.impulseVx) + mvx * num(opts.impulseVScale), -num(opts.impulseMax, 320), num(opts.impulseMax, 320));
        obj.impulseVy = clamp(num(obj.impulseVy) + mvy * num(opts.impulseVScale), -num(opts.impulseMax, 320), num(opts.impulseMax, 320));
      }
      applyPassiveReciprocatorImpulse(rect.item, rect.axisX || 1, rect.axisY || 0, nX, nY, vx, vy, num(opts.passiveImpulseScale, 1));
      applied = true;
    } else if (rect.poisonBlock) {
      const omega = clamp(num(rect.angularVelocity), -5.5, 5.5);
      const rx = num(obj.x) - num(rect.centerX, num(rect.item?.x, num(rect.cx)));
      const ry = num(obj.y) - num(rect.centerY, num(rect.item?.y, num(rect.cy)));
      const tvx = clamp(num(rect.motionVelocityX) - ry * omega, -420, 420);
      const tvy = clamp(num(rect.motionVelocityY) + rx * omega, -420, 420);
      obj.vx = clamp(num(obj.vx) * damping + tvx * surfaceScale + nX * normalBoost, -maxSpeed, maxSpeed);
      obj.vy = clamp(num(obj.vy) * damping + tvy * surfaceScale + nY * normalBoost, -maxSpeed, maxSpeed);
      if (opts.impulseVScale) {
        obj.impulseVx = clamp(num(obj.impulseVx) + tvx * num(opts.impulseVScale), -num(opts.impulseMax, 320), num(opts.impulseMax, 320));
        obj.impulseVy = clamp(num(obj.impulseVy) + tvy * num(opts.impulseVScale), -num(opts.impulseMax, 320), num(opts.impulseMax, 320));
      }
      applyImpulse(rect.item, obj.x, obj.y, -nX * (28 + Math.max(0, -(vx * nX + vy * nY)) * 0.42), -nY * (28 + Math.max(0, -(vx * nX + vy * nY)) * 0.42), num(opts.passiveImpulseScale, 1));
      applied = true;
    }
    if (applied && Number.isFinite(obj.spinVelocity)) obj.spinVelocity = clamp(num(obj.spinVelocity) + (nX >= 0 ? -1 : 1) * num(opts.spinKick, 7.0), -46, 46);
    return applied;
  }

  function applyRailCorrection(item, nx, ny, overlap, scale = 1) {
    if (!item || item.dead || item.type !== "reciprocator" || item.playerHeld || item._heldByPlayer) return false;
    resetAnchor(item);
    const a = axis(item);
    const push = Math.max(0, num(overlap)) * Math.max(0, num(scale));
    const along = (-num(nx) * a.x + -num(ny) * a.y) * push;
    if (!Number.isFinite(along) || Math.abs(along) < 0.01) return false;
    const before = ps(item, "railPhase", 0);
    pset(item, "railPhase", clamp(before + along / Math.max(10, halfTravel(item)), -1, 1), "rail-correction");
    const p = positionFromPhase(item);
    item.x = p.x;
    item.y = p.y;
    const changed = Math.abs(ps(item, "railPhase", 0) - before) > 0.0001;
    if (changed) commitBody(item);
    return changed;
  }

  function mechanicalSeparationWeight(item, nx, ny) {
    if (!item || item.dead || item.playerHeld || item._heldByPlayer) return 0;
    if (item.type === "poison_block") return 1 / Math.max(0.20, ps(item, "mass", 0.45));
    if (item.type === "reciprocator") {
      const a = axis(item);
      const projection = Math.abs(num(nx) * a.x + num(ny) * a.y);
      // Reciprocators can only be separated along their rail. Side contacts are
      // handled by impulse/brake, not by teleporting the rail body sideways.
      return projection < 0.10 ? 0 : projection * projection * 0.72;
    }
    // Rotators are anchored motors. Translating them would make edited drawings
    // drift away from their intended pivot, so they are solved via impulse/brake.
    return 0;
  }

  function moveMechanicalBodyForSeparation(item, dx, dy, dt = 0.016, reason = "mechanical-separation") {
    if (!item || item.dead || item.playerHeld || item._heldByPlayer) return false;
    if (!Number.isFinite(dx) || !Number.isFinite(dy) || Math.hypot(dx, dy) < 0.001) return false;
    if (item.type === "poison_block") {
      const beforeX = num(item.x), beforeY = num(item.y);
      item.prevX = beforeX;
      item.prevY = beforeY;
      item.x = beforeX + dx;
      item.y = beforeY + dy;
      item._physicsExternalPoseDirty = true;
      const len = Math.max(0.001, Math.hypot(dx, dy));
      const nx = dx / len, ny = dy / len;
      const vx = ps(item, "xv", num(item.vx));
      const vy = ps(item, "yv", num(item.vy));
      const inward = vx * nx + vy * ny;
      if (inward < 0) {
        pset(item, "xv", vx - nx * inward * 0.58, `${reason}-normal-damp`);
        pset(item, "yv", vy - ny * inward * 0.58, `${reason}-normal-damp`);
      }
      commitBody(item);
      wakeItem(item, reason);
      return true;
    }
    if (item.type === "reciprocator") {
      resetAnchor(item);
      const a = axis(item);
      const along = dx * a.x + dy * a.y;
      if (!Number.isFinite(along) || Math.abs(along) < 0.001) return false;
      const before = ps(item, "railPhase", 0);
      pset(item, "railPhase", clamp(before + along / Math.max(10, halfTravel(item)), -1, 1), reason);
      const p = positionFromPhase(item);
      item.prevX = num(item.x);
      item.prevY = num(item.y);
      item.x = p.x;
      item.y = p.y;
      item._physicsExternalPoseDirty = true;
      const current = ps(item, "slideSpeed", 0);
      if (current * along < 0) pset(item, "slideSpeed", current * 0.38, `${reason}-slide-damp`);
      const changed = Math.abs(ps(item, "railPhase", 0) - before) > 0.0001;
      if (changed) commitBody(item);
      return changed;
    }
    return false;
  }

  function applyMechanicalPairSeparation(a, b, info, dt, worldRef) {
    if (!a || !b || !info) return false;
    const overlap = Math.max(0, num(info.overlap));
    if (overlap <= 0.001) return false;
    const nx = num(info.nx), ny = num(info.ny);
    const wa = mechanicalSeparationWeight(a, -nx, -ny);
    const wb = mechanicalSeparationWeight(b, nx, ny);
    const sum = wa + wb;
    if (sum <= 0.0001) return false;
    // Resolve the actual penetration only.  The former extra bias made bodies
    // visibly pop when many mechanical items touched at once.
    const correction = Math.min(Math.max(0, overlap - 0.05) * 0.92, 18);
    const ax = -nx * correction * (wa / sum);
    const ay = -ny * correction * (wa / sum);
    const bx = nx * correction * (wb / sum);
    const by = ny * correction * (wb / sum);
    const movedA = moveMechanicalBodyForSeparation(a, ax, ay, dt, "pair-separation");
    const movedB = moveMechanicalBodyForSeparation(b, bx, by, dt, "pair-separation");
    if (movedA || movedB) {
      worldRef?.markSpatialDirty?.("mechanical-pair-separation");
      worldRef && (worldRef.drawListDirty = true);
    }
    return movedA || movedB;
  }

  function applyMechanicalFenceSeparation(item, info, dt, worldRef) {
    if (!item || !info) return false;
    const overlap = Math.max(0, num(info.overlap));
    if (overlap <= 0.001) return false;
    const correction = Math.min(Math.max(0, overlap - 0.05) * 0.94, 20);
    const moved = moveMechanicalBodyForSeparation(item, -num(info.nx) * correction, -num(info.ny) * correction, dt, "fence-separation");
    if (moved) {
      worldRef?.markSpatialDirty?.("mechanical-fence-separation");
      worldRef && (worldRef.drawListDirty = true);
    }
    return moved;
  }


  function noteReciprocatorBlocked(item, dt = 0.016, worldRef = null, reason = "obstacle") {
    if (!item || item.dead || item.type !== "reciprocator" || !isPowered(item)) return false;
    const now = Number(worldRef?.time || item.world?.time || 0) || 0;
    const step = Math.max(0.012, Math.min(0.08, num(dt, 0.016)));
    if ((item._reciprocatorBlockedAt || -999) + 0.18 < now) item._reciprocatorBlockedTimer = 0;
    item._reciprocatorBlockedAt = now;
    item._reciprocatorBlockedTimer = Math.min(1.2, num(item._reciprocatorBlockedTimer) + step);
    const cooldownOk = (item._reciprocatorAutoReverseAt || -999) + 0.42 <= now;
    if (!cooldownOk || item._reciprocatorBlockedTimer < 0.34) return false;
    const before = Math.sign(ps(item, "railDir", 1)) || 1;
    pset(item, "railDir", -before, "slide-reverse");
    const body = ensureBody(item, { syncFromLegacy: false });
    if (body) {
      body.motor = body.motor || {};
      body.motor.direction = ps(item, "railDir", 1);
      body.velocity = body.velocity || {};
      body.velocity.linear = -Math.abs(num(body.velocity.linear, ps(item, "slideSpeed", 0))) * before * 0.20;
    }
    pset(item, "slideSpeed", -Math.abs(ps(item, "slideSpeed", 0)) * before * 0.20, "slide-reverse-passive");
    item._reciprocatorBlockedTimer = 0;
    item._reciprocatorAutoReverseAt = now;
    commitBody(item);
    worldRef?.markSpatialDirty?.("reciprocator-auto-reverse");
    worldRef && (worldRef.drawListDirty = true);
    return true;
  }

  function reverseReciprocatorOnContact(item, nx, ny, dt = 0.016, worldRef = null, reason = "mechanical-contact") {
    if (!item || item.dead || item.type !== "reciprocator" || !isPowered(item)) return false;
    const now = Number(worldRef?.time || item.world?.time || 0) || 0;
    // Only physical body contacts should interrupt the rail.  Static fences and
    // ordinary obstacles never call this function.
    if ((item._reciprocatorContactReverseAt || -999) + 0.12 > now) return false;
    const a = axis(item);
    const dir = Math.sign(ps(item, "railDir", 1)) || 1;
    const driveX = a.x * dir;
    const driveY = a.y * dir;
    const ahead = driveX * num(nx) + driveY * num(ny);
    // Side brushes and contacts behind the motor are allowed to slide. A
    // direct or moderately diagonal contact in the travel direction reverses.
    if (ahead < 0.18) return false;
    pset(item, "railDir", -dir, "slide-contact-reverse");
    pset(item, "slideSpeed", 0, "slide-contact-clear-slide");
    const body = ensureBody(item, { syncFromLegacy: false });
    if (body) {
      body.motor = body.motor || {};
      body.motor.direction = -dir;
      body.velocity = body.velocity || {};
      body.velocity.linear = 0;
    }
    item._reciprocatorBlockedTimer = 0;
    item._reciprocatorContactReverseAt = now;
    item._reciprocatorAutoReverseAt = now;
    commitBody(item);
    if (worldRef) {
      worldRef.drawListDirty = true;
      worldRef.markSpatialDirty?.("reciprocator-contact-reverse");
    }
    return true;
  }

  function brakeRotatorOnContact(item, dt = 0.016, worldRef = null, reason = "mechanical-contact") {
    if (!item || item.dead || item.type !== "rotator" || !isPowered(item)) return false;
    const now = Number(worldRef?.time || item.world?.time || 0) || 0;
    if ((item._rotatorContactBrakeAt || -999) + 0.045 > now) return false;
    const motorSpeed = Math.abs(ps(item, "motorSpeed", 0));
    if (motorSpeed <= 0) return false;
    const drive = signedDrive(item);
    const sign = Math.sign(drive || motorSpeed) || 1;
    const current = num(bodyVelocity(item)?.angular, ps(item, "spin", 0));
    // A powered rotator has a motor, so a contact must produce a temporary
    // counter-spin; otherwise two powered rotators visually pass through each
    // other while the motor keeps driving at full speed.
    const brake = Math.max(0.32, motorSpeed * 0.82);
    pset(item, "spin", clamp(current - sign * brake, -3.4, 3.4), "rotator-contact-brake");
    item._rotatorContactBrakeAt = now;
    commitBody(item);
    if (worldRef) {
      worldRef.drawListDirty = true;
      worldRef.markSpatialDirty?.("rotator-contact-brake");
    }
    return true;
  }

  function isPhysicalCircleContactObject(obj) {
    if (!obj || obj.dead) return false;
    const t = String(obj.type || "");
    // Tarinai also collide as circles, but a walking creature should not flip a
    // powered rail.  Keep contact reversal to item-like physical circles.
    if (t === "ball" || t === "stone" || t === "genkotsu" || t === "firecracker" || t === "pushpin" || t === "oshibyo" || t === "zunchi") return true;
    return Boolean(obj.physicsBody && !isMechanicalType(t));
  }

  function itemCircleRadius(obj) {
    if (!obj) return 12;
    const fromHelper = typeof global.itemRadiusFor === "function" ? global.itemRadiusFor(obj.type, obj.r || obj.radius || 12) : null;
    return Math.max(4, num(obj.radius, num(obj.r, Number.isFinite(Number(fromHelper)) ? Number(fromHelper) : 12)));
  }

  function orientedRectCircleContactInfo(rect, obj, radius, margin = 0.5) {
    if (!rect || !obj) return null;
    const r = Math.max(0, num(radius));
    const m = Math.max(0, num(margin));
    const cx = num(obj.x);
    const cy = num(obj.y);
    if (!rect.oriented) {
      const px = Math.max(num(rect.left) - m, Math.min(num(rect.right) + m, cx));
      const py = Math.max(num(rect.top) - m, Math.min(num(rect.bottom) + m, cy));
      let dx = cx - px;
      let dy = cy - py;
      let d = Math.hypot(dx, dy);
      if (d >= r + m) return null;
      if (d < 0.001) { dx = cx - num(rect.cx, (num(rect.left) + num(rect.right)) * 0.5); dy = cy - num(rect.cy, (num(rect.top) + num(rect.bottom)) * 0.5); d = Math.hypot(dx, dy) || 1; }
      return { nx: dx / d, ny: dy / d, x: px, y: py, overlap: Math.max(0, r + m - d) };
    }
    const c = Number.isFinite(rect.cos) ? rect.cos : Math.cos(num(rect.angle));
    const ss = Number.isFinite(rect.sin) ? rect.sin : Math.sin(num(rect.angle));
    const dxw = cx - num(rect.cx);
    const dyw = cy - num(rect.cy);
    const lx = dxw * c + dyw * ss;
    const ly = -dxw * ss + dyw * c;
    const qx = Math.max(-num(rect.halfW) - m, Math.min(num(rect.halfW) + m, lx));
    const qy = Math.max(-num(rect.halfH) - m, Math.min(num(rect.halfH) + m, ly));
    let dx = lx - qx;
    let dy = ly - qy;
    let d = Math.hypot(dx, dy);
    if (d >= r + m) return null;
    if (d < 0.001) {
      const left = Math.abs(lx + num(rect.halfW));
      const right = Math.abs(num(rect.halfW) - lx);
      const top = Math.abs(ly + num(rect.halfH));
      const bottom = Math.abs(num(rect.halfH) - ly);
      const minSide = Math.min(left, right, top, bottom);
      if (minSide === left) { dx = -1; dy = 0; }
      else if (minSide === right) { dx = 1; dy = 0; }
      else if (minSide === top) { dx = 0; dy = -1; }
      else { dx = 0; dy = 1; }
      d = 1;
    }
    const nx = dx / d * c - dy / d * ss;
    const ny = dx / d * ss + dy / d * c;
    const wx = num(rect.cx) + qx * c - qy * ss;
    const wy = num(rect.cy) + qx * ss + qy * c;
    return { nx, ny, x: wx, y: wy, overlap: Math.max(0, r + m - d) };
  }

  function resolveReciprocatorPhysicalContacts(item, dt = 0.016, worldRef = null) {
    // Circle contacts are solved as push-away contacts in resolveMechanicalCircleContacts().
    // A powered reciprocator must reverse at rail limits or mechanical blockers,
    // not merely because it touched Tarinai, a ball, or a pin-like item.
    if (!item || item.dead || item.type !== "reciprocator" || !isPowered(item) || !worldRef?.items) return false;
    return resolveMechanicalCircleContacts(item, dt, worldRef, reach(item) + 96);
  }


  function resolveMechanicalCircleContacts(item, dt = 0.016, worldRef = null, radius = null) {
    if (!item || item.dead || !isMechanicalType(item) || !worldRef?.items) return false;
    const rects = obstacleRects(item);
    if (!rects.length) return false;
    const queryRadius = radius || reach(item) + 96;
    const source = worldRef.nearbyItems?.(item.x, item.y, queryRadius, true) || worldRef.nearbyObstacles?.(item.x, item.y, queryRadius, false) || worldRef.items || [];
    let changed = false;
    let contacts = 0;
    for (const other of source) {
      if (!other || other === item || other.dead || !isPhysicalCircleContactObject(other)) continue;
      if (typeof isPinType === "function" && isPinType(other.type) && other.pinState === "lodged") continue;
      const rr = itemCircleRadius(other);
      if (Math.hypot(num(other.x) - num(item.x), num(other.y) - num(item.y)) > queryRadius + rr + 12) continue;
      let best = null;
      for (const rect of rects) {
        const info = orientedRectCircleContactInfo(rect, other, rr, 2.75);
        if (!info) continue;
        if (!best || info.overlap > best.overlap) best = info;
      }
      if (!best) continue;
      const nx = Number.isFinite(best.nx) ? best.nx : 1;
      const ny = Number.isFinite(best.ny) ? best.ny : 0;
      const sep = Math.max(0.5, Math.min(28, best.overlap + 1.4));
      if (Number.isFinite(other.x)) other.x += nx * sep;
      if (Number.isFinite(other.y)) other.y += ny * sep;
      const v = pointVelocity(item, best.x, best.y);
      const closing = Math.max(0, v.x * nx + v.y * ny);
      const baseImpulse = clamp(best.overlap * 7.2 + closing * 0.24 + 8.0, 5.5, item.type === "reciprocator" ? 150 : 210);
      if (Number.isFinite(other.vx)) other.vx = clamp((other.vx || 0) + nx * baseImpulse, -1180, 1180);
      if (Number.isFinite(other.vy)) other.vy = clamp((other.vy || 0) + ny * baseImpulse, -1180, 1180);
      if (other.type === "ball") {
        other.prevX = Number.isFinite(other.prevX) ? other.prevX : other.x - nx * sep;
        other.prevY = Number.isFinite(other.prevY) ? other.prevY : other.y - ny * sep;
        other.spinVelocity = clamp((other.spinVelocity || 0) + (nx >= 0 ? -1 : 1) * (5.8 + Math.min(10, closing * 0.02)), -48, 48);
        other.lastKickedAt = worldRef.time || 0;
        other.lastKickerId = item.id || "mechanical";
      }
      if (item.type === "reciprocator") {
        // Balls, stones, pins and other movable circle items are cargo, not rail
        // blockers.  The reciprocator may push them, but its direction, phase
        // and motor velocity are left untouched.
      } else {
        applyImpulse(item, best.x, best.y, -nx * baseImpulse * (item.type === "poison_block" ? 0.38 : 0.16), -ny * baseImpulse * (item.type === "poison_block" ? 0.38 : 0.16), item.type === "poison_block" ? 0.58 : 0.34);
        if (item.type === "rotator") brakeRotatorOnContact(item, dt, worldRef, "physical-circle");
      }
      contacts += 1;
      changed = true;
      if (contacts >= 18) break;
    }
    if (changed) {
      commitBody(item);
      worldRef.markSpatialDirty?.("mechanical-circle-contact");
      worldRef.drawListDirty = true;
    }
    return changed;
  }

  function strongestRectContact(rectsA, rectsB, padding = 0) {
    let best = null;
    for (const ra of rectsA || []) {
      for (const rb of rectsB || []) {
        const info = rectOverlapInfo(ra, rb, padding);
        if (!info) continue;
        if (!best || info.overlap > best.info.overlap) best = { ra, rb, info };
      }
    }
    return best;
  }

  function pairFrameGuard(a, b, worldRef, budget = 6) {
    if (!worldRef || !a || !b) return false;
    const frame = Number(worldRef.frameCount || worldRef.tickCount || worldRef._frameId || 0) || Math.floor((Number(worldRef.time || 0) || 0) * 60);
    if (worldRef._mechanicalPairGuardFrame !== frame) {
      worldRef._mechanicalPairGuardFrame = frame;
      worldRef._mechanicalPairFrameAt = Object.create(null);
    }
    const key = a.id < b.id ? `${a.id}:${b.id}` : `${b.id}:${a.id}`;
    const packed = worldRef._mechanicalPairFrameAt[key];
    if (packed && packed.count >= budget) return true;
    worldRef._mechanicalPairFrameAt[key] = { count: packed ? packed.count + 1 : 1 };
    return false;
  }

  function resolvePair(a, b, dt, worldRef) {
    if (!a || !b || a.dead || b.dead || !isMechanicalType(a) || !isMechanicalType(b)) return false;
    if (pairFrameGuard(a, b, worldRef, 6)) return false;
    let contact = strongestRectContact(obstacleRects(a), obstacleRects(b), 0.75);
    if (!contact) return false;
    let info = contact.info;
    // Reverse from the initial impact. Separation can fully clear the overlap,
    // but that still represents a real collision and must not skip reversal.
    if (a.type === "reciprocator") reverseReciprocatorOnContact(a, info.nx, info.ny, dt, worldRef, "mechanical");
    if (b.type === "reciprocator") reverseReciprocatorOnContact(b, -info.nx, -info.ny, dt, worldRef, "mechanical");
    const separated = applyMechanicalPairSeparation(a, b, info, dt, worldRef);
    if (separated) {
      // Position projection may fully clear the overlap.  Re-query before adding
      // impulses; otherwise the solver turns a successful separation into a new kick.
      contact = strongestRectContact(obstacleRects(a), obstacleRects(b), 0.25);
      if (!contact) {
        if (worldRef) { worldRef.drawListDirty = true; worldRef.markSpatialDirty?.("mechanical-contact-separated"); }
        return true;
      }
      info = contact.info;
    }
    const va = pointVelocity(a, info.x, info.y);
    const vb = pointVelocity(b, info.x, info.y);
    const relClosing = (va.x - vb.x) * info.nx + (va.y - vb.y) * info.ny;
    const closing = Math.max(0, relClosing);
    const powerMul = isPowered(a) && isPowered(b) ? 1.18 : (isPowered(a) || isPowered(b) ? 1.02 : 0.72);
    const impulse = clamp((closing * 0.14 + info.overlap * 4.7 + 3.2) * powerMul, 2.5, separated ? 42 : 68);

    applyImpulse(a, info.x, info.y, -info.nx * impulse, -info.ny * impulse, separated ? 0.78 : 1.0);
    applyImpulse(b, info.x, info.y, info.nx * impulse, info.ny * impulse, separated ? 0.78 : 1.0);
    applyRailCorrection(a, info.nx, info.ny, info.overlap, b.type === "reciprocator" ? 0.42 : 0.72);
    applyRailCorrection(b, -info.nx, -info.ny, info.overlap, a.type === "reciprocator" ? 0.42 : 0.72);
    if (a.type === "rotator") brakeRotatorOnContact(a, dt, worldRef, "mechanical");
    if (b.type === "rotator") brakeRotatorOnContact(b, dt, worldRef, "mechanical");

    if (worldRef) { worldRef.drawListDirty = true; worldRef.markSpatialDirty?.("mechanical-contact"); }
    return true;
  }

  function fenceRectsNear(item, worldRef, radius) {
    const out = [];
    if (!item || !worldRef?.items) return out;
    const source = worldRef.nearbyItems?.(item.x, item.y, radius, true) || worldRef.nearbyObstacles?.(item.x, item.y, radius, false) || worldRef.items;
    for (const other of source) {
      if (!other || other === item || other.dead || isMechanicalType(other)) continue;
      if (other.type === "gate_fence" && other.gateOpen) continue;
      for (const rect of worldRef.solidObstacleRects?.(other) || []) out.push(rect);
    }
    return out;
  }

  function hasFenceNearby(item, worldRef, radius) {
    if (!item || !worldRef?.items) return false;
    const source = worldRef.nearbyItems?.(item.x, item.y, radius, true) || worldRef.items;
    for (const other of source) {
      if (!other || other === item || other.dead || !worldRef.isFenceType?.(other.type)) continue;
      if (other.type === "gate_fence" && other.gateOpen) continue;
      return true;
    }
    return false;
  }

  function resolveFenceContacts(item, dt, worldRef, radius = null) {
    if (!item || !worldRef || !isMechanicalType(item)) return false;
    const rects = obstacleRects(item);
    const fences = fenceRectsNear(item, worldRef, radius || reach(item) + 80);
    let changed = false;
    for (const mechRect of rects) {
      for (const fenceRect of fences) {
        const velocity = bodyVelocity(item);
        const vx = Number(velocity?.x || item.vx || 0);
        const vy = Number(velocity?.y || item.vy || 0);
        if (fenceRect?.oneWay && global.TarinaiGeometry.oneWayFenceAllows(item, fenceRect, vx, vy)) continue;
        let info = rectOverlapInfo(mechRect, fenceRect, item.type === "rotator" ? 1.35 : 0.5);
        if (!info) continue;
        if (item.type === "reciprocator") reverseReciprocatorOnContact(item, info.nx, info.ny, dt, worldRef, "solid-obstacle");
        const separated = applyMechanicalFenceSeparation(item, info, dt, worldRef);
        if (separated) {
          const post = strongestRectContact(obstacleRects(item), [fenceRect], 0.2);
          if (!post) { changed = true; continue; }
          info = post.info;
        }
        const v = pointVelocity(item, info.x, info.y);
        const closing = Math.max(0, v.x * info.nx + v.y * info.ny);
        const impulse = clamp(closing * 0.18 + info.overlap * 6.6 + 4.5, 3.5, separated ? 58 : 92);
        applyImpulse(item, info.x, info.y, -info.nx * impulse, -info.ny * impulse, separated ? 0.92 : 1.10);
        applyRailCorrection(item, info.nx, info.ny, info.overlap, 0.82);
        if (item.type === "rotator") brakeRotatorOnContact(item, dt, worldRef, "fence");
        changed = true;
      }
    }
    if (changed) { worldRef.drawListDirty = true; worldRef.markSpatialDirty?.("mechanism-fence-contact"); }
    return changed;
  }

  function hasInteractionCandidates(item, worldRef, radius = null) {
    if (!item || !worldRef) return false;
    const r = radius || reach(item) + 80;
    const source = worldRef.nearbyItems?.(item.x, item.y, r, true) || worldRef.nearbyObstacles?.(item.x, item.y, r, false) || worldRef.items || [];
    for (const other of source) {
      if (!other || other === item || other.dead) continue;
      if (isMechanicalType(other) || worldRef.isFenceType?.(other.type) || isPhysicalCircleContactObject(other)) return true;
      if (worldRef.solidObstacleRects?.(other)?.length) return true;
    }
    return false;
  }

  function resolveInteractions(item, dt, worldRef) {
    if (!item || !worldRef?.items || !isMechanicalType(item)) return false;
    let changed = false;
    const radius = reach(item) + 80;
    const source = worldRef.nearbyItems?.(item.x, item.y, radius, true) || worldRef.nearbyObstacles?.(item.x, item.y, radius, false) || worldRef.items;
    for (const other of source) {
      if (!other || other === item || other.dead || !isMechanicalType(other)) continue;
      changed = resolvePair(item, other, dt, worldRef) || changed;
    }
    changed = resolveMechanicalCircleContacts(item, dt, worldRef, radius) || changed;
    changed = resolveFenceContacts(item, dt, worldRef, radius) || changed;
    return changed;
  }

  function updateRotator(item, dt, worldRef, opts = {}) {
    if (!item || item.dead || item.type !== "rotator") return false;
    if (opts.statePrepared !== true) applyBodyState(item);
    return runMechanicalStep(item, () => {
      item.amount = 999;
      if (item.playerHeld || item._heldByPlayer) return false;
      const powered = isPowered(item);
      const passiveSpeed = ps(item, "spin", 0);
      const speed = (powered ? ps(item, "motorSpeed", 0) : 0) + passiveSpeed;
      pset(item, "spin", passiveSpeed * Math.pow(powered ? 0.18 : 0.88, Math.max(0.016, dt || 0.016)), "spin-friction");
      if (Math.abs(ps(item, "spin", 0)) < 0.004) pset(item, "spin", 0, "spin-stop");
      const ext = extent(item);
      item.r = Math.max(item.r || 64, Math.min(460, ext));
      const skipInteractions = opts.skipInteractions === true || opts.centralStep === true;
      if (!speed || !Number.isFinite(speed)) return (!skipInteractions && hasInteractionCandidates(item, worldRef, ext + 90)) ? resolveInteractions(item, dt, worldRef) : false;
      const totalDelta = speed * dt;
      if (skipInteractions || !hasInteractionCandidates(item, worldRef, ext + 100)) {
        item.prevAngle = num(item.angle);
        item.angle = normalizeAngle(num(item.angle) + totalDelta);
        item.rotatorSpinPhase = num(item.rotatorSpinPhase) + Math.abs(speed) * dt;
        if (worldRef && opts.deferDirty !== true) { worldRef.drawListDirty = true; worldRef.markSpatialDirty?.("rotator-spin-fast"); }
        return true;
      }
      const maxAngleStep = clamp(thickness(item) / Math.max(90, ext) * 0.75, 0.018, 0.055);
      const steps = Math.max(1, Math.min(36, Math.ceil(Math.abs(totalDelta) / maxAngleStep)));
      const stepDelta = totalDelta / steps;
      const stepDt = Math.max(0.001, (dt || 0.016) / steps);
      for (let i = 0; i < steps; i += 1) {
        item.prevAngle = num(item.angle);
        item.angle = normalizeAngle(num(item.angle) + stepDelta);
        if (!skipInteractions) resolveInteractions(item, stepDt, worldRef);
      }
      item.rotatorSpinPhase = num(item.rotatorSpinPhase) + Math.abs(speed) * dt;
      if (worldRef && opts.deferDirty !== true) { worldRef.drawListDirty = true; worldRef.markSpatialDirty?.("rotator-spin"); }
      return true;
    });
  }

  function integrateReciprocatorPhase(item, total, stepDt, powered, reason = "rail-integrate") {
    if (!item || item.dead || item.type !== "reciprocator") return false;
    const travel = Math.max(10, halfTravel(item));
    const before = ps(item, "railPhase", 0);
    const step = Math.max(0.001, num(stepDt, 0.016));
    const drive = num(total);
    const raw = before + drive * step / travel;
    if (!Number.isFinite(raw)) return false;
    const eps = 0.000001;
    if (powered && ((before >= 1 - eps && drive > 0) || raw >= 1)) {
      pset(item, "railPhase", 1, "rail-limit");
      pset(item, "railDir", -1, "rail-limit-reverse");
      pset(item, "slideSpeed", 0, "rail-limit-clear-slide");
      return true;
    }
    if (powered && ((before <= -1 + eps && drive < 0) || raw <= -1)) {
      pset(item, "railPhase", -1, "rail-limit");
      pset(item, "railDir", 1, "rail-limit-reverse");
      pset(item, "slideSpeed", 0, "rail-limit-clear-slide");
      return true;
    }
    if (raw > 1) {
      pset(item, "railPhase", 1, "rail-limit");
      if (!powered) pset(item, "slideSpeed", -Math.abs(drive) * 0.20, "rail-limit-bounce");
      return Math.abs(before - 1) > 0.0001;
    }
    if (raw < -1) {
      pset(item, "railPhase", -1, "rail-limit");
      if (!powered) pset(item, "slideSpeed", Math.abs(drive) * 0.20, "rail-limit-bounce");
      return Math.abs(before + 1) > 0.0001;
    }
    pset(item, "railPhase", raw, reason);
    return Math.abs(raw - before) > 0.0001;
  }

  function repairPoweredReciprocatorStall(item, dt = 0.016, moved = 0, worldRef = null) {
    if (!item || item.dead || item.type !== "reciprocator" || !isPowered(item)) return false;
    const motorSpeed = Math.max(0, ps(item, "railMotorSpeed", 92));
    if (motorSpeed <= 0.001) return false;
    const phase = ps(item, "railPhase", 0);
    const dir = Math.sign(ps(item, "railDir", 1)) || 1;
    let changed = false;
    if (phase >= 1 - 0.000001 && dir > 0) { pset(item, "railDir", -1, "rail-stall-limit-repair"); changed = true; }
    else if (phase <= -1 + 0.000001 && dir < 0) { pset(item, "railDir", 1, "rail-stall-limit-repair"); changed = true; }
    if (Math.abs(num(moved)) <= 0.001) {
      const now = Number(worldRef?.time || item.world?.time || 0) || 0;
      if ((item._reciprocatorMovedAt || -999) + 0.18 < now) {
        // Do not nudge the rail body forward.  Treat a stalled powered rail as
        // blocked and let the existing blocked/reverse path decide the next move.
        pset(item, "slideSpeed", 0, "rail-stall-slide-clear");
        if (!changed && Math.abs(phase) < 1 - 0.000001) {
          changed = noteReciprocatorBlocked(item, dt, worldRef, "rail-stall-blocked") || changed;
        }
      }
    } else {
      item._reciprocatorMovedAt = Number(worldRef?.time || item.world?.time || 0) || 0;
    }
    if (!changed) return false;
    const p = positionFromPhase(item);
    item.x = p.x;
    item.y = p.y;
    commitBody(item);
    worldRef?.markSpatialDirty?.("reciprocator-stall-repair");
    if (worldRef) worldRef.drawListDirty = true;
    return true;
  }

  function updateReciprocator(item, dt, worldRef, opts = {}) {
    if (!item || item.dead || item.type !== "reciprocator") return false;
    if (opts.statePrepared !== true) applyBodyState(item);
    return runMechanicalStep(item, () => {
      item.amount = 999;
      resetAnchor(item);
      if (item.playerHeld || item._heldByPlayer) { item.prevX = item.x; item.prevY = item.y; return false; }
      const powered = isPowered(item);
      const prevX = num(item.x, ps(item, "railAnchorX", 0)), prevY = num(item.y, ps(item, "railAnchorY", 0));
      item.prevX = prevX; item.prevY = prevY;
      const baseSpeed = Math.max(0, ps(item, "railMotorSpeed", 92));
      const estimateVelocity = (powered ? Math.sign(ps(item, "railDir", 1)) * baseSpeed : 0) + ps(item, "slideSpeed", 0);
      const skipInteractions = opts.skipInteractions === true || opts.centralStep === true;
      const steps = Math.max(1, Math.min(32, Math.ceil(Math.abs(estimateVelocity * dt) / 8)));
      const stepDt = Math.max(0.001, (dt || 0.016) / steps);
      if (Math.abs(estimateVelocity) > 0.001 && (skipInteractions || !hasInteractionCandidates(item, worldRef, reach(item) + 110))) {
        const dir = Math.sign(ps(item, "railDir", 1)) || 1;
        const passive = ps(item, "slideSpeed", 0);
        const total = (powered ? dir * baseSpeed : 0) + passive;
        integrateReciprocatorPhase(item, total, dt || 0.016, powered, "rail-integrate");
        const p = positionFromPhase(item);
        item.x = p.x; item.y = p.y;
        if (powered) resolveReciprocatorPhysicalContacts(item, dt || 0.016, worldRef);
      } else for (let i = 0; i < steps; i += 1) {
        const dir = Math.sign(ps(item, "railDir", 1)) || 1;
        const passive = ps(item, "slideSpeed", 0);
        const total = (powered ? dir * baseSpeed : 0) + passive;
        if (Number.isFinite(total) && Math.abs(total) > 0.001) {
          integrateReciprocatorPhase(item, total, stepDt, powered, "rail-integrate");
        }
        const p = positionFromPhase(item);
        item.x = p.x; item.y = p.y;
        if (powered) resolveReciprocatorPhysicalContacts(item, stepDt, worldRef);
        if (!skipInteractions) resolveInteractions(item, stepDt, worldRef);
      }
      pset(item, "slideSpeed", ps(item, "slideSpeed", 0) * Math.pow(powered ? 0.22 : 0.90, Math.max(0.016, dt || 0.016)), "slide-friction");
      if (Math.abs(ps(item, "slideSpeed", 0)) < 0.08) pset(item, "slideSpeed", 0, "slide-stop");
      let moved = Math.hypot(num(item.x) - prevX, num(item.y) - prevY);
      if (repairPoweredReciprocatorStall(item, dt || 0.016, moved, worldRef)) moved = Math.hypot(num(item.x) - prevX, num(item.y) - prevY);
      if (moved > 0.001 || Math.abs(ps(item, "slideSpeed", 0)) > 0.001 || powered) {
        if (worldRef && opts.deferDirty !== true) { worldRef.drawListDirty = true; worldRef.markSpatialDirty?.("reciprocator-motion"); }
        return true;
      }
      return false;
    });
  }

  function constrainPassiveBlockInsideWorld(item, worldRef) {
    if (!item || !worldRef) return false;
    const pad = Number(global.CONFIG?.worldPadding || 16) || 16;
    const reachValue = Math.max(24, reach(item));
    let changed = false;
    if (num(item.x) < pad + reachValue * 0.25) { item.x = pad + reachValue * 0.25; pset(item, "xv", Math.abs(ps(item, "xv", 0)) * 0.38, "world-boundary"); changed = true; }
    if (num(item.y) < pad + reachValue * 0.25) { item.y = pad + reachValue * 0.25; pset(item, "yv", Math.abs(ps(item, "yv", 0)) * 0.38, "world-boundary"); changed = true; }
    if (num(item.x) > num(worldRef.w, 1000) - pad - reachValue * 0.25) { item.x = num(worldRef.w, 1000) - pad - reachValue * 0.25; pset(item, "xv", -Math.abs(ps(item, "xv", 0)) * 0.38, "world-boundary"); changed = true; }
    if (num(item.y) > num(worldRef.h, 800) - pad - reachValue * 0.25) { item.y = num(worldRef.h, 800) - pad - reachValue * 0.25; pset(item, "yv", -Math.abs(ps(item, "yv", 0)) * 0.38, "world-boundary"); changed = true; }
    return changed;
  }

  function resolvePoisonBlockTarinaiContacts(item, worldRef, dt = 0.016) {
    if (!item || item.dead || item.type !== "poison_block" || !worldRef?.tarinai) return false;
    if (ps(item, "solid", true) === false) return false;
    const rects = obstacleRects(item);
    if (!rects.length) return false;
    const radius = reach(item) + 96;
    const source = worldRef.nearbyTarinai?.(item.x, item.y, radius + 48) || worldRef.tarinai || [];
    let changed = false;
    let contacts = 0;
    for (const t of source) {
      if (!t || t.dead || worldRef.isTarinaiHiddenInNestBox?.(t)) continue;
      const rr = Math.max(8, (Number(t.radius) || 22) * 0.74);
      if (Math.hypot(num(t.x) - num(item.x), num(t.y) - num(item.y)) > radius + rr) continue;
      for (const rect of rects) {
        if (!global.TarinaiGeometry.circleOverlapsRect(t.x, t.y, rr, rect, 1.0)) continue;
        const beforeX = num(t.x);
        const beforeY = num(t.y);
        const pushed = worldRef.pushTarinaiOutOfRect?.(t, rect, rr, {
          maxPush: Math.max(14, rr * 1.65),
          slop: 0.45,
        });
        if (!pushed) continue;
        contacts += 1;
        changed = true;
        const dx = num(t.x) - beforeX;
        const dy = num(t.y) - beforeY;
        const d = Math.hypot(dx, dy);
        if (d > 0.001) {
          // Eating/sleeping bodies can be nearly stationary.  Feed a small,
          // opposite impulse back into the passive block so the contact is not
          // visually perceived as the block tunneling through the Tarinai.
          const nx = dx / d;
          const ny = dy / d;
          const speed = Math.hypot(ps(item, "xv", 0), ps(item, "yv", 0));
          const impulse = Math.min(34, 5.5 + d * 0.85 + speed * 0.035);
          applyImpulse(item, num(t.x) - nx * rr, num(t.y) - ny * rr, -nx * impulse, -ny * impulse, 0.42);
          t.lastSolidObstacleCollisionSource = item;
          t.lastSolidObstacleCollisionAt = worldRef.time || 0;
        }
        break;
      }
      if (contacts >= 10) break;
    }
    if (changed) {
      commitBody(item);
      worldRef.markSpatialDirty?.("poison-block-tarinai-contact");
      worldRef.drawListDirty = true;
    }
    return changed;
  }

  function updatePoisonBlock(item, dt, worldRef, opts = {}) {
    if (!item || item.dead || item.type !== "poison_block") return false;
    if (opts.statePrepared !== true) applyBodyState(item);
    return runMechanicalStep(item, () => {
      item.amount = 999;
      item.r = Math.max(item.r || 64, Math.min(460, extent(item)));
      if (item.playerHeld || item._heldByPlayer) {
        item.prevX = item.x;
        item.prevY = item.y;
        item.prevAngle = num(item.angle);
        return false;
      }
      const stepTime = Math.max(0.001, Math.min(0.05, num(dt, 0.016)));
      if (!passiveItemAwake(item)) return false;
      const vx = ps(item, "xv", 0), vy = ps(item, "yv", 0), omega = ps(item, "spin", 0);
      const moveEstimate = Math.hypot(vx, vy) * stepTime;
      const rotEstimate = Math.abs(omega) * stepTime * Math.max(48, item.r || 64);
      const skipInteractions = opts.skipInteractions === true || opts.centralStep === true;
      const hasContacts = !skipInteractions && ps(item, "solid", true) !== false && hasInteractionCandidates(item, worldRef, reach(item) + 110);
      const steps = hasContacts ? Math.max(1, Math.min(28, Math.ceil(Math.max(moveEstimate, rotEstimate) / 8))) : 1;
      const subDt = stepTime / steps;
      let changed = false;
      for (let i = 0; i < steps; i += 1) {
        const beforeX = num(item.x), beforeY = num(item.y), beforeA = num(item.angle);
        item.prevX = beforeX;
        item.prevY = beforeY;
        item.prevAngle = beforeA;
        item.x = beforeX + ps(item, "xv", 0) * subDt;
        item.y = beforeY + ps(item, "yv", 0) * subDt;
        item.angle = normalizeAngle(beforeA + ps(item, "spin", 0) * subDt);
        changed = constrainPassiveBlockInsideWorld(item, worldRef) || changed;
        if (hasContacts) changed = resolveInteractions(item, subDt, worldRef) || changed;
        changed = resolvePoisonBlockTarinaiContacts(item, worldRef, subDt) || changed;
        changed = changed || Math.hypot(num(item.x) - beforeX, num(item.y) - beforeY) > 0.001 || Math.abs(num(item.angle) - beforeA) > 0.0001;
      }
      const friction = Math.pow(0.42, stepTime);
      const spinFriction = Math.pow(0.36, stepTime);
      pset(item, "xv", ps(item, "xv", 0) * friction, "poison-friction");
      pset(item, "yv", ps(item, "yv", 0) * friction, "poison-friction");
      pset(item, "spin", ps(item, "spin", 0) * spinFriction, "poison-spin-friction");
      if (Math.abs(ps(item, "xv", 0)) < 0.035) pset(item, "xv", 0, "poison-stop");
      if (Math.abs(ps(item, "yv", 0)) < 0.035) pset(item, "yv", 0, "poison-stop");
      if (Math.abs(ps(item, "spin", 0)) < 0.0015) pset(item, "spin", 0, "poison-spin-stop");
      if (item.physicsBody?.velocity) {
        item.vx = num(item.physicsBody.velocity.x);
        item.vy = num(item.physicsBody.velocity.y);
      }
      if (changed && worldRef && opts.deferDirty !== true) { worldRef.drawListDirty = true; worldRef.markSpatialDirty?.("poison-block-motion"); }
      return changed;
    });
  }



  function shouldCollideMechanical(item) {
    if (!item || item.dead || !isMechanicalType(item)) return false;
    if (item.playerHeld || item._heldByPlayer) return false;
    if (bodyOf(item)?.collision?.solid === false) return false;
    return obstacleRects(item).length > 0;
  }

  function isMechanicallyActive(item) {
    if (!item || item.dead || !isMechanicalType(item)) return false;
    if (item.playerHeld || item._heldByPlayer) return false;
    if (item.type === "rotator") return motionLevel(item) > 0.55;
    if (item.type === "reciprocator") return motionLevel(item) > 0.08;
    if (item.type === "poison_block") return passiveItemAwake(item);
    return false;
  }

  function collectMechanicalBodies(worldRef, opts = {}) {
    if (!worldRef?.itemsOfType) return [];
    worldRef.ensureItemBuckets?.("mechanical-world");
    const maxItems = Math.max(24, Number(opts.maxItems || 220) || 220);
    const cacheKey = `${worldRef.itemBucketRebuildsTotal || 0}:${maxItems}`;
    const cached = worldRef._mechanicalBodiesCache;
    if (cached?.key === cacheKey && Array.isArray(cached.items)) {
      let write = 0;
      for (let read = 0; read < cached.items.length; read += 1) {
        const item = cached.items[read];
        if (item && !item.dead) cached.items[write++] = item;
      }
      cached.items.length = write;
      return cached.items;
    }
    const out = [];
    const seen = worldRef._mechanicalBodiesSeen || (worldRef._mechanicalBodiesSeen = new Set());
    seen.clear();
    const add = (item) => {
      if (!item || item.dead || seen.has(item)) return false;
      item.world = worldRef;
      ensureBody(item, { syncFromLegacy: false });
      item.amount = 999;
      seen.add(item);
      out.push(item);
      return true;
    };
    // Powered reciprocators are autonomous motors.  They must not be starved by
    // the broad mechanical body cap, otherwise they appear to stop in empty
    // space and only move again after another item touches them.
    for (const item of worldRef.itemsOfType("reciprocator") || []) {
      if (!item || item.dead) continue;
      ensureBody(item, { syncFromLegacy: false });
      if (isPowered(item) || Math.abs(num(bodyVelocity(item)?.linear, ps(item, "slideSpeed", 0))) > 0.08) add(item);
    }
    for (const type of ["rotator", "poison_block", "reciprocator"]) {
      for (const item of worldRef.itemsOfType(type) || []) {
        if (!item || item.dead || seen.has(item)) continue;
        if (out.length >= maxItems) break;
        add(item);
      }
      if (out.length >= maxItems) break;
    }
    worldRef._mechanicalBodiesCache = { key: cacheKey, items: out };
    return out;
  }

  function bodyAabb(item, pad = 0) {
    const b = boundsAabb(item);
    if (!b) return null;
    return {
      left: b.left - pad,
      right: b.right + pad,
      top: b.top - pad,
      bottom: b.bottom + pad,
      item,
    };
  }

  function bodyAabbOverlap(a, b, pad = 0) {
    return footprints?.aabbOverlap?.(a, b, pad) ?? false;
  }

  function pairKey(a, b) {
    const ai = a?.id ?? "a";
    const bi = b?.id ?? "b";
    return ai < bi ? `${ai}:${bi}` : `${bi}:${ai}`;
  }

  function physicsFrameId(worldRef) {
    if (!worldRef) return 0;
    const frame = Number(worldRef.frameCount || worldRef.tickCount || worldRef._frameId || 0);
    if (Number.isFinite(frame) && frame > 0) return frame;
    return Math.floor((Number(worldRef.time || 0) || 0) * 60);
  }

  function makeBodyRecord(item, activeSet = null, pad = 6) {
    if (!item || item.dead || !isMechanicalType(item)) return null;
    const collidable = shouldCollideMechanical(item);
    const active = activeSet ? activeSet.has(item) : isMechanicallyActive(item);
    return {
      item,
      active,
      collidable,
      aabb: collidable ? bodyAabb(item, pad) : null,
      reach: reach(item),
    };
  }

  function buildMechanicalFrame(worldRef, opts = {}) {
    const bodies = Array.isArray(opts.bodies) ? opts.bodies : collectMechanicalBodies(worldRef, opts);
    const activeSet = opts.activeSet || (worldRef?._mechanicalActiveSet || (worldRef._mechanicalActiveSet = new Set()));
    if (!opts.activeSet) activeSet.clear();
    if (!opts.activeSet) {
      for (const item of bodies) if (isMechanicallyActive(item)) activeSet.add(item);
    }
    const focus = opts.focus !== false && worldRef?.nearbyObstacles && bodies.length > Math.max(36, Number(opts.focusThreshold || 48) || 48) && activeSet.size > 0 && activeSet.size < bodies.length * 0.65;
    let source = bodies;
    if (focus) {
      const chosen = worldRef._mechanicalFocusedSet || (worldRef._mechanicalFocusedSet = new Set());
      chosen.clear();
      for (const item of activeSet) chosen.add(item);
      for (const item of activeSet) {
        const radius = Math.max(90, reach(item) + 128);
        const candidates = worldRef.nearbyObstacles?.(item.x || 0, item.y || 0, radius, false) || [];
        for (const other of candidates) {
          if (!other || other === item || other.dead || !isMechanicalType(other.type)) continue;
          chosen.add(other);
        }
      }
      source = worldRef._mechanicalFocusedSource || (worldRef._mechanicalFocusedSource = []);
      source.length = 0;
      for (const item of chosen) source.push(item);
    }
    const pad = Number.isFinite(Number(opts.aabbPad)) ? Number(opts.aabbPad) : 6;
    const records = worldRef?._mechanicalFrameRecords || (worldRef._mechanicalFrameRecords = []);
    const byItem = worldRef?._mechanicalFrameByItem || (worldRef._mechanicalFrameByItem = new Map());
    records.length = 0;
    byItem.clear();
    let active = activeSet.size;
    let collidable = 0;
    for (const item of source) {
      const rec = makeBodyRecord(item, activeSet, pad);
      if (!rec) continue;
      records.push(rec);
      byItem.set(item, rec);
      if (rec.collidable && rec.aabb) collidable += 1;
    }
    return {
      frame: physicsFrameId(worldRef),
      time: Number(worldRef?.time || 0) || 0,
      bodies,
      activeSet,
      records,
      byItem,
      active,
      collidable,
      focused: focus,
      sourceCount: source.length,
    };
  }

  function broadphaseCandidateRecords(worldRef, frame, opts = {}) {
    if (!frame?.records?.length) return [];
    const all = frame.records.filter(r => r && r.collidable && r.aabb);
    const active = all.filter(r => r.active);
    if (!active.length) return [];
    const minUseFocused = Number(opts.focusThreshold || 48) || 48;
    // When only a few bodies are awake, build the broadphase around those
    // bodies plus nearby mechanical neighbors instead of scanning every static
    // collider in the field.
    if (!worldRef?.nearbyObstacles || all.length <= minUseFocused || active.length > Math.max(10, all.length * 0.45)) return all;
    const chosen = worldRef._mechanicalBroadphaseChosen || (worldRef._mechanicalBroadphaseChosen = new Set());
    chosen.clear();
    for (const r of active) chosen.add(r.item);
    const mech = global.TarinaiMechanicalSystem;
    for (const r of active) {
      const item = r.item;
      const radius = Math.max(90, (r.reach || reach(item)) + 128);
      const candidates = worldRef.nearbyObstacles?.(item.x || 0, item.y || 0, radius, false) || [];
      for (const other of candidates) {
        if (!other || other === item || other.dead || !mech?.isMechanicalType?.(other.type)) continue;
        chosen.add(other);
      }
    }
    const out = worldRef._mechanicalBroadphaseRecords || (worldRef._mechanicalBroadphaseRecords = []);
    out.length = 0;
    for (const item of chosen) {
      const cached = frame.byItem.get(item);
      const rec = cached || makeBodyRecord(item, frame.activeSet, Number.isFinite(Number(opts.aabbPad)) ? Number(opts.aabbPad) : 6);
      if (rec?.collidable && rec.aabb) out.push(rec);
    }
    return out;
  }

  function buildColliderGrid(records, opts = {}, gridScratch = null) {
    const cellSize = Math.max(96, Number(opts.cellSize || 156) || 156);
    const grid = gridScratch || new Map();
    grid.clear();
    const maxCellsPerBody = Math.max(4, Number(opts.maxCellsPerBody || 64) || 64);
    let inserted = 0;
    for (const rec of records || []) {
      if (!rec?.aabb) continue;
      const a = rec.aabb;
      const minX = Math.floor(a.left / cellSize);
      const maxX = Math.floor(a.right / cellSize);
      const minY = Math.floor(a.top / cellSize);
      const maxY = Math.floor(a.bottom / cellSize);
      let cells = (maxX - minX + 1) * (maxY - minY + 1);
      if (!Number.isFinite(cells) || cells <= 0) cells = 1;
      if (cells > maxCellsPerBody) {
        // Oversized AABBs can explode grid insertion cost. Center-bucketing
        // keeps the frame bounded; the later narrowphase still checks geometry.
        const key = `${Math.floor(((a.left + a.right) * 0.5) / cellSize)}:${Math.floor(((a.top + a.bottom) * 0.5) / cellSize)}`;
        let bucket = grid.get(key);
        if (!bucket) { bucket = []; grid.set(key, bucket); }
        bucket.push(rec);
        inserted += 1;
        continue;
      }
      for (let cy = minY; cy <= maxY; cy += 1) {
        for (let cx = minX; cx <= maxX; cx += 1) {
          const key = `${cx}:${cy}`;
          let bucket = grid.get(key);
          if (!bucket) { bucket = []; grid.set(key, bucket); }
          bucket.push(rec);
          inserted += 1;
        }
      }
    }
    return { grid, cellSize, inserted };
  }

  function contactCandidateScore(a, b) {
    if (!a?.aabb || !b?.aabb) return -Infinity;
    const overlapX = Math.min(a.aabb.right, b.aabb.right) - Math.max(a.aabb.left, b.aabb.left);
    const overlapY = Math.min(a.aabb.bottom, b.aabb.bottom) - Math.max(a.aabb.top, b.aabb.top);
    if (overlapX < -8 || overlapY < -8) return -Infinity;
    let score = 0;
    if (a.active) score += 4;
    if (b.active) score += 4;
    score += Math.max(0, Math.min(overlapX, overlapY) + 8) * 0.22;
    score += Math.min(18, Math.max(0, overlapX + 8) * Math.max(0, overlapY + 8) / 900);
    const ax = (a.aabb.left + a.aabb.right) * 0.5;
    const ay = (a.aabb.top + a.aabb.bottom) * 0.5;
    const bx = (b.aabb.left + b.aabb.right) * 0.5;
    const by = (b.aabb.top + b.aabb.bottom) * 0.5;
    score -= Math.min(5, Math.hypot(ax - bx, ay - by) / 180);
    return score;
  }

  function resolveMechanicalPairsBroadphase(worldRef, dt = 0.016, opts = {}) {
    const frame = opts.frame || buildMechanicalFrame(worldRef, opts);
    if (!frame || frame.collidable < 2 || frame.active <= 0) return { solved: 0, checked: 0, pairs: 0, candidates: 0, gridCells: 0 };
    const records = Array.isArray(opts.records) ? opts.records : broadphaseCandidateRecords(worldRef, frame, opts);
    if (records.length < 2) return { solved: 0, checked: 0, pairs: 0, candidates: records.length, gridCells: 0 };
    const gridInfo = buildColliderGrid(records, opts, worldRef._mechanicalColliderGrid || (worldRef._mechanicalColliderGrid = new Map()));
    const grid = gridInfo.grid;
    const seen = Object.create(null);
    const maxPairs = Math.max(24, Number(opts.maxPairs || 240) || 240);
    const maxCandidates = maxPairs >= 100000000 ? Number.POSITIVE_INFINITY : Math.max(maxPairs + 48, Math.min(900, maxPairs * 3));
    const pairCandidates = worldRef._mechanicalPairCandidates || (worldRef._mechanicalPairCandidates = []);
    pairCandidates.length = 0;
    let pairs = 0;
    for (const bucket of grid.values()) {
      for (let i = 0; i < bucket.length; i += 1) {
        const a = bucket[i];
        for (let j = i + 1; j < bucket.length; j += 1) {
          const b = bucket[j];
          if (!a || !b || a.item === b.item) continue;
          if (!a.active && !b.active) continue;
          const key = pairKey(a.item, b.item);
          if (seen[key]) continue;
          seen[key] = true;
          if (!bodyAabbOverlap(a.aabb, b.aabb, 8)) continue;
          const score = contactCandidateScore(a, b);
          if (!Number.isFinite(score)) continue;
          pairs += 1;
          if (pairCandidates.length < maxCandidates) pairCandidates.push({ a, b, key, score });
          else {
            // Keep only the highest-priority candidates so pathological overlap
            // scenes stay bounded before narrowphase resolution.
            let worst = 0;
            for (let k = 1; k < pairCandidates.length; k += 1) if (pairCandidates[k].score < pairCandidates[worst].score) worst = k;
            if (score > pairCandidates[worst].score) pairCandidates[worst] = { a, b, key, score };
          }
        }
      }
    }
    pairCandidates.sort((p, q) => q.score - p.score);
    let checked = 0;
    let solved = 0;
    for (const p of pairCandidates) {
      if (checked >= maxPairs) break;
      checked += 1;
      if (resolvePair(p.a.item, p.b.item, dt, worldRef)) solved += 1;
    }
    return { solved, checked, pairs, candidates: records.length, gridCells: grid.size, queuedPairs: pairCandidates.length };
  }

  function resolveMechanicalFences(worldRef, dt, bodies, activeSet, opts = {}) {
    let solved = 0;
    const maxItems = Math.max(12, Number(opts.maxFenceItems || 96) || 96);
    let count = 0;
    for (const item of bodies || []) {
      if (!item || item.dead) continue;
      // Fences are static in this runtime. A sleeping poison block or passive body
      // cannot create a new fence contact by itself, so skip it before expensive geometry work.
      if (activeSet && !activeSet.has(item)) continue;
      // Rail-driven reciprocators also participate here. A solid obstacle in
      // their travel path is a collision and reverses the motor direction.
      if (!shouldCollideMechanical(item)) continue;
      if (resolveFenceContacts(item, dt, worldRef, reach(item) + 80)) solved += 1;
      count += 1;
      if (count >= maxItems) break;
    }
    return solved;
  }


  function estimatedBodyMotion(item, dt = 0.016) {
    if (!item || item.dead) return 0;
    const step = Math.max(0.001, Math.min(0.05, Number(dt || 0.016) || 0.016));
    if (item.type === "rotator") {
      const speed = signedDrive(item);
      return Math.abs(speed) * step * Math.max(48, extent(item));
    }
    if (item.type === "reciprocator") {
      const speed = signedDrive(item);
      return Math.abs(speed) * step;
    }
    if (item.type === "poison_block") {
      const vel = bodyVelocity(item);
      return Math.hypot(num(vel?.x, ps(item, "xv", 0)), num(vel?.y, ps(item, "yv", 0))) * step + Math.abs(num(vel?.angular, ps(item, "spin", 0))) * step * Math.max(48, extent(item));
    }
    return 0;
  }

  function updateMechanicalWorld(worldRef, dt = 0.016, opts = {}) {
    if (!worldRef?.itemsOfType) return { ran: 0, active: 0, solved: 0, fenceSolved: 0, links: 0 };
    const profiler = global.TarinaiPerf;
    const end = profiler.begin("update.mechanicalWorld") || null;
    try {
      const rawDt = Number(dt || 0.016) || 0.016;
      const clampedDt = Math.max(0.001, Math.min(0.05, rawDt));
      const bodies = collectMechanicalBodies(worldRef, opts);
      if (!bodies.length) return { ran: 0, active: 0, solved: 0, fenceSolved: 0, links: 0, candidates: 0 };
      if (opts.statePrepared !== true) {
        for (const item of bodies) applyBodyState(item);
      }
      const active = [];
      for (const item of bodies) if (isMechanicallyActive(item)) active.push(item);
      const movingWork = active.length;
      let maxMotion = 0;
      for (const item of active) maxMotion = Math.max(maxMotion, estimatedBodyMotion(item, clampedDt));
      let fenceSensitiveMotion = false;
      for (const item of active) {
        if ((item?.type === "rotator" || item?.type === "reciprocator") && estimatedBodyMotion(item, clampedDt) > 9 && hasFenceNearby(item, worldRef, reach(item) + 94)) { fenceSensitiveMotion = true; break; }
      }
      const requestedMaxSubsteps = Number(opts.maxSubsteps || 4) || 4;
      const substepCap = fenceSensitiveMotion ? Math.min(6, Math.max(requestedMaxSubsteps, requestedMaxSubsteps + 2)) : requestedMaxSubsteps;
      const motionSlice = fenceSensitiveMotion ? 8 : 14;
      const substeps = Math.max(1, Math.min(substepCap, Math.max(Math.ceil(movingWork / 36), Math.ceil(maxMotion / motionSlice))));
      const subDt = clampedDt / substeps;
      let ran = 0;
      let moved = false;
      let stepSolved = 0;
      let stepChecked = 0;
      let stepPairs = 0;
      let stepFenceSolved = 0;
      // Resolve body pairs between substeps, not only once after all motion.
      // This keeps thin, visually-aligned rotator/reciprocator strokes from
      // tunneling through each other without inflating their collision width.
      for (let step = 0; step < substeps; step += 1) {
        let subMoved = false;
        for (const item of active) {
          if (!item || item.dead || item.playerHeld || item._heldByPlayer) continue;
          let changed = false;
          if (item.type === "rotator") changed = updateRotator(item, subDt, worldRef, { centralStep: true, skipInteractions: true, deferDirty: true, statePrepared: true });
          else if (item.type === "reciprocator") changed = updateReciprocator(item, subDt, worldRef, { centralStep: true, skipInteractions: true, deferDirty: true, statePrepared: true });
          else if (item.type === "poison_block") changed = updatePoisonBlock(item, subDt, worldRef, { centralStep: true, skipInteractions: true, deferDirty: true, statePrepared: true });
          if (changed) { moved = true; subMoved = true; ran += 1; }
        }
        if (subMoved) {
          const subFrame = active.length > 1 || active.some(it => it?.type === "rotator") ? buildMechanicalFrame(worldRef, { bodies }) : null;
          if (active.length > 1 && subFrame) {
            const subStats = resolveMechanicalPairsBroadphase(worldRef, subDt, { frame: subFrame, maxPairs: opts.maxSubstepPairs || 140, focusThreshold: opts.focusThreshold || 48 });
            if (subStats.solved) moved = true;
            stepSolved += subStats.solved || 0;
            stepChecked += subStats.checked || 0;
            stepPairs += subStats.pairs || 0;
          }
          // Fence contacts are checked during high-speed rotator substeps rather
          // than only after the final pose.  This closes the tunneling gap where
          // a thin/hand-drawn rotator can pass entirely across a fence between
          // two final-frame overlap checks.
          const subFenceSolved = resolveMechanicalFences(worldRef, subDt, active, subFrame?.activeSet || new Set(active), { maxFenceItems: opts.maxSubstepFenceItems || 32 });
          if (subFenceSolved) { moved = true; stepFenceSolved += subFenceSolved; }
        }
      }
      if (moved) {
        worldRef.drawListDirty = true;
        worldRef.markSpatialDirty?.("mechanical-world-motion");
      }
      // Resolve links after all motors/passive bodies have moved, so constraints see
      // one coherent world-state rather than each item solving in isolation.
      const links = opts.skipLinks === true ? 0 : (global.TarinaiConstraintSystem.updateWorld(worldRef, clampedDt, { maxLinks: opts.maxLinks || 160 }) || 0);
      // Build a single physics frame after motion and reuse it for pair and fence passes.
      // This is intentionally save-incompatible: transient body records are runtime only.
      const frame = buildMechanicalFrame(worldRef, { bodies });
      const pairStats = resolveMechanicalPairsBroadphase(worldRef, clampedDt, { frame, maxPairs: opts.maxPairs || 260, focusThreshold: opts.focusThreshold || 48 });
      pairStats.solved = (pairStats.solved || 0) + stepSolved;
      pairStats.checked = (pairStats.checked || 0) + stepChecked;
      pairStats.pairs = (pairStats.pairs || 0) + stepPairs;
      const fenceSolved = stepFenceSolved + resolveMechanicalFences(worldRef, clampedDt, bodies, frame.activeSet, opts);
      if (pairStats.solved || fenceSolved || links) {
        worldRef.drawListDirty = true;
        worldRef.markSpatialDirty?.("mechanical-world-solve");
      }
      worldRef._mechanicalWorldStats = { bodies: bodies.length, active: frame.active, collidable: frame.collidable, sourceCount: frame.sourceCount || frame.records.length, focused: Boolean(frame.focused), candidates: pairStats.candidates || 0, gridCells: pairStats.gridCells || 0, substeps, fenceSensitive: fenceSensitiveMotion };
      return { ran, active: frame.active, solved: pairStats.solved, checked: pairStats.checked, pairs: pairStats.pairs, fenceSolved, links, candidates: pairStats.candidates || 0, gridCells: pairStats.gridCells || 0, substeps, sourceCount: frame.sourceCount || frame.records.length, focused: Boolean(frame.focused) };
    } finally {
      if (end) end();
    }
  }

  function resolveMechanicalPairs(worldRef, dt = 0.016, opts = {}) {
    const stats = resolveMechanicalPairsBroadphase(worldRef, dt, opts);
    return stats.solved || 0;
  }


  function applyPokeImpulse(item, x, y, worldRef) {
    if (!item || !isMechanicalType(item)) return false;
    if (item.type === "poison_block") {
      const dx = num(item.x) - num(x);
      const dy = num(item.y) - num(y);
      const d = Math.max(12, Math.hypot(dx, dy));
      applyImpulse(item, x, y, dx / d * 72, dy / d * 72, 1.0);
      wakeItem(item, "poke-poison-block");
      worldRef?.markSpatialDirty?.("poke-poison-block");
      return true;
    }
    if (item.type === "rotator" && !isPowered(item)) {
      const a = itemAngle(item);
      const pose = bodyPose(item);
      const side = Math.sign((num(x) - num(pose?.x, item.x)) * Math.cos(a + Math.PI / 2) + (num(y) - num(pose?.y, item.y)) * Math.sin(a + Math.PI / 2)) || (stableUnit(item.id || item.seed || "rotator", "poke-side") < 0.5 ? -1 : 1);
      pset(item, "spin", clamp(num(bodyVelocity(item)?.angular, ps(item, "spin", 0)) * 0.82 - side * 0.32, -1.6, 1.6), "pair-spin-response");
      commitBody(item);
      worldRef?.markSpatialDirty?.("poke-passive-rotator");
      return true;
    }
    if (item.type === "reciprocator" && !isPowered(item)) {
      const a = axis(item);
      const pose = bodyPose(item);
      const side = Math.sign((num(x) - num(pose?.x, item.x)) * a.x + (num(y) - num(pose?.y, item.y)) * a.y) || (stableUnit(item.id || item.seed || "reciprocator", "poke-side") < 0.5 ? -1 : 1);
      pset(item, "slideSpeed", clamp(num(bodyVelocity(item)?.linear, ps(item, "slideSpeed", 0)) * 0.76 - side * 34, -115, 115), "pair-slide-response");
      commitBody(item);
      worldRef?.markSpatialDirty?.("poke-passive-reciprocator");
      return true;
    }
    return false;
  }

  function hitTest(worldRef, item, x, y, opts = {}) {
    return global.TarinaiCollisionFootprints.hitTestItem(worldRef, item, x, y, opts) || { hit: false, distance: Infinity };
  }

  global.TarinaiMechanicalSystem = Object.freeze({
    isMechanicalType,
    isPowered,
    sanitizeSegments,
    obstacleRects,
    placementRects,
    poisonHazardRects,
    extent,
    reach,
    signedDrive,
    motionLevel,
    resetAnchor,
    axis,
    railAxisAngle,
    applySurfaceVelocityToCircle,
    resolveMechanicalPairs,
    updateWorld: updateMechanicalWorld,
    updateRotator,
    updateReciprocator,
    updatePoisonBlock,
    applyPokeImpulse,
    hitTest,
    invalidateGeometry,
    wakeItem,
    passiveItemAwake,
  });
})(typeof window !== "undefined" ? window : globalThis);