func (c *Context) DrawShapedGlyphs(glyphs []text.ShapedGlyph, face text.Face, x, y float64) {
	if face == nil || len(glyphs) == 0 {
		return
	}

	defer c.setGPUClipRect()()

	col := FromColor(c.currentColor())
	target := c.gpuRenderTarget()

	if rc := c.gpuCtxOps(); rc != nil {
		if sta, ok := rc.(GPUShapedTextAccelerator); ok {
			if sta.DrawShapedGlyphMaskText(target, face, glyphs, x, y, col, c.totalMatrix(), c.deviceScale) == nil {
				return
			}
		}
	}

	a := Accelerator()
	if a != nil {
		if sta, ok := a.(GPUShapedTextAccelerator); ok {
			if sta.DrawShapedGlyphMaskText(target, face, glyphs, x, y, col, c.totalMatrix(), c.deviceScale) == nil {
				return
			}
		}
	}

	// Fallback: reconstruct string is not possible from glyphs,
	// so render each glyph outline through the fill pipeline.
	c.drawShapedGlyphsAsOutlines(glyphs, face, x, y)
}

func (c *Context) DrawString(s string, x, y float64) {
	if c.face == nil {
		return
	}

	// Set GPU scissor rect for rectangular clips.
	defer c.setGPUClipRect()()

	switch c.selectTextStrategy() {
	case TextModeGlyphMask:
		// Try GPU glyph mask (Tier 6) first; fall back to MSDF, then CPU.
		if c.tryGPUGlyphMaskText(s, x, y) {
			return
		}
		if c.tryGPUText(s, x, y) {
			return
		}
		c.drawStringCPU(s, x, y)
	case TextModeAliased:
		// Aliased text through glyph mask pipeline with binary rasterization.
		// Same Tier 6 atlas + GPU path, but NoAAFiller instead of AnalyticFiller.
		if c.tryGPUGlyphMaskTextAliased(s, x, y) {
			return
		}
		// CPU fallback: bitmap rasterization (already non-AA at small sizes).
		c.flushGPUAccelerator()
		c.drawStringCPU(s, x, y)
	case TextModeMSDF:
		// Try GPU MSDF first; fall back to CPU if unavailable.
		if c.tryGPUText(s, x, y) {
			return
		}
		c.drawStringCPU(s, x, y)
	case TextModeVector:
		// Vector text is rendered as glyph outline paths through the normal
		// fill pipeline (doFill). This routes through GPU stencil+cover when
		// a SurfaceTarget is active, or CPU when standalone. No explicit
		// flush here — doFill() manages GPU/CPU routing and any necessary
		// flush internally. An explicit flush would create a mid-frame
		// render pass with LoadOpClear, wiping previously drawn content.
		c.drawStringAsOutlines(s, x, y)
	case TextModeBitmap:
		// Skip GPU entirely, use CPU pipeline directly.
		c.flushGPUAccelerator()
		c.drawStringCPU(s, x, y)
	default:	// TextModeAuto — current behavior
		// ADR-027: CJK ≤64px → prefer Tier 6 (bitmap) over MSDF.
		// MSDF at 64px reference produces stroke fusion on dense CJK characters.
		if c.isCJKText(s) && c.glyphMaskDeviceSize() <= glyphMaskMaxSizeCJK {
			if c.tryGPUGlyphMaskText(s, x, y) {
				return
			}
		}
		if c.tryGPUText(s, x, y) {
			return
		}
		c.drawStringCPU(s, x, y)
	}
}

func (c *Context) DrawStringAnchored(s string, x, y, ax, ay float64) {
	if c.face == nil {
		return
	}

	// Measure the text and calculate offset based on anchor.
	// The anchor maps linearly within the text bounding box:
	//   ay=0 → y is the top of the text (baseline = y + ascent)
	//   ay=0.5 → y is the vertical center (baseline = y + ascent - h/2)
	//   ay=1 → y is the bottom (baseline = y + ascent - h)
	// Formula: baseline = y + ascent - ay * h
	// where h = ascent + descent (visual bounding box, no lineGap).
	w, _ := text.Measure(s, c.face)
	metrics := c.face.Metrics()
	h := metrics.Ascent + metrics.Descent
	x -= w * ax
	y = y + metrics.Ascent - ay*h

	// Delegate to DrawString which handles TextMode routing.
	c.DrawString(s, x, y)
}

func (c *Context) DrawStringWrapped(s string, x, y, ax, ay, width, lineSpacing float64, align Align) {
	if c.face == nil {
		return
	}
	lines := c.WordWrap(s, width)
	if len(lines) == 0 {
		return
	}

	metrics := c.face.Metrics()
	fh := metrics.LineHeight()

	// Visual height of the text block:
	// - (n-1) inter-line gaps of fh*lineSpacing
	// - ascent above first baseline + descent below last baseline
	n := float64(len(lines))
	h := (n-1)*fh*lineSpacing + metrics.Ascent + metrics.Descent

	// Adjust starting position by anchor (bounding-box model):
	//   ay=0 → y is the top of the block (first baseline = y + ascent)
	//   ay=0.5 → y is the vertical center
	//   ay=1 → y is the bottom of the block
	// Formula: first_baseline = y + ascent - ay * h
	x -= ax * width
	y = y + metrics.Ascent - ay*h

	// Adjust x base for alignment
	switch align {
	case text.AlignCenter:
		x += width / 2
	case text.AlignRight:
		x += width
	}

	for _, line := range lines {
		drawX := x
		switch align {
		case text.AlignCenter:
			lw, _ := c.MeasureString(line)
			drawX = x - lw/2
		case text.AlignRight:
			lw, _ := c.MeasureString(line)
			drawX = x - lw
		}
		c.DrawString(line, drawX, y)
		y += fh * lineSpacing
	}
}

func (c *Context) Font() text.Face {
	return c.face
}

func (c *Context) LoadFontFace(path string, points float64) error {
	source, err := text.NewFontSourceFromFile(path)
	if err != nil {
		return err
	}
	c.face = source.Face(points)
	return nil
}

func (c *Context) MeasureMultilineString(s string, lineSpacing float64) (width, height float64) {
	if c.face == nil {
		return 0, 0
	}
	lines := splitLines(s)
	metrics := c.face.Metrics()
	fh := metrics.LineHeight()
	for _, line := range lines {
		lw, _ := text.Measure(line, c.face)
		if lw > width {
			width = lw
		}
	}
	// Visual height: ascent above first baseline + (n-1) inter-line gaps + descent below last baseline.
	n := float64(len(lines))
	height = (n-1)*fh*lineSpacing + metrics.Ascent + metrics.Descent
	return
}

func (c *Context) MeasureString(s string) (w, h float64) {
	if c.face == nil {
		return 0, 0
	}
	return text.Measure(s, c.face)
}

func (c *Context) SetFont(face text.Face) {
	c.face = face
}

func (c *Context) StrokeString(s string, x, y float64) {
	if c.face == nil {
		return
	}
	path := c.textOutlinePath(s, x, y)
	if path == nil {
		return
	}

	devicePath := path.Transform(c.totalMatrix())
	c.trackDamage(devicePath.Bounds())

	// Set GPU scissor rect for rectangular clips.
	defer c.setGPUClipRect()()

	// Save and restore context path — doStroke uses c.path.
	savedPath := c.path
	c.path = devicePath
	_ = c.doStroke()
	c.path = savedPath
}

func (c *Context) StrokeStringAnchored(s string, x, y, ax, ay float64) {
	if c.face == nil {
		return
	}

	w, _ := text.Measure(s, c.face)
	metrics := c.face.Metrics()
	h := metrics.Ascent + metrics.Descent
	x -= w * ax
	y = y + metrics.Ascent - ay*h

	c.StrokeString(s, x, y)
}

func (c *Context) TextPath(s string, x, y float64) *Path {
	if c.face == nil {
		return nil
	}
	return c.textOutlinePath(s, x, y)
}

func (c *Context) WordWrap(s string, w float64) []string {
	if c.face == nil {
		return []string{s}
	}
	results := text.WrapText(s, c.face, w, text.WrapWord)
	lines := make([]string, len(results))
	for i, r := range results {
		lines[i] = r.Text
	}
	return lines
}