[prakashUXtech]

What

PixelBuffer.composite(_:through:mode:opacity:filter:) and AffineMatrix.bounds(of:_:) in
Sources/CoreRaster/Compositing/CompositeAffine.swift replace the AC-0 stubs (AC-5).

• bounds(of:_:) maps all four corners of a width x height image, floors the least x/y and
  ceils the greatest. It returns nil when an entry or a corner isn't finite. Edges are clamped to ±2^52 in
  Double before the Int conversion, so a huge matrix can't overflow and x + width always fits.
• composite(through:) checks the opacity (0...1, finite) and the matrix (finite, invertible) before
  it changes anything. It then clips the bounds to the backdrop and resamples the layer into a buffer
  the size of that clipped rectangle. To do that it calls the merged AC-3 transformed with the matrix
  moved by the rectangle's origin, so each backdrop pixel samples the same source point it would in a
  full-size copy. Last, it composites that piece at the origin with the existing
  composite(_:x:y:mode:opacity:) row blend. Sampling and blending are reused, not copied, and
  AffineTransform.swift is unchanged (no visibility change needed). No full-size intermediate is
  built, and rows outside the bounds are never written.
• CompositeAffineTests is turned on (no assertion changed). It gains badInputThrowsAndLeavesBackdrop:
  NaN/infinite entries, singular matrices, and opacities 1.5, -0.1, NaN and infinity, including a bad
  opacity with an off-backdrop matrix. Each throws RasterError and leaves the backdrop == to a copy
  taken before.
• AffineStubTests.swift is deleted: its only two cases were the composite and bounds stubs, so
  removing them left an empty suite.
• Two mutation entries in Tests/mutations/CoreRaster.CompositeAffine.json.

Why

Packet docs/blueprints/core/features/affine-composite.md, slice AC-comp, task AC-5. A moved, scaled
or rotated layer now composites onto a backdrop in place, equal to transform-then-composite, without
building a full-size copy. AC-6's CPU affine call and the KJ-AC walk build on this.

Packet ambiguities resolved

• Touched region = the corners' integer bounds, as the pseudocode says. A kernel's fringe can reach
  just past the corners: bilinear at 0.5 reaches about 0.75 output px, and Lanczos-3 reaches further.
  Those fringe pixels are not drawn, which matches "for each backdrop pixel in them" and
  rowsOutsideBoundsAreUntouched. Equality with transform-then-composite holds for layers whose edge
  pixels are transparent, as the fixtures' layers are. A borderless layer's fringe past the integer
  bounds is clipped.
• Validation order. The opacity is checked first, then the matrix, before the off-backdrop early
  return. So bad input always throws, even when nothing would be drawn.
• Overflow mid-composite. A non-finite blend result still throws as the offset composite does: rows
  above it are already written. Only the validation failures promise an unchanged backdrop.
• Huge matrices. bounds clamps to ±2^52 rather than returning nil, so nil keeps the packet's
  meaning: non-finite only.

Proof

• swift test --filter CompositeAffineTests: 6/6 pass (equalsTransformThenComposite,
  wholePixelTranslationsAreExact, rotatedBoundsCoverCorners, rowsOutsideBoundsAreUntouched,
  offBackdropChangesNothing, badInputThrowsAndLeavesBackdrop).
• scripts/mutate --validate: OK. scripts/mutate --run --plan CoreRaster.CompositeAffine: 2/2 caught.
  "bounds from two corners only" is caught by rotatedBoundsCoverCorners. "Opacity applied twice" is
  caught first by wholePixelTranslationsAreExact; equalsTransformThenComposite covers it too.
• scripts/ci: CI: PASS on the head below, rebased on origin/dev.

Docs MCP: apple-docs was used to check FloatingPoint.rounded(_:) and FloatingPointRoundingRule
(.down/.up). No other new platform or library API is used.

Part of #434

Belt-Lead: act-1a150bfbcf7-sfwy
Feature: affine-composite
Slice: AC-comp
Mutate: 2/2 CoreRaster.CompositeAffine
Fast-Check: pass
Head: 8446798

---

[github-actions]

Fast lane: merged into dev (146 lines, 4 files, Fast-Check marker).