@pibbl/core 0.0.1

package/dist/features/physics/lib/2d/canvas/inference.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/features/physics/lib/2d/canvas/inference.ts"],
+  "sourcesContent": ["import {\n  Arc,\n  Circle,\n  Ellipse,\n  Group,\n  HorizontalLine,\n  Image,\n  Line,\n  Path,\n  Polygon,\n  Rectangle,\n  RegularPolygon,\n  Star,\n  SvgPath,\n  Text,\n  VerticalLine,\n  Wedge,\n} from \"@pibbl/core\";\nimport type {\n  PibblPhysicsShape2D,\n  PibblPhysicsVector2,\n} from \"../../../2d-geometry.js\";\nimport {\n  arcShape2D,\n  boxShape2D,\n  chainShape2D,\n  circleShape2D,\n  ellipseShape2D,\n  polygonShape2D,\n  roundedBoxShape2D,\n  wedgeShape2D,\n} from \"../shapes.js\";\nimport {\n  canonicalizeContour2D,\n  polygonMassData2D,\n  triangulateContour2D,\n} from \"../math.js\";\nimport {\n  createShape2D,\n  requireShapeRecord2D,\n  type PolygonLeaf2D,\n} from \"../shape-records.js\";\n\nexport interface CanvasColliderInferenceInput2D {\n  readonly componentType: Function;\n  readonly componentName: string;\n  readonly style: Readonly<Record<PropertyKey, unknown>>;\n}\n\nconst customShapeResolvers2D = new WeakMap<\n  Function,\n  (style: Readonly<Record<PropertyKey, unknown>>) => PibblPhysicsShape2D\n>();\n\nexport function installCustomShapeResolver2D(\n  component: Function,\n  resolver: (\n    style: Readonly<Record<PropertyKey, unknown>>,\n  ) => PibblPhysicsShape2D,\n): void {\n  if (customShapeResolvers2D.has(component)) {\n    throw new Error(\n      \"A Pibbl primitive may have only one physics 2D shape resolver.\",\n    );\n  }\n  customShapeResolvers2D.set(component, resolver);\n}\n\nexport function inferCanvasColliderShape2D(\n  input: CanvasColliderInferenceInput2D,\n): PibblPhysicsShape2D {\n  const { componentType, componentName, style } = input;\n  const customResolver = customShapeResolvers2D.get(componentType);\n  if (customResolver) return requireShape(customResolver(style), componentName);\n  if (componentType === Rectangle) {\n    const width = positive(style, \"width\", componentName),\n      height = positive(style, \"height\", componentName);\n    const center = [width / 2, height / 2] as const;\n    const radii = resolvedRadii(style, 4);\n    return radii.some((radius) => radius > 0)\n      ? roundedBoxShape2D({\n          width,\n          height,\n          center,\n          radius: radii as [number, number, number, number],\n        })\n      : boxShape2D({ width, height, center });\n  }\n  if (componentType === Circle) {\n    return circleShape2D({\n      center: [number(style, \"cx\", 0), number(style, \"cy\", 0)],\n      radius: positive(style, \"radius\", componentName),\n    });\n  }\n  if (componentType === Ellipse) {\n    return ellipseShape2D({\n      center: [number(style, \"cx\", 0), number(style, \"cy\", 0)],\n      radiusX: positive(style, \"radiusX\", componentName),\n      radiusY: positive(style, \"radiusY\", componentName),\n      rotationDegrees: (number(style, \"rotation\", 0) * 180) / Math.PI,\n    });\n  }\n  if (componentType === Arc) {\n    return arcShape2D({\n      center: [number(style, \"cx\", 0), number(style, \"cy\", 0)],\n      radius: positive(style, \"radius\", componentName),\n      startAngleRadians: number(style, \"startAngle\"),\n      endAngleRadians: number(style, \"endAngle\"),\n      counterclockwise: style.counterclockwise === true,\n      thickness: positive(style, \"strokeWidth\", componentName),\n    });\n  }\n  if (componentType === Wedge) {\n    return wedgeShape2D({\n      center: [number(style, \"cx\", 0), number(style, \"cy\", 0)],\n      radius: positive(style, \"radius\", componentName),\n      startAngleRadians: number(style, \"startAngle\"),\n      endAngleRadians: number(style, \"endAngle\"),\n      counterclockwise: style.counterclockwise === true,\n    });\n  }\n  if (componentType === Polygon) {\n    const vertices = points(style.coords, `${componentName}.coords`);\n    const radii = resolvedRadii(style, vertices.length);\n    return shapeFromClosedContour(\n      roundedContour(vertices, radii),\n      `${componentName}.coords`,\n      radii.some((radius) => radius > 0),\n    );\n  }\n  if (componentType === RegularPolygon) {\n    const sides = integer(style, \"sides\", 3, componentName);\n    const radius = regularPolygonRadius(style, sides, componentName);\n    const cx = number(style, \"cx\", 0),\n      cy = number(style, \"cy\", 0),\n      rotation = number(style, \"rotation\", -Math.PI / 2);\n    const vertices = Array.from({ length: sides }, (_, index) => {\n      const angle = rotation + (index * Math.PI * 2) / sides;\n      return [\n        cx + radius * Math.cos(angle),\n        cy + radius * Math.sin(angle),\n      ] as const;\n    });\n    const radii = resolvedRadii(style, sides);\n    return shapeFromClosedContour(\n      roundedContour(vertices, radii),\n      `${componentName}.vertices`,\n      radii.some((value) => value > 0),\n    );\n  }\n  if (componentType === Star) {\n    const count = integer(style, \"points\", 3, componentName);\n    const outer = positive(style, \"outerRadius\", componentName),\n      inner = positive(style, \"innerRadius\", componentName);\n    if (inner > outer)\n      throw new RangeError(\n        `${componentName}.innerRadius must not exceed outerRadius.`,\n      );\n    const cx = number(style, \"cx\", 0),\n      cy = number(style, \"cy\", 0),\n      rotation = number(style, \"rotation\", -Math.PI / 2);\n    const vertices = Array.from({ length: count * 2 }, (_, index) => {\n      const angle = rotation + (index * Math.PI) / count;\n      const radius = index % 2 === 0 ? outer : inner;\n      return [\n        cx + radius * Math.cos(angle),\n        cy + radius * Math.sin(angle),\n      ] as const;\n    });\n    const radii = resolvedRadii(style, count * 2);\n    return shapeFromClosedContour(\n      roundedContour(vertices, radii),\n      `${componentName}.vertices`,\n      true,\n    );\n  }\n  if (componentType === Line)\n    return lineShape(\n      points(style.coords, `${componentName}.coords`),\n      number(style, \"strokeWidth\", 0),\n    );\n  if (componentType === HorizontalLine) {\n    const y = number(style, \"y\");\n    return lineShape(\n      [\n        [number(style, \"x1\", 0), y],\n        [number(style, \"x2\"), y],\n      ],\n      number(style, \"strokeWidth\", 0),\n    );\n  }\n  if (componentType === VerticalLine) {\n    const x = number(style, \"x\");\n    return lineShape(\n      [\n        [x, number(style, \"y1\", 0)],\n        [x, number(style, \"y2\")],\n      ],\n      number(style, \"strokeWidth\", 0),\n    );\n  }\n  if (componentType === SvgPath) return inferSvgPath(style, componentName);\n  if (componentType === Path)\n    throw explicitShapeError(\n      componentName,\n      \"its opaque Path2D commands cannot be inspected\",\n    );\n  if (componentType === Text || componentType === Image) {\n    if (typeof style.width !== \"number\" || typeof style.height !== \"number\") {\n      throw explicitShapeError(\n        componentName,\n        \"stable width and height are not declared\",\n      );\n    }\n    const width = positive(style, \"width\", componentName),\n      height = positive(style, \"height\", componentName);\n    return boxShape2D({ width, height, center: [width / 2, height / 2] });\n  }\n  if (componentType === Group)\n    throw explicitShapeError(\n      componentName,\n      \"Group has no self geometry; attach colliders to physical descendants\",\n    );\n  throw explicitShapeError(\n    componentName,\n    \"the primitive has no stable physics shape adapter\",\n  );\n}\n\nexport function bakeCanvasShapeTransform2D(\n  shape: PibblPhysicsShape2D,\n  transform: DOMMatrixReadOnly,\n): PibblPhysicsShape2D {\n  if (isIdentity(transform)) return shape;\n  const source = requireShapeRecord2D(shape);\n  const local = new DOMMatrix()\n    .translate(source.localPose.x, source.localPose.y)\n    .rotate((source.localPose.rotationRadians * 180) / Math.PI);\n  const combined = new DOMMatrix([\n    transform.a,\n    transform.b,\n    transform.c,\n    transform.d,\n    transform.e,\n    transform.f,\n  ]).multiply(local);\n  const parts: PibblPhysicsShape2D[] = [];\n  for (const leaf of source.leaves) {\n    if (leaf.kind === \"segment\") {\n      parts.push(\n        chainShape2D({\n          points: [\n            transformPoint(combined, leaf.start),\n            transformPoint(combined, leaf.end),\n          ],\n        }),\n      );\n      continue;\n    }\n    const contour = leafContour(leaf).map((point) =>\n      transformPoint(combined, point),\n    );\n    parts.push(\n      shapeFromClosedContour(\n        contour,\n        \"transformed collider contour\",\n        leaf.kind === \"rounded-box\" || leaf.kind === \"capsule\",\n      ),\n    );\n  }\n  return combineShapes(parts);\n}\n\nfunction inferSvgPath(\n  style: Readonly<Record<PropertyKey, unknown>>,\n  componentName: string,\n): PibblPhysicsShape2D {\n  if (typeof style.d !== \"string\")\n    throw explicitShapeError(componentName, \"SVG path data is not a string\");\n  const contours = parseSvgContours(style.d, componentName);\n  if (contours.length !== 1)\n    throw explicitShapeError(\n      componentName,\n      \"multiple SVG contours have ambiguous fill or winding semantics\",\n    );\n  const contour = contours[0]!;\n  if (contour.closed) {\n    if (style.fill === undefined)\n      throw explicitShapeError(\n        componentName,\n        \"a closed SVG contour without a resolved fill is ambiguous\",\n      );\n    try {\n      return shapeFromClosedContour(contour.points, `${componentName}.d`);\n    } catch {\n      throw explicitShapeError(\n        componentName,\n        \"its SVG contour is self-intersecting, degenerate, or cannot be decomposed deterministically\",\n      );\n    }\n  }\n  if (style.fill !== undefined)\n    throw explicitShapeError(\n      componentName,\n      \"an open filled SVG contour is ambiguous\",\n    );\n  try {\n    return lineShape(contour.points, number(style, \"strokeWidth\", 0));\n  } catch {\n    throw explicitShapeError(\n      componentName,\n      \"its open SVG contour is degenerate or has an invalid resolved stroke width\",\n    );\n  }\n}\n\nfunction lineShape(\n  source: readonly PibblPhysicsVector2[],\n  strokeWidth: number,\n): PibblPhysicsShape2D {\n  if (source.length < 2)\n    throw new RangeError(\"A line collider requires at least two points.\");\n  if (!Number.isFinite(strokeWidth) || strokeWidth < 0)\n    throw new TypeError(\n      \"Resolved strokeWidth must be a finite nonnegative number.\",\n    );\n  return chainShape2D({ points: source, radius: strokeWidth / 2 });\n}\n\nfunction shapeFromClosedContour(\n  source: readonly PibblPhysicsVector2[],\n  path: string,\n  forceCompound = false,\n): PibblPhysicsShape2D {\n  if (!forceCompound) {\n    try {\n      return polygonShape2D({ points: source });\n    } catch {\n      // Concavity is represented as a deterministic triangle compound below.\n    }\n  }\n  {\n    const contour = canonicalizeContour2D(source, {\n      strictlyConvex: false,\n      path,\n    });\n    const triangles = triangulateContour2D(contour);\n    const leaves = triangles.map<PolygonLeaf2D>(\n      (vertices, canonicalLeafIndex) =>\n        Object.freeze({ kind: \"polygon\", vertices, canonicalLeafIndex }),\n    );\n    const entries = leaves.map((leaf) => polygonMassData2D(leaf.vertices));\n    const area = entries.reduce((sum, entry) => sum + entry.area, 0);\n    const centroidX =\n      entries.reduce((sum, entry) => sum + entry.area * entry.centroidX, 0) /\n      area;\n    const centroidY =\n      entries.reduce((sum, entry) => sum + entry.area * entry.centroidY, 0) /\n      area;\n    const unitInertia = entries.reduce((sum, entry) => {\n      const dx = entry.centroidX - centroidX,\n        dy = entry.centroidY - centroidY;\n      return sum + entry.unitInertia + entry.area * (dx * dx + dy * dy);\n    }, 0);\n    const xs = leaves.flatMap((leaf) =>\n      Array.from(leaf.vertices).filter((_, index) => index % 2 === 0),\n    );\n    const ys = leaves.flatMap((leaf) =>\n      Array.from(leaf.vertices).filter((_, index) => index % 2 === 1),\n    );\n    return createShape2D({\n      leaves,\n      localBounds: new Float64Array([\n        Math.min(...xs),\n        Math.min(...ys),\n        Math.max(...xs),\n        Math.max(...ys),\n      ]),\n      area,\n      centroidX,\n      centroidY,\n      unitInertia,\n    });\n  }\n}\n\nfunction combineShapes(\n  shapes: readonly PibblPhysicsShape2D[],\n): PibblPhysicsShape2D {\n  if (shapes.length === 1) return shapes[0]!;\n  const records = shapes.map(requireShapeRecord2D);\n  const leaves = records.flatMap((record) => record.leaves);\n  const area = records.reduce((sum, record) => sum + record.area, 0);\n  const centroidX =\n    area === 0\n      ? 0\n      : records.reduce(\n          (sum, record) => sum + record.area * record.centroidX,\n          0,\n        ) / area;\n  const centroidY =\n    area === 0\n      ? 0\n      : records.reduce(\n          (sum, record) => sum + record.area * record.centroidY,\n          0,\n        ) / area;\n  const unitInertia = records.reduce((sum, record) => {\n    const dx = record.centroidX - centroidX,\n      dy = record.centroidY - centroidY;\n    return sum + record.unitInertia + record.area * (dx * dx + dy * dy);\n  }, 0);\n  return createShape2D({\n    leaves,\n    localBounds: new Float64Array([\n      Math.min(...records.map((record) => record.localBounds[0]!)),\n      Math.min(...records.map((record) => record.localBounds[1]!)),\n      Math.max(...records.map((record) => record.localBounds[2]!)),\n      Math.max(...records.map((record) => record.localBounds[3]!)),\n    ]),\n    area,\n    centroidX,\n    centroidY,\n    unitInertia,\n  });\n}\n\nfunction leafContour(\n  leaf: ReturnType<typeof requireShapeRecord2D>[\"leaves\"][number],\n): readonly PibblPhysicsVector2[] {\n  switch (leaf.kind) {\n    case \"circle\":\n      return ellipseContour(leaf.center, leaf.radius, leaf.radius, 0);\n    case \"ellipse\":\n      return ellipseContour(\n        leaf.center,\n        leaf.radiusX,\n        leaf.radiusY,\n        leaf.rotationRadians,\n      );\n    case \"box\":\n      return [\n        [leaf.center[0]! - leaf.halfWidth, leaf.center[1]! - leaf.halfHeight],\n        [leaf.center[0]! + leaf.halfWidth, leaf.center[1]! - leaf.halfHeight],\n        [leaf.center[0]! + leaf.halfWidth, leaf.center[1]! + leaf.halfHeight],\n        [leaf.center[0]! - leaf.halfWidth, leaf.center[1]! + leaf.halfHeight],\n      ];\n    case \"rounded-box\": {\n      const cx = leaf.center[0]!,\n        cy = leaf.center[1]!;\n      const corners = [\n        [\n          cx + leaf.halfWidth - leaf.radii[1]!,\n          cy - leaf.halfHeight + leaf.radii[1]!,\n          -Math.PI / 2,\n          0,\n          leaf.radii[1]!,\n        ],\n        [\n          cx + leaf.halfWidth - leaf.radii[2]!,\n          cy + leaf.halfHeight - leaf.radii[2]!,\n          0,\n          Math.PI / 2,\n          leaf.radii[2]!,\n        ],\n        [\n          cx - leaf.halfWidth + leaf.radii[3]!,\n          cy + leaf.halfHeight - leaf.radii[3]!,\n          Math.PI / 2,\n          Math.PI,\n          leaf.radii[3]!,\n        ],\n        [\n          cx - leaf.halfWidth + leaf.radii[0]!,\n          cy - leaf.halfHeight + leaf.radii[0]!,\n          Math.PI,\n          Math.PI * 1.5,\n          leaf.radii[0]!,\n        ],\n      ] as const;\n      return corners.flatMap(([x, y, start, end, radius]) =>\n        arcContour(x, y, radius, start, end, 8),\n      );\n    }\n    case \"capsule\": {\n      const angle = Math.atan2(\n        leaf.end[1]! - leaf.start[1]!,\n        leaf.end[0]! - leaf.start[0]!,\n      );\n      return [\n        ...arcContour(\n          leaf.end[0]!,\n          leaf.end[1]!,\n          leaf.radius,\n          angle - Math.PI / 2,\n          angle + Math.PI / 2,\n          16,\n        ),\n        ...arcContour(\n          leaf.start[0]!,\n          leaf.start[1]!,\n          leaf.radius,\n          angle + Math.PI / 2,\n          angle + Math.PI * 1.5,\n          16,\n        ),\n      ];\n    }\n    case \"polygon\": {\n      const result: PibblPhysicsVector2[] = [];\n      for (let index = 0; index < leaf.vertices.length; index += 2)\n        result.push([leaf.vertices[index]!, leaf.vertices[index + 1]!]);\n      return result;\n    }\n    case \"segment\":\n      return [];\n  }\n}\n\nfunction ellipseContour(\n  center: Float64Array,\n  radiusX: number,\n  radiusY: number,\n  rotation: number,\n): readonly PibblPhysicsVector2[] {\n  const cosine = Math.cos(rotation),\n    sine = Math.sin(rotation);\n  return Array.from({ length: 32 }, (_, index) => {\n    const angle = (index * Math.PI * 2) / 32,\n      x = radiusX * Math.cos(angle),\n      y = radiusY * Math.sin(angle);\n    return [\n      center[0]! + x * cosine - y * sine,\n      center[1]! + x * sine + y * cosine,\n    ] as const;\n  });\n}\n\nfunction arcContour(\n  cx: number,\n  cy: number,\n  radius: number,\n  start: number,\n  end: number,\n  steps: number,\n): readonly PibblPhysicsVector2[] {\n  if (radius === 0) return [[cx, cy]];\n  return Array.from({ length: steps + 1 }, (_, index) => {\n    const angle = start + ((end - start) * index) / steps;\n    return [\n      cx + radius * Math.cos(angle),\n      cy + radius * Math.sin(angle),\n    ] as const;\n  });\n}\n\nfunction transformPoint(\n  matrix: DOMMatrixReadOnly,\n  point: ArrayLike<number>,\n): PibblPhysicsVector2 {\n  return [\n    matrix.a * point[0]! + matrix.c * point[1]! + matrix.e,\n    matrix.b * point[0]! + matrix.d * point[1]! + matrix.f,\n  ];\n}\n\nfunction isIdentity(matrix: DOMMatrixReadOnly): boolean {\n  return (\n    matrix.a === 1 &&\n    matrix.b === 0 &&\n    matrix.c === 0 &&\n    matrix.d === 1 &&\n    matrix.e === 0 &&\n    matrix.f === 0\n  );\n}\n\nfunction roundedContour(\n  source: readonly PibblPhysicsVector2[],\n  radii: readonly number[],\n): readonly PibblPhysicsVector2[] {\n  if (radii.every((radius) => radius === 0))\n    return source.map((point) => [point[0], point[1]] as const);\n  const corners = source.map((point, index) => {\n    const previous = source[(index + source.length - 1) % source.length]!,\n      next = source[(index + 1) % source.length]!;\n    const previousLength = Math.hypot(\n      previous[0] - point[0],\n      previous[1] - point[1],\n    );\n    const nextLength = Math.hypot(next[0] - point[0], next[1] - point[1]);\n    const previousUnit = [\n      (previous[0] - point[0]) / previousLength,\n      (previous[1] - point[1]) / previousLength,\n    ] as const;\n    const nextUnit = [\n      (next[0] - point[0]) / nextLength,\n      (next[1] - point[1]) / nextLength,\n    ] as const;\n    const dot = Math.max(\n      -1,\n      Math.min(\n        1,\n        previousUnit[0] * nextUnit[0] + previousUnit[1] * nextUnit[1],\n      ),\n    );\n    return {\n      point,\n      previousUnit,\n      nextUnit,\n      demand: radii[index]! / Math.tan(Math.acos(dot) / 2),\n      radius: radii[index]!,\n      previousLength,\n    };\n  });\n  const scale = corners.reduce((current, corner, index) => {\n    const demand =\n      corner.demand + corners[(index + 1) % corners.length]!.demand;\n    return demand > 0\n      ? Math.min(\n          current,\n          corners[(index + 1) % corners.length]!.previousLength / demand,\n        )\n      : current;\n  }, 1);\n  const output: PibblPhysicsVector2[] = [];\n  for (const corner of corners) {\n    const demand = corner.demand * scale;\n    if (corner.radius === 0 || !Number.isFinite(demand)) {\n      output.push([corner.point[0], corner.point[1]]);\n      continue;\n    }\n    const start = [\n      corner.point[0] + corner.previousUnit[0] * demand,\n      corner.point[1] + corner.previousUnit[1] * demand,\n    ] as const;\n    const end = [\n      corner.point[0] + corner.nextUnit[0] * demand,\n      corner.point[1] + corner.nextUnit[1] * demand,\n    ] as const;\n    output.push(start);\n    appendQuadratic(output, start, corner.point, end, 0);\n  }\n  return output;\n}\n\nfunction appendQuadratic(\n  output: PibblPhysicsVector2[],\n  start: PibblPhysicsVector2,\n  control: PibblPhysicsVector2,\n  end: PibblPhysicsVector2,\n  depth: number,\n): void {\n  const midpoint = [\n    (start[0] + 2 * control[0] + end[0]) / 4,\n    (start[1] + 2 * control[1] + end[1]) / 4,\n  ] as const;\n  const chord = [(start[0] + end[0]) / 2, (start[1] + end[1]) / 2] as const;\n  if (\n    Math.hypot(midpoint[0] - chord[0], midpoint[1] - chord[1]) <= 0.05 ||\n    depth >= 12\n  ) {\n    output.push([end[0], end[1]]);\n    return;\n  }\n  const firstControl = midpointOf(start, control),\n    secondControl = midpointOf(control, end);\n  appendQuadratic(output, start, firstControl, midpoint, depth + 1);\n  appendQuadratic(output, midpoint, secondControl, end, depth + 1);\n}\n\ninterface SvgContour {\n  readonly points: readonly PibblPhysicsVector2[];\n  readonly closed: boolean;\n}\n\nfunction parseSvgContours(\n  data: string,\n  componentName: string,\n): readonly SvgContour[] {\n  const tokens =\n    data.match(/[a-zA-Z]|[-+]?(?:\\d*\\.\\d+|\\d+\\.?)(?:[eE][-+]?\\d+)?/g) ?? [];\n  const contours: SvgContour[] = [];\n  let output: PibblPhysicsVector2[] = [],\n    closed = false,\n    command = \"\",\n    index = 0;\n  let current: PibblPhysicsVector2 = [0, 0],\n    start: PibblPhysicsVector2 = [0, 0];\n  const finish = () => {\n    if (output.length > 0) contours.push({ points: output, closed });\n    output = [];\n    closed = false;\n  };\n  const read = () => {\n    const value = Number(tokens[index++]);\n    if (!Number.isFinite(value))\n      throw explicitShapeError(componentName, \"SVG path data is malformed\");\n    return value;\n  };\n  while (index < tokens.length) {\n    if (/^[a-zA-Z]$/.test(tokens[index]!)) command = tokens[index++]!;\n    if (!command)\n      throw explicitShapeError(\n        componentName,\n        \"SVG path data must begin with a command\",\n      );\n    const relative = command === command.toLowerCase(),\n      upper = command.toUpperCase();\n    const point = (x: number, y: number): PibblPhysicsVector2 =>\n      relative ? [current[0] + x, current[1] + y] : [x, y];\n    if (upper === \"M\") {\n      finish();\n      current = point(read(), read());\n      start = current;\n      output.push(current);\n      command = relative ? \"l\" : \"L\";\n    } else if (upper === \"L\") {\n      current = point(read(), read());\n      output.push(current);\n    } else if (upper === \"H\") {\n      current = relative\n        ? [current[0] + read(), current[1]]\n        : [read(), current[1]];\n      output.push(current);\n    } else if (upper === \"V\") {\n      current = relative\n        ? [current[0], current[1] + read()]\n        : [current[0], read()];\n      output.push(current);\n    } else if (upper === \"Q\") {\n      const control = point(read(), read()),\n        end = point(read(), read());\n      appendQuadratic(output, current, control, end, 0);\n      current = end;\n    } else if (upper === \"C\") {\n      const first = point(read(), read()),\n        second = point(read(), read()),\n        end = point(read(), read());\n      appendCubic(output, current, first, second, end, 0);\n      current = end;\n    } else if (upper === \"Z\") {\n      closed = true;\n      current = start;\n      command = \"\";\n    } else\n      throw explicitShapeError(\n        componentName,\n        `SVG command ${command} is not supported for deterministic collider inference`,\n      );\n  }\n  finish();\n  return contours;\n}\n\nfunction appendCubic(\n  output: PibblPhysicsVector2[],\n  start: PibblPhysicsVector2,\n  first: PibblPhysicsVector2,\n  second: PibblPhysicsVector2,\n  end: PibblPhysicsVector2,\n  depth: number,\n): void {\n  const error = Math.max(\n    pointLineDistance(first, start, end),\n    pointLineDistance(second, start, end),\n  );\n  if (error <= 0.05 || depth >= 12) {\n    output.push([end[0], end[1]]);\n    return;\n  }\n  const a = midpointOf(start, first),\n    b = midpointOf(first, second),\n    c = midpointOf(second, end),\n    d = midpointOf(a, b),\n    e = midpointOf(b, c),\n    middle = midpointOf(d, e);\n  appendCubic(output, start, a, d, middle, depth + 1);\n  appendCubic(output, middle, e, c, end, depth + 1);\n}\n\nfunction midpointOf(\n  a: PibblPhysicsVector2,\n  b: PibblPhysicsVector2,\n): PibblPhysicsVector2 {\n  return [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];\n}\nfunction pointLineDistance(\n  point: PibblPhysicsVector2,\n  start: PibblPhysicsVector2,\n  end: PibblPhysicsVector2,\n): number {\n  const dx = end[0] - start[0],\n    dy = end[1] - start[1],\n    length = Math.hypot(dx, dy);\n  return length === 0\n    ? Math.hypot(point[0] - start[0], point[1] - start[1])\n    : Math.abs(\n        dy * point[0] - dx * point[1] + end[0] * start[1] - end[1] * start[0],\n      ) / length;\n}\n\nfunction resolvedRadii(\n  style: Readonly<Record<PropertyKey, unknown>>,\n  count: number,\n): readonly number[] {\n  const fallback = number(style, \"cornerRadius\", 0),\n    source = Array.isArray(style.cornerRadii) ? style.cornerRadii : [];\n  return Array.from({ length: count }, (_, index) => {\n    const value = source[index] ?? fallback;\n    if (typeof value !== \"number\" || !Number.isFinite(value) || value < 0)\n      throw new TypeError(\n        `cornerRadii[${index}] must be a finite nonnegative number.`,\n      );\n    return value;\n  });\n}\nfunction regularPolygonRadius(\n  style: Readonly<Record<PropertyKey, unknown>>,\n  sides: number,\n  componentName: string,\n): number {\n  if (style.circumradius !== undefined)\n    return positive(style, \"circumradius\", componentName);\n  if (style.inradius !== undefined)\n    return (\n      positive(style, \"inradius\", componentName) / Math.cos(Math.PI / sides)\n    );\n  if (style.sideLength !== undefined)\n    return (\n      positive(style, \"sideLength\", componentName) /\n      (2 * Math.sin(Math.PI / sides))\n    );\n  throw new TypeError(`${componentName} requires one resolved size.`);\n}\nfunction points(value: unknown, path: string): readonly PibblPhysicsVector2[] {\n  if (!Array.isArray(value))\n    throw new TypeError(`${path} must be an array of points.`);\n  return value.map((entry, index) => {\n    if (\n      !Array.isArray(entry) ||\n      entry.length !== 2 ||\n      !entry.every((item) => typeof item === \"number\" && Number.isFinite(item))\n    )\n      throw new TypeError(\n        `${path}[${index}] must be a finite two-dimensional point.`,\n      );\n    return [entry[0] as number, entry[1] as number] as const;\n  });\n}\nfunction number(\n  style: Readonly<Record<PropertyKey, unknown>>,\n  key: string,\n  fallback?: number,\n): number {\n  const value = style[key] ?? fallback;\n  if (typeof value !== \"number\" || !Number.isFinite(value))\n    throw new TypeError(`Resolved ${key} must be a finite number.`);\n  return value;\n}\nfunction positive(\n  style: Readonly<Record<PropertyKey, unknown>>,\n  key: string,\n  componentName: string,\n): number {\n  const value = number(style, key);\n  if (value <= 0)\n    throw new RangeError(`${componentName}.${key} must be greater than zero.`);\n  return value;\n}\nfunction integer(\n  style: Readonly<Record<PropertyKey, unknown>>,\n  key: string,\n  minimum: number,\n  componentName: string,\n): number {\n  const value = number(style, key);\n  if (!Number.isSafeInteger(value) || value < minimum)\n    throw new RangeError(\n      `${componentName}.${key} must be a safe integer of at least ${minimum}.`,\n    );\n  return value;\n}\nfunction requireShape(\n  shape: PibblPhysicsShape2D,\n  componentName: string,\n): PibblPhysicsShape2D {\n  try {\n    requireShapeRecord2D(shape);\n    return shape;\n  } catch {\n    throw new TypeError(\n      `${componentName} physics shape resolver must return a Pibbl physics 2D shape.`,\n    );\n  }\n}\nfunction explicitShapeError(componentName: string, reason: string): Error {\n  return new Error(\n    `${componentName} cannot infer a collider because ${reason}; provide an explicit shape.`,\n  );\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/features/physics/lib/2d/canvas/presentation.d.ts

@@ -0,0 +1,11 @@
+import type { PibblPhysicsPose2D } from "../../../2d-geometry.js";
+export interface CanvasBodyPresentationCapture2D {
+    readonly initialPose: PibblPhysicsPose2D;
+    readonly parentWorld: DOMMatrix;
+    readonly initialBodyLocal: DOMMatrix;
+    readonly poseResidual: DOMMatrix;
+}
+export declare function captureBodyPresentation2D(parentWorld: DOMMatrixReadOnly, initialBodyLocal: DOMMatrixReadOnly, componentName: string, requireRigidAncestor?: boolean): CanvasBodyPresentationCapture2D;
+export declare function resolveDynamicPresentationTransform2D(capture: CanvasBodyPresentationCapture2D, presentedPose: PibblPhysicsPose2D, parentWorld: DOMMatrixReadOnly, currentBodyLocal: DOMMatrixReadOnly, componentName: string): DOMMatrix;
+export declare function bodyLocalTransformFromPrimitive2D(componentType: Function, style: Readonly<Record<PropertyKey, unknown>>): DOMMatrix;
+export declare function matrixFromPose(pose: PibblPhysicsPose2D): DOMMatrix;

package/dist/features/physics/lib/2d/canvas/presentation.js

@@ -0,0 +1,169 @@
+import { Group } from "@pibbl/core";
+const MATRIX_EPSILON = 1e-6;
+function captureBodyPresentation2D(parentWorld, initialBodyLocal, componentName, requireRigidAncestor = true) {
+  if (requireRigidAncestor) validateRigidAncestor(parentWorld, componentName);
+  else
+    validateFiniteInvertible(
+      parentWorld,
+      `${componentName} ancestor transform`
+    );
+  validateFiniteInvertible(
+    initialBodyLocal,
+    `${componentName} authored transform`
+  );
+  if (requireRigidAncestor) {
+    validateUnskewed(initialBodyLocal, `${componentName} authored transform`);
+  }
+  const world = copyMatrix(parentWorld).multiply(initialBodyLocal);
+  const scaleX = Math.hypot(world.a, world.b);
+  const initialPose = Object.freeze({
+    position: Object.freeze([clean(world.e), clean(world.f)]),
+    rotationDegrees: clean(
+      Math.atan2(world.b / scaleX, world.a / scaleX) * 180 / Math.PI
+    )
+  });
+  const poseMatrix = matrixFromPose(initialPose);
+  return Object.freeze({
+    initialPose,
+    parentWorld: copyMatrix(parentWorld),
+    initialBodyLocal: copyMatrix(initialBodyLocal),
+    poseResidual: poseMatrix.inverse().multiply(world)
+  });
+}
+function resolveDynamicPresentationTransform2D(capture, presentedPose, parentWorld, currentBodyLocal, componentName) {
+  validateRigidAncestor(parentWorld, componentName);
+  if (!sameMatrix(parentWorld, capture.parentWorld)) {
+    throw new Error(
+      `${componentName} ancestor transform changed while an enabled dynamic body owns pose. Use teleportBody2D(), a kinematic body, or disable physics before authored motion.`
+    );
+  }
+  if (!sameMatrix(currentBodyLocal, capture.initialBodyLocal)) {
+    throw new Error(
+      `${componentName} authored pose changed while an enabled dynamic body owns pose. Use teleportBody2D(), a kinematic body, or disable physics before authored motion.`
+    );
+  }
+  validatePose(presentedPose, componentName);
+  const presentedWorld = matrixFromPose(presentedPose).multiply(
+    capture.poseResidual
+  );
+  const result = copyMatrix(parentWorld).inverse().multiply(presentedWorld).multiply(copyMatrix(capture.initialBodyLocal).inverse());
+  return cleanMatrix(result);
+}
+function bodyLocalTransformFromPrimitive2D(componentType, style) {
+  let transform = new DOMMatrix().translate(
+    finiteStyleNumber(style.left, 0, "left"),
+    finiteStyleNumber(style.top, 0, "top")
+  );
+  if (componentType !== Group) return transform;
+  const scaleX = finiteStyleNumber(style.scaleX, 1, "scaleX");
+  const scaleY = finiteStyleNumber(style.scaleY, 1, "scaleY");
+  if (scaleX !== 1 || scaleY !== 1) transform = transform.scale(scaleX, scaleY);
+  const rotation = finiteStyleNumber(
+    style.rotationDegrees,
+    0,
+    "rotationDegrees"
+  );
+  if (rotation !== 0) {
+    const origin = style.rotationOrigin ?? [0, 0];
+    if (!Array.isArray(origin) || origin.length !== 2 || origin.some(
+      (value) => typeof value !== "number" || !Number.isFinite(value)
+    )) {
+      throw new TypeError(
+        "Group rotationOrigin must be a finite two-dimensional point."
+      );
+    }
+    transform = transform.translate(origin[0], origin[1]).rotate(rotation).translate(-origin[0], -origin[1]);
+  }
+  const translateX = finiteStyleNumber(style.translateX, 0, "translateX");
+  const translateY = finiteStyleNumber(style.translateY, 0, "translateY");
+  if (translateX !== 0 || translateY !== 0)
+    transform = transform.translate(translateX, translateY);
+  const skewX = finiteStyleNumber(style.skewX, 0, "skewX");
+  const skewY = finiteStyleNumber(style.skewY, 0, "skewY");
+  if (skewX !== 0) transform = transform.skewX(skewX);
+  if (skewY !== 0) transform = transform.skewY(skewY);
+  return transform;
+}
+function validatePose(pose, componentName) {
+  if (!Number.isFinite(pose.position[0]) || !Number.isFinite(pose.position[1]) || !Number.isFinite(pose.rotationDegrees)) {
+    throw new TypeError(
+      `${componentName} physics presentation pose must be finite.`
+    );
+  }
+}
+function validateRigidAncestor(matrix, componentName) {
+  validateFiniteInvertible(
+    matrix,
+    `${componentName} dynamic ancestor transform`
+  );
+  validateUnskewed(matrix, `${componentName} dynamic ancestor transform`);
+  const scaleX = Math.hypot(matrix.a, matrix.b);
+  const scaleY = Math.hypot(matrix.c, matrix.d);
+  if (!close(scaleX, 1) || !close(scaleY, 1)) {
+    throw new Error(
+      `${componentName} has a non-rigid dynamic ancestor scale. Bake scale into collider geometry or move the body outside that ancestor.`
+    );
+  }
+}
+function validateFiniteInvertible(matrix, label) {
+  const values = [matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f];
+  if (values.some((value) => !Number.isFinite(value))) {
+    throw new TypeError(`${label} must contain only finite values.`);
+  }
+  if (Math.abs(matrix.a * matrix.d - matrix.b * matrix.c) <= 1e-10) {
+    throw new Error(`${label} is noninvertible.`);
+  }
+}
+function validateUnskewed(matrix, label) {
+  const scaleX = Math.hypot(matrix.a, matrix.b);
+  const scaleY = Math.hypot(matrix.c, matrix.d);
+  const dot = (matrix.a * matrix.c + matrix.b * matrix.d) / (scaleX * scaleY);
+  if (Math.abs(dot) > 1e-8)
+    throw new Error(`${label} is skewed and cannot define a rigid body pose.`);
+}
+function sameMatrix(left, right) {
+  return close(left.a, right.a) && close(left.b, right.b) && close(left.c, right.c) && close(left.d, right.d) && close(left.e, right.e) && close(left.f, right.f);
+}
+function close(left, right) {
+  return Math.abs(left - right) <= MATRIX_EPSILON;
+}
+function clean(value) {
+  return Math.abs(value) <= MATRIX_EPSILON ? 0 : value;
+}
+function cleanMatrix(source) {
+  return new DOMMatrix([
+    clean(source.a),
+    clean(source.b),
+    clean(source.c),
+    clean(source.d),
+    clean(source.e),
+    clean(source.f)
+  ]);
+}
+function copyMatrix(source) {
+  return new DOMMatrix([
+    source.a,
+    source.b,
+    source.c,
+    source.d,
+    source.e,
+    source.f
+  ]);
+}
+function matrixFromPose(pose) {
+  return new DOMMatrix().translate(pose.position[0], pose.position[1]).rotate(pose.rotationDegrees);
+}
+function finiteStyleNumber(value, fallback, property) {
+  const resolved = value ?? fallback;
+  if (typeof resolved !== "number" || !Number.isFinite(resolved)) {
+    throw new TypeError(`Resolved Group ${property} must be finite.`);
+  }
+  return resolved;
+}
+export {
+  bodyLocalTransformFromPrimitive2D,
+  captureBodyPresentation2D,
+  matrixFromPose,
+  resolveDynamicPresentationTransform2D
+};
+//# sourceMappingURL=presentation.js.map

package/dist/features/physics/lib/2d/canvas/presentation.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/features/physics/lib/2d/canvas/presentation.ts"],
+  "sourcesContent": ["import type { PibblPhysicsPose2D } from \"../../../2d-geometry.js\";\nimport { Group } from \"@pibbl/core\";\n\nconst MATRIX_EPSILON = 1e-6;\n\nexport interface CanvasBodyPresentationCapture2D {\n  readonly initialPose: PibblPhysicsPose2D;\n  readonly parentWorld: DOMMatrix;\n  readonly initialBodyLocal: DOMMatrix;\n  readonly poseResidual: DOMMatrix;\n}\n\nexport function captureBodyPresentation2D(\n  parentWorld: DOMMatrixReadOnly,\n  initialBodyLocal: DOMMatrixReadOnly,\n  componentName: string,\n  requireRigidAncestor = true,\n): CanvasBodyPresentationCapture2D {\n  if (requireRigidAncestor) validateRigidAncestor(parentWorld, componentName);\n  else\n    validateFiniteInvertible(\n      parentWorld,\n      `${componentName} ancestor transform`,\n    );\n  validateFiniteInvertible(\n    initialBodyLocal,\n    `${componentName} authored transform`,\n  );\n  if (requireRigidAncestor) {\n    validateUnskewed(initialBodyLocal, `${componentName} authored transform`);\n  }\n  const world = copyMatrix(parentWorld).multiply(initialBodyLocal);\n  const scaleX = Math.hypot(world.a, world.b);\n  const initialPose = Object.freeze({\n    position: Object.freeze([clean(world.e), clean(world.f)] as const),\n    rotationDegrees: clean(\n      (Math.atan2(world.b / scaleX, world.a / scaleX) * 180) / Math.PI,\n    ),\n  });\n  const poseMatrix = matrixFromPose(initialPose);\n  return Object.freeze({\n    initialPose,\n    parentWorld: copyMatrix(parentWorld),\n    initialBodyLocal: copyMatrix(initialBodyLocal),\n    poseResidual: poseMatrix.inverse().multiply(world),\n  });\n}\n\nexport function resolveDynamicPresentationTransform2D(\n  capture: CanvasBodyPresentationCapture2D,\n  presentedPose: PibblPhysicsPose2D,\n  parentWorld: DOMMatrixReadOnly,\n  currentBodyLocal: DOMMatrixReadOnly,\n  componentName: string,\n): DOMMatrix {\n  validateRigidAncestor(parentWorld, componentName);\n  if (!sameMatrix(parentWorld, capture.parentWorld)) {\n    throw new Error(\n      `${componentName} ancestor transform changed while an enabled dynamic body owns pose. ` +\n        \"Use teleportBody2D(), a kinematic body, or disable physics before authored motion.\",\n    );\n  }\n  if (!sameMatrix(currentBodyLocal, capture.initialBodyLocal)) {\n    throw new Error(\n      `${componentName} authored pose changed while an enabled dynamic body owns pose. ` +\n        \"Use teleportBody2D(), a kinematic body, or disable physics before authored motion.\",\n    );\n  }\n  validatePose(presentedPose, componentName);\n  const presentedWorld = matrixFromPose(presentedPose).multiply(\n    capture.poseResidual,\n  );\n  const result = copyMatrix(parentWorld)\n    .inverse()\n    .multiply(presentedWorld)\n    .multiply(copyMatrix(capture.initialBodyLocal).inverse());\n  return cleanMatrix(result);\n}\n\nexport function bodyLocalTransformFromPrimitive2D(\n  componentType: Function,\n  style: Readonly<Record<PropertyKey, unknown>>,\n): DOMMatrix {\n  let transform = new DOMMatrix().translate(\n    finiteStyleNumber(style.left, 0, \"left\"),\n    finiteStyleNumber(style.top, 0, \"top\"),\n  );\n  if (componentType !== Group) return transform;\n  const scaleX = finiteStyleNumber(style.scaleX, 1, \"scaleX\");\n  const scaleY = finiteStyleNumber(style.scaleY, 1, \"scaleY\");\n  if (scaleX !== 1 || scaleY !== 1) transform = transform.scale(scaleX, scaleY);\n  const rotation = finiteStyleNumber(\n    style.rotationDegrees,\n    0,\n    \"rotationDegrees\",\n  );\n  if (rotation !== 0) {\n    const origin = style.rotationOrigin ?? [0, 0];\n    if (\n      !Array.isArray(origin) ||\n      origin.length !== 2 ||\n      origin.some(\n        (value) => typeof value !== \"number\" || !Number.isFinite(value),\n      )\n    ) {\n      throw new TypeError(\n        \"Group rotationOrigin must be a finite two-dimensional point.\",\n      );\n    }\n    transform = transform\n      .translate(origin[0], origin[1])\n      .rotate(rotation)\n      .translate(-origin[0], -origin[1]);\n  }\n  const translateX = finiteStyleNumber(style.translateX, 0, \"translateX\");\n  const translateY = finiteStyleNumber(style.translateY, 0, \"translateY\");\n  if (translateX !== 0 || translateY !== 0)\n    transform = transform.translate(translateX, translateY);\n  const skewX = finiteStyleNumber(style.skewX, 0, \"skewX\");\n  const skewY = finiteStyleNumber(style.skewY, 0, \"skewY\");\n  if (skewX !== 0) transform = transform.skewX(skewX);\n  if (skewY !== 0) transform = transform.skewY(skewY);\n  return transform;\n}\n\nfunction validatePose(pose: PibblPhysicsPose2D, componentName: string): void {\n  if (\n    !Number.isFinite(pose.position[0]) ||\n    !Number.isFinite(pose.position[1]) ||\n    !Number.isFinite(pose.rotationDegrees)\n  ) {\n    throw new TypeError(\n      `${componentName} physics presentation pose must be finite.`,\n    );\n  }\n}\n\nfunction validateRigidAncestor(\n  matrix: DOMMatrixReadOnly,\n  componentName: string,\n): void {\n  validateFiniteInvertible(\n    matrix,\n    `${componentName} dynamic ancestor transform`,\n  );\n  validateUnskewed(matrix, `${componentName} dynamic ancestor transform`);\n  const scaleX = Math.hypot(matrix.a, matrix.b);\n  const scaleY = Math.hypot(matrix.c, matrix.d);\n  if (!close(scaleX, 1) || !close(scaleY, 1)) {\n    throw new Error(\n      `${componentName} has a non-rigid dynamic ancestor scale. Bake scale into collider geometry or move the body outside that ancestor.`,\n    );\n  }\n}\n\nfunction validateFiniteInvertible(\n  matrix: DOMMatrixReadOnly,\n  label: string,\n): void {\n  const values = [matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f];\n  if (values.some((value) => !Number.isFinite(value))) {\n    throw new TypeError(`${label} must contain only finite values.`);\n  }\n  if (Math.abs(matrix.a * matrix.d - matrix.b * matrix.c) <= 1e-10) {\n    throw new Error(`${label} is noninvertible.`);\n  }\n}\n\nfunction validateUnskewed(matrix: DOMMatrixReadOnly, label: string): void {\n  const scaleX = Math.hypot(matrix.a, matrix.b);\n  const scaleY = Math.hypot(matrix.c, matrix.d);\n  const dot = (matrix.a * matrix.c + matrix.b * matrix.d) / (scaleX * scaleY);\n  if (Math.abs(dot) > 1e-8)\n    throw new Error(`${label} is skewed and cannot define a rigid body pose.`);\n}\n\nfunction sameMatrix(\n  left: DOMMatrixReadOnly,\n  right: DOMMatrixReadOnly,\n): boolean {\n  return (\n    close(left.a, right.a) &&\n    close(left.b, right.b) &&\n    close(left.c, right.c) &&\n    close(left.d, right.d) &&\n    close(left.e, right.e) &&\n    close(left.f, right.f)\n  );\n}\n\nfunction close(left: number, right: number): boolean {\n  return Math.abs(left - right) <= MATRIX_EPSILON;\n}\n\nfunction clean(value: number): number {\n  return Math.abs(value) <= MATRIX_EPSILON ? 0 : value;\n}\n\nfunction cleanMatrix(source: DOMMatrixReadOnly): DOMMatrix {\n  return new DOMMatrix([\n    clean(source.a),\n    clean(source.b),\n    clean(source.c),\n    clean(source.d),\n    clean(source.e),\n    clean(source.f),\n  ]);\n}\n\nfunction copyMatrix(source: DOMMatrixReadOnly): DOMMatrix {\n  return new DOMMatrix([\n    source.a,\n    source.b,\n    source.c,\n    source.d,\n    source.e,\n    source.f,\n  ]);\n}\n\nexport function matrixFromPose(pose: PibblPhysicsPose2D): DOMMatrix {\n  return new DOMMatrix()\n    .translate(pose.position[0], pose.position[1])\n    .rotate(pose.rotationDegrees);\n}\n\nfunction finiteStyleNumber(\n  value: unknown,\n  fallback: number,\n  property: string,\n): number {\n  const resolved = value ?? fallback;\n  if (typeof resolved !== \"number\" || !Number.isFinite(resolved)) {\n    throw new TypeError(`Resolved Group ${property} must be finite.`);\n  }\n  return resolved;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/features/physics/lib/2d/collision/analytic.d.ts

@@ -0,0 +1,15 @@
+export interface AnalyticDistance2D {
+    readonly separation: number;
+    readonly firstX: number;
+    readonly firstY: number;
+    readonly secondX: number;
+    readonly secondY: number;
+    readonly normalX: number;
+    readonly normalY: number;
+}
+export declare function distanceCircleToCircle2D(firstX: number, firstY: number, firstRadius: number, secondX: number, secondY: number, secondRadius: number, fallbackNormalX?: number, fallbackNormalY?: number): AnalyticDistance2D;
+export declare function distancePointToCircle2D(pointX: number, pointY: number, centerX: number, centerY: number, radius: number, fallbackNormalX?: number, fallbackNormalY?: number): AnalyticDistance2D;
+export declare function distancePointToCapsule2D(pointX: number, pointY: number, startX: number, startY: number, endX: number, endY: number, radius: number, fallbackNormalX?: number, fallbackNormalY?: number): AnalyticDistance2D;
+export declare function distancePointToSegment2D(pointX: number, pointY: number, startX: number, startY: number, endX: number, endY: number, fallbackNormalX?: number, fallbackNormalY?: number): AnalyticDistance2D;
+export declare function distanceCapsuleToCapsule2D(firstStartX: number, firstStartY: number, firstEndX: number, firstEndY: number, firstRadius: number, secondStartX: number, secondStartY: number, secondEndX: number, secondEndY: number, secondRadius: number, fallbackNormalX?: number, fallbackNormalY?: number): AnalyticDistance2D;
+export declare function closestPointOnSegment2D(pointX: number, pointY: number, startX: number, startY: number, endX: number, endY: number): readonly [number, number, number];

package/dist/features/physics/lib/2d/collision/analytic.js

@@ -0,0 +1,151 @@
+import { GEOMETRY_EPSILON } from "../numeric-policy.js";
+function distanceCircleToCircle2D(firstX, firstY, firstRadius, secondX, secondY, secondRadius, fallbackNormalX = 1, fallbackNormalY = 0) {
+  const dx = firstX - secondX;
+  const dy = firstY - secondY;
+  const distance = Math.hypot(dx, dy);
+  const normal = unitOrFallback(dx, dy, fallbackNormalX, fallbackNormalY);
+  return {
+    separation: distance - firstRadius - secondRadius,
+    firstX: firstX - normal[0] * firstRadius,
+    firstY: firstY - normal[1] * firstRadius,
+    secondX: secondX + normal[0] * secondRadius,
+    secondY: secondY + normal[1] * secondRadius,
+    normalX: normal[0],
+    normalY: normal[1]
+  };
+}
+function distancePointToCircle2D(pointX, pointY, centerX, centerY, radius, fallbackNormalX = 1, fallbackNormalY = 0) {
+  const dx = pointX - centerX;
+  const dy = pointY - centerY;
+  const distance = Math.hypot(dx, dy);
+  const normal = unitOrFallback(dx, dy, fallbackNormalX, fallbackNormalY);
+  return {
+    separation: distance - radius,
+    firstX: pointX,
+    firstY: pointY,
+    secondX: centerX + normal[0] * radius,
+    secondY: centerY + normal[1] * radius,
+    normalX: normal[0],
+    normalY: normal[1]
+  };
+}
+function distancePointToCapsule2D(pointX, pointY, startX, startY, endX, endY, radius, fallbackNormalX = 1, fallbackNormalY = 0) {
+  const closest = closestPointOnSegment2D(pointX, pointY, startX, startY, endX, endY);
+  return distancePointToCircle2D(
+    pointX,
+    pointY,
+    closest[0],
+    closest[1],
+    radius,
+    fallbackNormalX,
+    fallbackNormalY
+  );
+}
+function distancePointToSegment2D(pointX, pointY, startX, startY, endX, endY, fallbackNormalX = 1, fallbackNormalY = 0) {
+  const closest = closestPointOnSegment2D(pointX, pointY, startX, startY, endX, endY);
+  const dx = pointX - closest[0];
+  const dy = pointY - closest[1];
+  const distance = Math.hypot(dx, dy);
+  const normal = unitOrFallback(dx, dy, fallbackNormalX, fallbackNormalY);
+  return {
+    separation: distance,
+    firstX: pointX,
+    firstY: pointY,
+    secondX: closest[0],
+    secondY: closest[1],
+    normalX: normal[0],
+    normalY: normal[1]
+  };
+}
+function distanceCapsuleToCapsule2D(firstStartX, firstStartY, firstEndX, firstEndY, firstRadius, secondStartX, secondStartY, secondEndX, secondEndY, secondRadius, fallbackNormalX = 1, fallbackNormalY = 0) {
+  const closest = closestPointsOnSegments2D(
+    firstStartX,
+    firstStartY,
+    firstEndX,
+    firstEndY,
+    secondStartX,
+    secondStartY,
+    secondEndX,
+    secondEndY
+  );
+  const dx = closest[0] - closest[2];
+  const dy = closest[1] - closest[3];
+  const distance = Math.hypot(dx, dy);
+  const normal = unitOrFallback(dx, dy, fallbackNormalX, fallbackNormalY);
+  return {
+    separation: distance - firstRadius - secondRadius,
+    firstX: closest[0] - normal[0] * firstRadius,
+    firstY: closest[1] - normal[1] * firstRadius,
+    secondX: closest[2] + normal[0] * secondRadius,
+    secondY: closest[3] + normal[1] * secondRadius,
+    normalX: normal[0],
+    normalY: normal[1]
+  };
+}
+function closestPointsOnSegments2D(firstStartX, firstStartY, firstEndX, firstEndY, secondStartX, secondStartY, secondEndX, secondEndY) {
+  const candidates = [];
+  const firstDx = firstEndX - firstStartX;
+  const firstDy = firstEndY - firstStartY;
+  const secondDx = secondEndX - secondStartX;
+  const secondDy = secondEndY - secondStartY;
+  const denominator = firstDx * secondDy - firstDy * secondDx;
+  if (Math.abs(denominator) > GEOMETRY_EPSILON) {
+    const offsetX = secondStartX - firstStartX;
+    const offsetY = secondStartY - firstStartY;
+    const firstAmount = (offsetX * secondDy - offsetY * secondDx) / denominator;
+    const secondAmount = (offsetX * firstDy - offsetY * firstDx) / denominator;
+    if (firstAmount >= 0 && firstAmount <= 1 && secondAmount >= 0 && secondAmount <= 1) {
+      const x = firstStartX + firstAmount * firstDx;
+      const y = firstStartY + firstAmount * firstDy;
+      candidates.push([x, y, x, y]);
+    }
+  }
+  addEndpointCandidate(candidates, firstStartX, firstStartY, secondStartX, secondStartY, secondEndX, secondEndY, true);
+  addEndpointCandidate(candidates, firstEndX, firstEndY, secondStartX, secondStartY, secondEndX, secondEndY, true);
+  addEndpointCandidate(candidates, secondStartX, secondStartY, firstStartX, firstStartY, firstEndX, firstEndY, false);
+  addEndpointCandidate(candidates, secondEndX, secondEndY, firstStartX, firstStartY, firstEndX, firstEndY, false);
+  candidates.sort(compareSegmentCandidates);
+  return candidates[0];
+}
+function addEndpointCandidate(output, pointX, pointY, startX, startY, endX, endY, pointBelongsToFirst) {
+  const closest = closestPointOnSegment2D(pointX, pointY, startX, startY, endX, endY);
+  output.push(pointBelongsToFirst ? [pointX, pointY, closest[0], closest[1]] : [closest[0], closest[1], pointX, pointY]);
+}
+function compareSegmentCandidates(first, second) {
+  const firstDistance = (first[0] - first[2]) ** 2 + (first[1] - first[3]) ** 2;
+  const secondDistance = (second[0] - second[2]) ** 2 + (second[1] - second[3]) ** 2;
+  if (Math.abs(firstDistance - secondDistance) > GEOMETRY_EPSILON * GEOMETRY_EPSILON) {
+    return firstDistance - secondDistance;
+  }
+  const firstKey = [(first[0] + first[2]) / 2, (first[1] + first[3]) / 2, Math.min(first[0], first[2]), Math.min(first[1], first[3])];
+  const secondKey = [(second[0] + second[2]) / 2, (second[1] + second[3]) / 2, Math.min(second[0], second[2]), Math.min(second[1], second[3])];
+  for (let index = 0; index < firstKey.length; index += 1) {
+    const difference = firstKey[index] - secondKey[index];
+    if (Math.abs(difference) > GEOMETRY_EPSILON) return difference;
+  }
+  return 0;
+}
+function closestPointOnSegment2D(pointX, pointY, startX, startY, endX, endY) {
+  const dx = endX - startX;
+  const dy = endY - startY;
+  const denominator = dx * dx + dy * dy;
+  const amount = denominator <= GEOMETRY_EPSILON * GEOMETRY_EPSILON ? 0 : Math.max(0, Math.min(1, ((pointX - startX) * dx + (pointY - startY) * dy) / denominator));
+  return [startX + amount * dx, startY + amount * dy, amount];
+}
+function unitOrFallback(x, y, fallbackX, fallbackY) {
+  const length = Math.hypot(x, y);
+  if (length > GEOMETRY_EPSILON) {
+    return [x / length, y / length];
+  }
+  const fallbackLength = Math.hypot(fallbackX, fallbackY);
+  return fallbackLength > GEOMETRY_EPSILON ? [fallbackX / fallbackLength, fallbackY / fallbackLength] : [1, 0];
+}
+export {
+  closestPointOnSegment2D,
+  distanceCapsuleToCapsule2D,
+  distanceCircleToCircle2D,
+  distancePointToCapsule2D,
+  distancePointToCircle2D,
+  distancePointToSegment2D
+};
+//# sourceMappingURL=analytic.js.map

package/dist/features/physics/lib/2d/collision/analytic.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/features/physics/lib/2d/collision/analytic.ts"],
+  "sourcesContent": ["import { GEOMETRY_EPSILON } from '../numeric-policy.js';\n\nexport interface AnalyticDistance2D {\n  readonly separation: number;\n  readonly firstX: number;\n  readonly firstY: number;\n  readonly secondX: number;\n  readonly secondY: number;\n  readonly normalX: number;\n  readonly normalY: number;\n}\n\nexport function distanceCircleToCircle2D(\n  firstX: number,\n  firstY: number,\n  firstRadius: number,\n  secondX: number,\n  secondY: number,\n  secondRadius: number,\n  fallbackNormalX = 1,\n  fallbackNormalY = 0,\n): AnalyticDistance2D {\n  const dx = firstX - secondX;\n  const dy = firstY - secondY;\n  const distance = Math.hypot(dx, dy);\n  const normal = unitOrFallback(dx, dy, fallbackNormalX, fallbackNormalY);\n  return {\n    separation: distance - firstRadius - secondRadius,\n    firstX: firstX - normal[0] * firstRadius,\n    firstY: firstY - normal[1] * firstRadius,\n    secondX: secondX + normal[0] * secondRadius,\n    secondY: secondY + normal[1] * secondRadius,\n    normalX: normal[0],\n    normalY: normal[1],\n  };\n}\n\nexport function distancePointToCircle2D(\n  pointX: number,\n  pointY: number,\n  centerX: number,\n  centerY: number,\n  radius: number,\n  fallbackNormalX = 1,\n  fallbackNormalY = 0,\n): AnalyticDistance2D {\n  const dx = pointX - centerX;\n  const dy = pointY - centerY;\n  const distance = Math.hypot(dx, dy);\n  const normal = unitOrFallback(dx, dy, fallbackNormalX, fallbackNormalY);\n  return {\n    separation: distance - radius,\n    firstX: pointX,\n    firstY: pointY,\n    secondX: centerX + normal[0] * radius,\n    secondY: centerY + normal[1] * radius,\n    normalX: normal[0],\n    normalY: normal[1],\n  };\n}\n\nexport function distancePointToCapsule2D(\n  pointX: number,\n  pointY: number,\n  startX: number,\n  startY: number,\n  endX: number,\n  endY: number,\n  radius: number,\n  fallbackNormalX = 1,\n  fallbackNormalY = 0,\n): AnalyticDistance2D {\n  const closest = closestPointOnSegment2D(pointX, pointY, startX, startY, endX, endY);\n  return distancePointToCircle2D(\n    pointX,\n    pointY,\n    closest[0],\n    closest[1],\n    radius,\n    fallbackNormalX,\n    fallbackNormalY,\n  );\n}\n\nexport function distancePointToSegment2D(\n  pointX: number,\n  pointY: number,\n  startX: number,\n  startY: number,\n  endX: number,\n  endY: number,\n  fallbackNormalX = 1,\n  fallbackNormalY = 0,\n): AnalyticDistance2D {\n  const closest = closestPointOnSegment2D(pointX, pointY, startX, startY, endX, endY);\n  const dx = pointX - closest[0];\n  const dy = pointY - closest[1];\n  const distance = Math.hypot(dx, dy);\n  const normal = unitOrFallback(dx, dy, fallbackNormalX, fallbackNormalY);\n  return {\n    separation: distance,\n    firstX: pointX,\n    firstY: pointY,\n    secondX: closest[0],\n    secondY: closest[1],\n    normalX: normal[0],\n    normalY: normal[1],\n  };\n}\n\nexport function distanceCapsuleToCapsule2D(\n  firstStartX: number,\n  firstStartY: number,\n  firstEndX: number,\n  firstEndY: number,\n  firstRadius: number,\n  secondStartX: number,\n  secondStartY: number,\n  secondEndX: number,\n  secondEndY: number,\n  secondRadius: number,\n  fallbackNormalX = 1,\n  fallbackNormalY = 0,\n): AnalyticDistance2D {\n  const closest = closestPointsOnSegments2D(\n    firstStartX,\n    firstStartY,\n    firstEndX,\n    firstEndY,\n    secondStartX,\n    secondStartY,\n    secondEndX,\n    secondEndY,\n  );\n  const dx = closest[0] - closest[2];\n  const dy = closest[1] - closest[3];\n  const distance = Math.hypot(dx, dy);\n  const normal = unitOrFallback(dx, dy, fallbackNormalX, fallbackNormalY);\n  return {\n    separation: distance - firstRadius - secondRadius,\n    firstX: closest[0] - normal[0] * firstRadius,\n    firstY: closest[1] - normal[1] * firstRadius,\n    secondX: closest[2] + normal[0] * secondRadius,\n    secondY: closest[3] + normal[1] * secondRadius,\n    normalX: normal[0],\n    normalY: normal[1],\n  };\n}\n\nfunction closestPointsOnSegments2D(\n  firstStartX: number,\n  firstStartY: number,\n  firstEndX: number,\n  firstEndY: number,\n  secondStartX: number,\n  secondStartY: number,\n  secondEndX: number,\n  secondEndY: number,\n): readonly [number, number, number, number] {\n  const candidates: [number, number, number, number][] = [];\n  const firstDx = firstEndX - firstStartX;\n  const firstDy = firstEndY - firstStartY;\n  const secondDx = secondEndX - secondStartX;\n  const secondDy = secondEndY - secondStartY;\n  const denominator = firstDx * secondDy - firstDy * secondDx;\n  if (Math.abs(denominator) > GEOMETRY_EPSILON) {\n    const offsetX = secondStartX - firstStartX;\n    const offsetY = secondStartY - firstStartY;\n    const firstAmount = (offsetX * secondDy - offsetY * secondDx) / denominator;\n    const secondAmount = (offsetX * firstDy - offsetY * firstDx) / denominator;\n    if (firstAmount >= 0 && firstAmount <= 1 && secondAmount >= 0 && secondAmount <= 1) {\n      const x = firstStartX + firstAmount * firstDx;\n      const y = firstStartY + firstAmount * firstDy;\n      candidates.push([x, y, x, y]);\n    }\n  }\n  addEndpointCandidate(candidates, firstStartX, firstStartY, secondStartX, secondStartY, secondEndX, secondEndY, true);\n  addEndpointCandidate(candidates, firstEndX, firstEndY, secondStartX, secondStartY, secondEndX, secondEndY, true);\n  addEndpointCandidate(candidates, secondStartX, secondStartY, firstStartX, firstStartY, firstEndX, firstEndY, false);\n  addEndpointCandidate(candidates, secondEndX, secondEndY, firstStartX, firstStartY, firstEndX, firstEndY, false);\n  candidates.sort(compareSegmentCandidates);\n  return candidates[0]!;\n}\n\nfunction addEndpointCandidate(\n  output: [number, number, number, number][],\n  pointX: number,\n  pointY: number,\n  startX: number,\n  startY: number,\n  endX: number,\n  endY: number,\n  pointBelongsToFirst: boolean,\n): void {\n  const closest = closestPointOnSegment2D(pointX, pointY, startX, startY, endX, endY);\n  output.push(pointBelongsToFirst\n    ? [pointX, pointY, closest[0], closest[1]]\n    : [closest[0], closest[1], pointX, pointY]);\n}\n\nfunction compareSegmentCandidates(\n  first: readonly [number, number, number, number],\n  second: readonly [number, number, number, number],\n): number {\n  const firstDistance = (first[0] - first[2]) ** 2 + (first[1] - first[3]) ** 2;\n  const secondDistance = (second[0] - second[2]) ** 2 + (second[1] - second[3]) ** 2;\n  if (Math.abs(firstDistance - secondDistance) > GEOMETRY_EPSILON * GEOMETRY_EPSILON) {\n    return firstDistance - secondDistance;\n  }\n  const firstKey = [(first[0] + first[2]) / 2, (first[1] + first[3]) / 2, Math.min(first[0], first[2]), Math.min(first[1], first[3])];\n  const secondKey = [(second[0] + second[2]) / 2, (second[1] + second[3]) / 2, Math.min(second[0], second[2]), Math.min(second[1], second[3])];\n  for (let index = 0; index < firstKey.length; index += 1) {\n    const difference = firstKey[index]! - secondKey[index]!;\n    if (Math.abs(difference) > GEOMETRY_EPSILON) return difference;\n  }\n  return 0;\n}\n\nexport function closestPointOnSegment2D(\n  pointX: number,\n  pointY: number,\n  startX: number,\n  startY: number,\n  endX: number,\n  endY: number,\n): readonly [number, number, number] {\n  const dx = endX - startX;\n  const dy = endY - startY;\n  const denominator = dx * dx + dy * dy;\n  const amount = denominator <= GEOMETRY_EPSILON * GEOMETRY_EPSILON\n    ? 0\n    : Math.max(0, Math.min(1, ((pointX - startX) * dx + (pointY - startY) * dy) / denominator));\n  return [startX + amount * dx, startY + amount * dy, amount];\n}\n\nfunction unitOrFallback(\n  x: number,\n  y: number,\n  fallbackX: number,\n  fallbackY: number,\n): readonly [number, number] {\n  const length = Math.hypot(x, y);\n  if (length > GEOMETRY_EPSILON) {\n    return [x / length, y / length];\n  }\n  const fallbackLength = Math.hypot(fallbackX, fallbackY);\n  return fallbackLength > GEOMETRY_EPSILON\n    ? [fallbackX / fallbackLength, fallbackY / fallbackLength]\n    : [1, 0];\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/features/physics/lib/2d/collision/casts.d.ts

@@ -0,0 +1,37 @@
+import type { PibblPhysicsPose2D, PibblPhysicsRay2D, PibblPhysicsShape2D, PibblPhysicsShapeHit2D, PibblPhysicsVector2 } from '../../../2d-geometry.js';
+/**
+ * Casts a ray against one posed shape and returns its first hit or null.
+ *
+ * @param shape - Shape to intersect. See {@link PibblPhysicsShape2D}.
+ * @param publicPose - Target shape pose. See {@link PibblPhysicsPose2D}.
+ * @param ray - Ray origin, direction, and travel limit. See {@link PibblPhysicsRay2D}.
+ * @param options - Whether initial overlap counts as a hit.
+ * @returns The first shape hit, or null when there is no hit. See {@link PibblPhysicsShapeHit2D}.
+ *
+ * @see {@link PibblPhysicsShape2D}
+ * @see {@link PibblPhysicsPose2D}
+ * @see {@link PibblPhysicsRay2D}
+ * @see {@link PibblPhysicsShapeHit2D}
+ */
+export declare function raycastShape2D(shape: PibblPhysicsShape2D, publicPose: PibblPhysicsPose2D, ray: PibblPhysicsRay2D, options?: Readonly<{
+    includeInitialOverlap?: boolean;
+}>): PibblPhysicsShapeHit2D | null;
+/**
+ * Sweeps a posed shape along a translation against another posed shape and returns a hit or null.
+ *
+ * @param moving - Shape to sweep. See {@link PibblPhysicsShape2D}.
+ * @param publicFrom - Initial pose of the moving shape. See {@link PibblPhysicsPose2D}.
+ * @param publicTranslation - Translation vector for the sweep. See {@link PibblPhysicsVector2}.
+ * @param target - Stationary shape to test against. See {@link PibblPhysicsShape2D}.
+ * @param publicTargetPose - Pose of the stationary shape. See {@link PibblPhysicsPose2D}.
+ * @param options - Whether initial overlap counts as a hit.
+ * @returns The first sweep hit, or null when there is no hit. See {@link PibblPhysicsShapeHit2D}.
+ *
+ * @see {@link PibblPhysicsShape2D}
+ * @see {@link PibblPhysicsPose2D}
+ * @see {@link PibblPhysicsVector2}
+ * @see {@link PibblPhysicsShapeHit2D}
+ */
+export declare function shapeCastAgainstShape2D(moving: PibblPhysicsShape2D, publicFrom: PibblPhysicsPose2D, publicTranslation: PibblPhysicsVector2, target: PibblPhysicsShape2D, publicTargetPose: PibblPhysicsPose2D, options?: Readonly<{
+    includeInitialOverlap?: boolean;
+}>): PibblPhysicsShapeHit2D | null;