chore(v2): vendor dependencies for offline/China builds

go mod vendor pins onnxruntime_go v1.12.1, Gio and the rest into v2/vendor
so go run/build work without hitting proxy.golang.org (blocked/slow in
China). Verified: CGO_ENABLED=1 go build -mod=vendor ./internal/spike and
GOOS=windows go build -mod=vendor ./internal/ui both pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

v2/vendor/golang.org/x/image/font/basicfont/basicfont.go

@@ -0,0 +1,138 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:generate go run gen.go
+
+// Package basicfont provides fixed-size font faces.
+package basicfont // import "golang.org/x/image/font/basicfont"
+
+import (
+	"image"
+
+	"golang.org/x/image/font"
+	"golang.org/x/image/math/fixed"
+)
+
+// Range maps a contiguous range of runes to vertically adjacent sub-images of
+// a Face's Mask image. The rune range is inclusive on the low end and
+// exclusive on the high end.
+//
+// If Low <= r && r < High, then the rune r is mapped to the sub-image of
+// Face.Mask whose bounds are image.Rect(0, y*h, Face.Width, (y+1)*h),
+// where y = (int(r-Low) + Offset) and h = (Face.Ascent + Face.Descent).
+type Range struct {
+	Low, High rune
+	Offset    int
+}
+
+// Face7x13 is a Face derived from the public domain X11 misc-fixed font files.
+//
+// At the moment, it holds the printable characters in ASCII starting with
+// space, and the Unicode replacement character U+FFFD.
+//
+// Its data is entirely self-contained and does not require loading from
+// separate files.
+var Face7x13 = &Face{
+	Advance: 7,
+	Width:   6,
+	Height:  13,
+	Ascent:  11,
+	Descent: 2,
+	Mask:    mask7x13,
+	Ranges: []Range{
+		{'\u0020', '\u007f', 0},
+		{'\ufffd', '\ufffe', 95},
+	},
+}
+
+// Face is a basic font face whose glyphs all have the same metrics.
+//
+// It is safe to use concurrently.
+type Face struct {
+	// Advance is the glyph advance, in pixels.
+	Advance int
+	// Width is the glyph width, in pixels.
+	Width int
+	// Height is the inter-line height, in pixels.
+	Height int
+	// Ascent is the glyph ascent, in pixels.
+	Ascent int
+	// Descent is the glyph descent, in pixels.
+	Descent int
+	// Left is the left side bearing, in pixels. A positive value means that
+	// all of a glyph is to the right of the dot.
+	Left int
+
+	// Mask contains all of the glyph masks. Its width is typically the Face's
+	// Width, and its height a multiple of the Face's Height.
+	Mask image.Image
+	// Ranges map runes to sub-images of Mask. The rune ranges must not
+	// overlap, and must be in increasing rune order.
+	Ranges []Range
+}
+
+func (f *Face) Close() error                   { return nil }
+func (f *Face) Kern(r0, r1 rune) fixed.Int26_6 { return 0 }
+
+func (f *Face) Metrics() font.Metrics {
+	return font.Metrics{
+		Height:     fixed.I(f.Height),
+		Ascent:     fixed.I(f.Ascent),
+		Descent:    fixed.I(f.Descent),
+		XHeight:    fixed.I(f.Ascent),
+		CapHeight:  fixed.I(f.Ascent),
+		CaretSlope: image.Point{X: 0, Y: 1},
+	}
+}
+
+func (f *Face) Glyph(dot fixed.Point26_6, r rune) (
+	dr image.Rectangle, mask image.Image, maskp image.Point, advance fixed.Int26_6, ok bool) {
+
+	if found, rng := f.find(r); rng != nil {
+		maskp.Y = (int(found-rng.Low) + rng.Offset) * (f.Ascent + f.Descent)
+		x := int(dot.X+32)>>6 + f.Left
+		y := int(dot.Y+32) >> 6
+		dr = image.Rectangle{
+			Min: image.Point{
+				X: x,
+				Y: y - f.Ascent,
+			},
+			Max: image.Point{
+				X: x + f.Width,
+				Y: y + f.Descent,
+			},
+		}
+
+		return dr, f.Mask, maskp, fixed.I(f.Advance), r == found
+	}
+	return image.Rectangle{}, nil, image.Point{}, 0, false
+}
+
+func (f *Face) GlyphBounds(r rune) (bounds fixed.Rectangle26_6, advance fixed.Int26_6, ok bool) {
+	if found, rng := f.find(r); rng != nil {
+		return fixed.R(0, -f.Ascent, f.Width, +f.Descent), fixed.I(f.Advance), r == found
+	}
+	return fixed.Rectangle26_6{}, 0, false
+}
+
+func (f *Face) GlyphAdvance(r rune) (advance fixed.Int26_6, ok bool) {
+	if found, rng := f.find(r); rng != nil {
+		return fixed.I(f.Advance), r == found
+	}
+	return 0, false
+}
+
+func (f *Face) find(r rune) (rune, *Range) {
+	for {
+		for i, rng := range f.Ranges {
+			if (rng.Low <= r) && (r < rng.High) {
+				return r, &f.Ranges[i]
+			}
+		}
+		if r == '\ufffd' {
+			return 0, nil
+		}
+		r = '\ufffd'
+	}
+}

v2/vendor/golang.org/x/image/font/font.go

@@ -0,0 +1,354 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package font defines an interface for font faces, for drawing text on an
+// image.
+//
+// Other packages provide font face implementations. For example, a truetype
+// package would provide one based on .ttf font files.
+package font // import "golang.org/x/image/font"
+
+import (
+	"image"
+	"image/draw"
+	"io"
+	"unicode/utf8"
+
+	"golang.org/x/image/math/fixed"
+)
+
+// TODO: who is responsible for caches (glyph images, glyph indices, kerns)?
+// The Drawer or the Face?
+
+// Face is a font face. Its glyphs are often derived from a font file, such as
+// "Comic_Sans_MS.ttf", but a face has a specific size, style, weight and
+// hinting. For example, the 12pt and 18pt versions of Comic Sans are two
+// different faces, even if derived from the same font file.
+//
+// A Face is not safe for concurrent use by multiple goroutines, as its methods
+// may re-use implementation-specific caches and mask image buffers.
+//
+// To create a Face, look to other packages that implement specific font file
+// formats.
+type Face interface {
+	io.Closer
+
+	// Glyph returns the draw.DrawMask parameters (dr, mask, maskp) to draw r's
+	// glyph at the sub-pixel destination location dot, and that glyph's
+	// advance width.
+	//
+	// It returns !ok if the face does not contain a glyph for r. This includes
+	// returning !ok for a fallback glyph (such as substituting a U+FFFD glyph
+	// or OpenType's .notdef glyph), in which case the other return values may
+	// still be non-zero.
+	//
+	// The contents of the mask image returned by one Glyph call may change
+	// after the next Glyph call. Callers that want to cache the mask must make
+	// a copy.
+	Glyph(dot fixed.Point26_6, r rune) (
+		dr image.Rectangle, mask image.Image, maskp image.Point, advance fixed.Int26_6, ok bool)
+
+	// GlyphBounds returns the bounding box of r's glyph, drawn at a dot equal
+	// to the origin, and that glyph's advance width.
+	//
+	// It returns !ok if the face does not contain a glyph for r. This includes
+	// returning !ok for a fallback glyph (such as substituting a U+FFFD glyph
+	// or OpenType's .notdef glyph), in which case the other return values may
+	// still be non-zero.
+	//
+	// The glyph's ascent and descent are equal to -bounds.Min.Y and
+	// +bounds.Max.Y. The glyph's left-side and right-side bearings are equal
+	// to bounds.Min.X and advance-bounds.Max.X. A visual depiction of what
+	// these metrics are is at
+	// https://developer.apple.com/library/archive/documentation/TextFonts/Conceptual/CocoaTextArchitecture/Art/glyphterms_2x.png
+	GlyphBounds(r rune) (bounds fixed.Rectangle26_6, advance fixed.Int26_6, ok bool)
+
+	// GlyphAdvance returns the advance width of r's glyph.
+	//
+	// It returns !ok if the face does not contain a glyph for r. This includes
+	// returning !ok for a fallback glyph (such as substituting a U+FFFD glyph
+	// or OpenType's .notdef glyph), in which case the other return values may
+	// still be non-zero.
+	GlyphAdvance(r rune) (advance fixed.Int26_6, ok bool)
+
+	// Kern returns the horizontal adjustment for the kerning pair (r0, r1). A
+	// positive kern means to move the glyphs further apart.
+	Kern(r0, r1 rune) fixed.Int26_6
+
+	// Metrics returns the metrics for this Face.
+	Metrics() Metrics
+
+	// TODO: ColoredGlyph for various emoji?
+	// TODO: Ligatures? Shaping?
+}
+
+// Metrics holds the metrics for a Face. A visual depiction is at
+// https://developer.apple.com/library/mac/documentation/TextFonts/Conceptual/CocoaTextArchitecture/Art/glyph_metrics_2x.png
+type Metrics struct {
+	// Height is the recommended amount of vertical space between two lines of
+	// text.
+	Height fixed.Int26_6
+
+	// Ascent is the distance from the top of a line to its baseline.
+	Ascent fixed.Int26_6
+
+	// Descent is the distance from the bottom of a line to its baseline. The
+	// value is typically positive, even though a descender goes below the
+	// baseline.
+	Descent fixed.Int26_6
+
+	// XHeight is the distance from the top of non-ascending lowercase letters
+	// to the baseline.
+	XHeight fixed.Int26_6
+
+	// CapHeight is the distance from the top of uppercase letters to the
+	// baseline.
+	CapHeight fixed.Int26_6
+
+	// CaretSlope is the slope of a caret as a vector with the Y axis pointing up.
+	// The slope {0, 1} is the vertical caret.
+	CaretSlope image.Point
+}
+
+// Drawer draws text on a destination image.
+//
+// A Drawer is not safe for concurrent use by multiple goroutines, since its
+// Face is not.
+type Drawer struct {
+	// Dst is the destination image.
+	Dst draw.Image
+	// Src is the source image.
+	Src image.Image
+	// Face provides the glyph mask images.
+	Face Face
+	// Dot is the baseline location to draw the next glyph. The majority of the
+	// affected pixels will be above and to the right of the dot, but some may
+	// be below or to the left. For example, drawing a 'j' in an italic face
+	// may affect pixels below and to the left of the dot.
+	Dot fixed.Point26_6
+
+	// TODO: Clip image.Image?
+	// TODO: SrcP image.Point for Src images other than *image.Uniform? How
+	// does it get updated during DrawString?
+}
+
+// TODO: should DrawString return the last rune drawn, so the next DrawString
+// call can kern beforehand? Or should that be the responsibility of the caller
+// if they really want to do that, since they have to explicitly shift d.Dot
+// anyway? What if ligatures span more than two runes? What if grapheme
+// clusters span multiple runes?
+//
+// TODO: do we assume that the input is in any particular Unicode Normalization
+// Form?
+//
+// TODO: have DrawRunes(s []rune)? DrawRuneReader(io.RuneReader)?? If we take
+// io.RuneReader, we can't assume that we can rewind the stream.
+//
+// TODO: how does this work with line breaking: drawing text up until a
+// vertical line? Should DrawString return the number of runes drawn?
+
+// DrawBytes draws s at the dot and advances the dot's location.
+//
+// It is equivalent to DrawString(string(s)) but may be more efficient.
+func (d *Drawer) DrawBytes(s []byte) {
+	prevC := rune(-1)
+	for len(s) > 0 {
+		c, size := utf8.DecodeRune(s)
+		s = s[size:]
+		if prevC >= 0 {
+			d.Dot.X += d.Face.Kern(prevC, c)
+		}
+		dr, mask, maskp, advance, _ := d.Face.Glyph(d.Dot, c)
+		if !dr.Empty() {
+			draw.DrawMask(d.Dst, dr, d.Src, image.Point{}, mask, maskp, draw.Over)
+		}
+		d.Dot.X += advance
+		prevC = c
+	}
+}
+
+// DrawString draws s at the dot and advances the dot's location.
+func (d *Drawer) DrawString(s string) {
+	prevC := rune(-1)
+	for _, c := range s {
+		if prevC >= 0 {
+			d.Dot.X += d.Face.Kern(prevC, c)
+		}
+		dr, mask, maskp, advance, _ := d.Face.Glyph(d.Dot, c)
+		if !dr.Empty() {
+			draw.DrawMask(d.Dst, dr, d.Src, image.Point{}, mask, maskp, draw.Over)
+		}
+		d.Dot.X += advance
+		prevC = c
+	}
+}
+
+// BoundBytes returns the bounding box of s, drawn at the drawer dot, as well as
+// the advance.
+//
+// It is equivalent to BoundBytes(string(s)) but may be more efficient.
+func (d *Drawer) BoundBytes(s []byte) (bounds fixed.Rectangle26_6, advance fixed.Int26_6) {
+	bounds, advance = BoundBytes(d.Face, s)
+	bounds.Min = bounds.Min.Add(d.Dot)
+	bounds.Max = bounds.Max.Add(d.Dot)
+	return
+}
+
+// BoundString returns the bounding box of s, drawn at the drawer dot, as well
+// as the advance.
+func (d *Drawer) BoundString(s string) (bounds fixed.Rectangle26_6, advance fixed.Int26_6) {
+	bounds, advance = BoundString(d.Face, s)
+	bounds.Min = bounds.Min.Add(d.Dot)
+	bounds.Max = bounds.Max.Add(d.Dot)
+	return
+}
+
+// MeasureBytes returns how far dot would advance by drawing s.
+//
+// It is equivalent to MeasureString(string(s)) but may be more efficient.
+func (d *Drawer) MeasureBytes(s []byte) (advance fixed.Int26_6) {
+	return MeasureBytes(d.Face, s)
+}
+
+// MeasureString returns how far dot would advance by drawing s.
+func (d *Drawer) MeasureString(s string) (advance fixed.Int26_6) {
+	return MeasureString(d.Face, s)
+}
+
+// BoundBytes returns the bounding box of s with f, drawn at a dot equal to the
+// origin, as well as the advance.
+//
+// It is equivalent to BoundString(string(s)) but may be more efficient.
+func BoundBytes(f Face, s []byte) (bounds fixed.Rectangle26_6, advance fixed.Int26_6) {
+	prevC := rune(-1)
+	for len(s) > 0 {
+		c, size := utf8.DecodeRune(s)
+		s = s[size:]
+		if prevC >= 0 {
+			advance += f.Kern(prevC, c)
+		}
+		b, a, _ := f.GlyphBounds(c)
+		if !b.Empty() {
+			b.Min.X += advance
+			b.Max.X += advance
+			bounds = bounds.Union(b)
+		}
+		advance += a
+		prevC = c
+	}
+	return
+}
+
+// BoundString returns the bounding box of s with f, drawn at a dot equal to the
+// origin, as well as the advance.
+func BoundString(f Face, s string) (bounds fixed.Rectangle26_6, advance fixed.Int26_6) {
+	prevC := rune(-1)
+	for _, c := range s {
+		if prevC >= 0 {
+			advance += f.Kern(prevC, c)
+		}
+		b, a, _ := f.GlyphBounds(c)
+		if !b.Empty() {
+			b.Min.X += advance
+			b.Max.X += advance
+			bounds = bounds.Union(b)
+		}
+		advance += a
+		prevC = c
+	}
+	return
+}
+
+// MeasureBytes returns how far dot would advance by drawing s with f.
+//
+// It is equivalent to MeasureString(string(s)) but may be more efficient.
+func MeasureBytes(f Face, s []byte) (advance fixed.Int26_6) {
+	prevC := rune(-1)
+	for len(s) > 0 {
+		c, size := utf8.DecodeRune(s)
+		s = s[size:]
+		if prevC >= 0 {
+			advance += f.Kern(prevC, c)
+		}
+		a, _ := f.GlyphAdvance(c)
+		advance += a
+		prevC = c
+	}
+	return advance
+}
+
+// MeasureString returns how far dot would advance by drawing s with f.
+func MeasureString(f Face, s string) (advance fixed.Int26_6) {
+	prevC := rune(-1)
+	for _, c := range s {
+		if prevC >= 0 {
+			advance += f.Kern(prevC, c)
+		}
+		a, _ := f.GlyphAdvance(c)
+		advance += a
+		prevC = c
+	}
+	return advance
+}
+
+// Hinting selects how to quantize a vector font's glyph nodes.
+//
+// Not all fonts support hinting.
+type Hinting int
+
+const (
+	HintingNone Hinting = iota
+	HintingVertical
+	HintingFull
+)
+
+// Stretch selects a normal, condensed, or expanded face.
+//
+// Not all fonts support stretches.
+type Stretch int
+
+const (
+	StretchUltraCondensed Stretch = -4
+	StretchExtraCondensed Stretch = -3
+	StretchCondensed      Stretch = -2
+	StretchSemiCondensed  Stretch = -1
+	StretchNormal         Stretch = +0
+	StretchSemiExpanded   Stretch = +1
+	StretchExpanded       Stretch = +2
+	StretchExtraExpanded  Stretch = +3
+	StretchUltraExpanded  Stretch = +4
+)
+
+// Style selects a normal, italic, or oblique face.
+//
+// Not all fonts support styles.
+type Style int
+
+const (
+	StyleNormal Style = iota
+	StyleItalic
+	StyleOblique
+)
+
+// Weight selects a normal, light or bold face.
+//
+// Not all fonts support weights.
+//
+// The named Weight constants (e.g. WeightBold) correspond to CSS' common
+// weight names (e.g. "Bold"), but the numerical values differ, so that in Go,
+// the zero value means to use a normal weight. For the CSS names and values,
+// see https://developer.mozilla.org/en/docs/Web/CSS/font-weight
+type Weight int
+
+const (
+	WeightThin       Weight = -3 // CSS font-weight value 100.
+	WeightExtraLight Weight = -2 // CSS font-weight value 200.
+	WeightLight      Weight = -1 // CSS font-weight value 300.
+	WeightNormal     Weight = +0 // CSS font-weight value 400.
+	WeightMedium     Weight = +1 // CSS font-weight value 500.
+	WeightSemiBold   Weight = +2 // CSS font-weight value 600.
+	WeightBold       Weight = +3 // CSS font-weight value 700.
+	WeightExtraBold  Weight = +4 // CSS font-weight value 800.
+	WeightBlack      Weight = +5 // CSS font-weight value 900.
+)