@godot-scene-web/canvas 0.1.0

package/dist/glyph-pass-DfQlp_IH.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glyph-pass-DfQlp_IH.d.ts","names":[],"sources":["../src/damage.ts","../src/draw-list.ts","../src/present.ts","../src/glyph-pass.ts"],"mappings":"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"}

package/dist/glyph-pass-hbgpu.d.ts

@@ -0,0 +1,227 @@
+import { F as GlyphsView, t as GlyphPass } from "./glyph-pass-DfQlp_IH.js";
+import { HbGpuContrast, HbGpuFace, HbGpuRenderer } from "@godot-scene-web/hb-gpu/webgl";
+import { HbGpu, HbGpuFailure, HbGpuFont, HbGpuShapeOptions } from "@godot-scene-web/hb-gpu";
+
+//#region src/glyph-pass-hbgpu.d.ts
+/**
+ * Below this ppem the outline path is measurably blurrier than the alternatives.
+ *
+ * `ppem` here is `GlyphsView.pixelsPerEm` times the scale in `GlyphsView.m` times the device-pixel
+ * ratio — the size in DEVICE pixels, which is the only size the shader can see, and it sees all
+ * three factors (it derives ppem from `fwidth`). The number is HarfBuzz's own branch point, not a
+ * threshold chosen here: `hb_gpu_draw` switches to a five-tap MSAA approximation under it.
+ */
+declare const PPEM_FIDELITY_FLOOR = 16;
+/**
+ * The id `slotFor` returns for a glyph with no ink, or one the atlas declined.
+ *
+ * Write it into `GlyphsView.slots` and the pass skips the glyph. It is a distinct value ON PURPOSE:
+ * a caller that wrote a real-looking id for a space would get a degenerate quad reading texel 0,
+ * which is some other glyph's header.
+ */
+declare const GLYPH_SLOT_NONE = -1;
+/**
+ * A face registered with the pass: the handle `slotFor` takes.
+ *
+ * It pairs the ENCODER (`HbGpuFont`, which turns a glyph id into an outline blob) with the atlas
+ * FACE handle that namespaces that glyph id, because the two must not drift: glyph 42 of Noto Sans
+ * SC and glyph 42 of Roboto are unrelated outlines, and an atlas that cannot tell them apart
+ * renders fluent, crisp, wrong text.
+ */
+interface GlyphFace {
+  readonly font: HbGpuFont;
+  readonly face: HbGpuFace;
+  /** Units per em. The scale `GlyphsView.pixelsPerEm` is measured against. */
+  readonly upem: number;
+  readonly label: string;
+}
+interface HbGpuGlyphPassStats {
+  /** Distinct `(face, glyph)` pairs that have ever been given an id. */
+  slots: number;
+  /** Runs drawn. */
+  runs: number;
+  /** Glyphs the renderer reported drawing, summed over runs. */
+  glyphs: number;
+  /** Glyphs skipped because their slot id was {@link GLYPH_SLOT_NONE} — spaces, mostly. */
+  inkless: number;
+  /**
+   * Glyphs whose slot id resolved to nothing and had to be encoded and uploaded again.
+   *
+   * THE COUNTER THAT SAYS THE ATLAS IS TOO SMALL. Non-zero once, on a cold list, is the mechanism
+   * working. Non-zero every frame means the working set does not fit and every frame is paying an
+   * encode — raise `atlasTexels`.
+   */
+  reuploads: number;
+  /**
+   * Glyphs the pass could not draw at all: an id it never issued, an encode that failed, or a
+   * re-upload the atlas refused. A hole in a word, so it is counted rather than left to a
+   * screenshot.
+   */
+  dropped: number;
+  /** Runs whose device ppem was under {@link PPEM_FIDELITY_FLOOR}. See this file's header. */
+  runsBelowPpemFloor: number;
+  /** Additive shaping-cache counters. */
+  shapeHits: number;
+  shapeMisses: number;
+  shapeEntries: number;
+  shapeGlyphs: number;
+  shapeEvicted: number;
+}
+interface HbGpuGlyphPassOptions {
+  /**
+   * The context to draw in — the SAME one the executor was given.
+   *
+   * It must be `premultipliedAlpha: true`, which is what `createCanvasStage` asks for; hb-gpu's
+   * fragment writes premultiplied coverage and a straight-alpha canvas composites it twice,
+   * silently, as a merely darker picture.
+   */
+  gl: WebGL2RenderingContext;
+  /** An instantiated hb-gpu module. The pass reads HarfBuzz's own GLSL and its encoders out of it. */
+  module: HbGpu;
+  /**
+   * The scene's coordinate extent — `CanvasStage.designWidth`, the space a `GlyphsView` lives in.
+   *
+   * Only a starting value: `drawRun` takes both sizes from the frame's `StageProjection`, which is
+   * the one authority on where design space lands.
+   */
+  designWidth: number;
+  designHeight: number;
+  /** The achieved drawing buffer. Defaults to the design pair, i.e. a device-pixel ratio of 1. */
+  framebufferWidth?: number;
+  framebufferHeight?: number;
+  /** Atlas capacity in texels; see `HbGpuRendererOptions.atlasTexels`. */
+  atlasTexels?: number;
+  /**
+   * The contrast curve hb-gpu applies to the coverage it computed. Omit for the renderer's own
+   * default, `HB_GPU_CONTRAST_DEFAULT` — stem darkening ON.
+   *
+   * OMITTING IT IS EXACTLY THE PICTURE THIS PASS DREW BEFORE THE OPTION EXISTED. It is not
+   * defaulted here: `undefined` is forwarded as `undefined` and `createHbGpuRenderer` decides, so
+   * every existing consumer and every committed pixel golden is byte-identical to before.
+   *
+   * WHY A GODOT-PARITY CONSUMER PASSES `HB_GPU_CONTRAST_NONE`, AND IT IS MEASURED RATHER THAN
+   * PREFERRED. Stem darkening is not a tie-breaker inside this path's quality — it IS the quality
+   * crossover against the other text arms. Distortion against an 8x area-coverage reference, swept
+   * over ppem 16-52 by `packages/perf-harness/probes/text-crossover.ts`
+   * (`pnpm -w run text:crossover -- --hb-contrast default|none`):
+   *
+   *     ppem 16    default 0.1091    none 0.0258     canvas2d 0.0925
+   *     ppem 24    default 0.0537    none 0.0138
+   *
+   * So the shipped curve LOSES to a plain `ctx.fillText` at 16 and costs this path ~4x its own
+   * achievable distortion at 24, while with the curve off hb-gpu wins at every ppem swept, with
+   * the tightest edges of any arm. AND GODOT APPLIES NO CURVE OF ITS OWN — its grayscale and MSDF
+   * glyph interiors come out byte-uniform — so a consumer whose acceptance test is "does this look
+   * like the engine we are mirroring" is holding its text up against a rasterizer that never
+   * darkened a stem, and the correction reads as a weight mismatch rather than as contrast.
+   *
+   * THE DEFAULT STAYS ON, because the case it was measured for is real and is a different case:
+   * against the DOM text path, uncorrected coverage is washed out (`HbGpuContrast`'s own doc — DOM
+   * puts 66% more pixels in the deep-dark end of one fixed crop). Text that is not standing next
+   * to Godot's own output still wants it.
+   *
+   * IT MOVES EDGES, NOT INK, WHICHEVER WAY YOU SET IT. `hb_gpu_stem_darken` is gated on partial
+   * coverage (`cov > 0 && cov < 1`), so a glyph INTERIOR is byte-identical either way and only the
+   * ramp at the boundary narrows or widens. The library also ramps the correction off by ppem 48,
+   * so display-sized text barely moves and small UI text moves most.
+   *
+   * IT REACHES THE FILL PASS ONLY, and that is the renderer's rule rather than this pass's: a run
+   * drawn with a non-zero `GlyphsView.spreadPx` emits raw coverage whatever this says. An outlined
+   * label is therefore already half-uncorrected today — see `HbGpuContrast.stemDarkening`.
+   */
+  contrast?: HbGpuContrast;
+  /** Opt-in expanded hb-gpu records used only by adjacent-run batching. */
+  batchAdjacentRuns?: boolean;
+  /** Every refusal, from this file and from the renderer under it. */
+  onError?(failure: HbGpuFailure): void;
+  /**
+   * Warn on the console the first time a run is drawn below {@link PPEM_FIDELITY_FLOOR}. Default
+   * on.
+   *
+   * ONCE, not per run: a page of small text would otherwise emit a line per label per frame, and a
+   * warning nobody can read is a warning nobody reads. {@link HbGpuGlyphPassStats.runsBelowPpemFloor}
+   * keeps the full tally. It is a `console.warn` rather than an `onError` because it is not a
+   * refusal — the text IS drawn, and only a measurement says another path would draw it better.
+   */
+  warnBelowPpemFloor?: boolean;
+  /** Maximum cached shaped runs. Zero disables memoisation. Defaults to 512. */
+  shapeCacheEntries?: number;
+  /** Maximum glyphs retained by shaped-run memoisation. Defaults to entries × 64. */
+  shapeCacheGlyphs?: number;
+}
+interface HbGpuGlyphPass extends GlyphPass {
+  /** The renderer underneath. Exposed for its `atlas` / `blobs` stats. */
+  readonly renderer: HbGpuRenderer;
+  readonly stats: HbGpuGlyphPassStats;
+  /**
+   * Register a face from its bytes, or `null` if hb-gpu will not take them.
+   *
+   * THE SAME BYTES THE SHAPER WAS GIVEN. Glyph ids come out of one HarfBuzz and outlines out of
+   * another; two different files make gid 97 two different outlines, and the result is crisp,
+   * fluent, wrong text that no counter downstream can see.
+   */
+  registerFace(bytes: Uint8Array, label?: string): GlyphFace | null;
+  /**
+   * The stable slot id for one glyph of one face — what a caller writes into `GlyphsView.slots`.
+   *
+   * Uploads the outline on first use and is a map lookup after that. The id is dense, permanent
+   * and survives eviction: it names an entry in THIS pass's table, not a place in the atlas.
+   *
+   * {@link GLYPH_SLOT_NONE} for a glyph with no ink and for one the atlas refused.
+   */
+  slotFor(face: GlyphFace, glyphId: number): number;
+  /** Glyph id for a code point in `face`, or 0 (`.notdef`). A convenience over `HbGpuFont`. */
+  glyphFor(face: GlyphFace, codepoint: number): number;
+  /**
+   * Shape `text` and fill `run` with the result: slots, pen positions and count. `false` if the
+   * shaper refused, leaving `run` untouched.
+   *
+   * ONE HARFBUZZ, WHICH IS THE WHOLE POINT OF HAVING THIS AT ALL. hb-gpu's wasm exports the
+   * OpenType shaper as well as the Slug encoder, so a consumer that calls this loads one HarfBuzz
+   * and holds each face once. Shaping elsewhere — npm `harfbuzzjs`, most likely — means a second
+   * build, a second heap and the same font bytes resident twice, which measured 4.19 MiB across
+   * the pair on a phone (`docs/text-rendering.md`). It is also the configuration in which glyph
+   * ids and outlines can come from two DIFFERENT files, and gid 97 meaning two different things is
+   * crisp, fluent, wrong text that no counter downstream can see.
+   *
+   * THE PEN ARITHMETIC LIVES HERE FOR THE SAME REASON IT IS EASY TO GET WRONG. HarfBuzz reports
+   * advances and offsets in FONT units, y-UP; `GlyphsView.positions` are design units, y-DOWN,
+   * measured from the run's origin. So each is scaled by `run.pixelsPerEm / face.upem` and y is
+   * negated, an offset positions its own glyph only, and the advance accumulates after it. Getting
+   * the scale or the y sign wrong produces text that looks entirely plausible and is subtly
+   * mis-spaced — which is why there is one implementation rather than one per caller.
+   *
+   * `run.pixelsPerEm` must be set BEFORE the call. Exactly three fields are written — `slots`,
+   * `positions` and `glyphCount` — and `run.slots` / `run.positions` are replaced by larger buffers
+   * if the run does not fit. Inkless glyphs (a space) are skipped rather than given a slot, so
+   * `run.glyphCount` can be smaller than the shaped length.
+   *
+   * `m`, the colour and `spreadPx` are LEFT ALONE, which is what makes an outlined label one shape
+   * and two pushes: shape once, then `pushGlyphs` with the outline colour and a spread, then again
+   * with the fill colour and `spreadPx = 0`. Both runs then carry pen positions that came from a
+   * single shaping pass and cannot drift apart.
+   */
+  fillRun(run: GlyphsView, face: GlyphFace, text: string, options?: HbGpuShapeOptions): boolean;
+  /** Drop shaped-run memoisation without disturbing faces or atlas residency. */
+  clearShapeCache(): void;
+  /** Re-state both sizes after the stage resized. See `HbGpuRenderer.setViewport`. */
+  setViewport(designWidth: number, designHeight: number, framebufferWidth?: number, framebufferHeight?: number): void;
+  /** Forward of `HbGpuRenderer.notifyContextLost` — wire it to the stage's `onContextLost`. */
+  notifyContextLost(): void;
+  /** Forward of `HbGpuRenderer.rebuild` — wire it to the stage's `onContextRestored`. */
+  rebuild(): boolean;
+  /** Delete the renderer's GL objects. Does NOT touch the context or the registered fonts. */
+  dispose(): void;
+}
+/**
+ * Build a glyph pass over a borrowed context, or `null` when the renderer will not build.
+ *
+ * `null` rather than a throw, following `createCanvasStage` and `createHbGpuRenderer`: a consumer
+ * that cannot have the GPU glyph path falls back to its DOM one, and only it knows whether that is
+ * acceptable. Pass `onError` to be told why — a pass that declined silently reports as a page with
+ * no words on it.
+ */
+declare function createHbGpuGlyphPass(options: HbGpuGlyphPassOptions): HbGpuGlyphPass | null;
+//#endregion
+export { GLYPH_SLOT_NONE, GlyphFace, HbGpuGlyphPass, HbGpuGlyphPassOptions, HbGpuGlyphPassStats, PPEM_FIDELITY_FLOOR, createHbGpuGlyphPass };
+//# sourceMappingURL=glyph-pass-hbgpu.d.ts.map

package/dist/glyph-pass-hbgpu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glyph-pass-hbgpu.d.ts","names":[],"sources":["../src/glyph-pass-hbgpu.ts"],"mappings":";;;;;;AAiFA;;;;AAAgC;AAShC;;cATa,mBAAA;;AASe;AAU5B;;;;;cAVa,eAAA;;;;;;AAeG;AAGhB;;UARiB,SAAA;EAAA,SACN,IAAA,EAAM,SAAA;EAAA,SACN,IAAA,EAAM,SAAS;EAUxB;EAAA,SARS,IAAA;EAAA,SACA,KAAA;AAAA;AAAA,UAGM,mBAAA;EAwBf;EAtBA,KAAA;EAyBA;EAvBA,IAAA;EAyBA;EAvBA,MAAA;EAwBY;EAtBZ,OAAA;EAyBe;;;;;;;EAjBf,SAAA;EAmF8B;;;;;EA7E9B,OAAA;EA6BA;EA3BA,kBAAA;EA8BA;EA5BA,SAAA;EACA,WAAA;EACA,YAAA;EACA,WAAA;EACA,YAAA;AAAA;AAAA,UAGe,qBAAA;EA4Ef;;;;AAIgB;AAGlB;;EA3EE,EAAA,EAAI,sBAAA;EA6Ee;EA3EnB,MAAA,EAAQ,KAAA;EAoFY;;;;;;EA7EpB,WAAA;EACA,YAAA;EAiE+C;EA/D/C,gBAAA;EACA,iBAAA;EAgES;EA9DT,WAAA;EA+DS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqEF;AAiBT;;;;EA9GE,QAAA,GAAW,aAAA;EA+GX;EA7GA,iBAAA;EA8Ge;EA5Gf,OAAA,EAAS,OAAA,EAAS,YAAA;;;;;;;;;;EAUlB,kBAAA;;EAEA,iBAAA;;EAEA,gBAAA;AAAA;AAAA,UAGe,cAAA,SAAuB,SAAA;;WAE7B,QAAA,EAAU,aAAA;EAAA,SACV,KAAA,EAAO,mBAAA;;;;;;;;EAQhB,YAAA,CAAa,KAAA,EAAO,UAAA,EAAY,KAAA,YAAiB,SAAA;;;;;;;;;EASjD,OAAA,CAAQ,IAAA,EAAM,SAAA,EAAW,OAAA;;EAEzB,QAAA,CAAS,IAAA,EAAM,SAAA,EAAW,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8B1B,OAAA,CACE,GAAA,EAAK,UAAA,EACL,IAAA,EAAM,SAAA,EACN,IAAA,UACA,OAAA,GAAU,iBAAA;;EAGZ,eAAA;;EAEA,WAAA,CACE,WAAA,UACA,YAAA,UACA,gBAAA,WACA,iBAAA;;EAGF,iBAAA;;EAEA,OAAA;;EAEA,OAAA;AAAA;;;;;;;;;iBAiBc,oBAAA,CACd,OAAA,EAAS,qBAAA,GACR,cAAc"}

package/dist/glyph-pass-hbgpu.js

@@ -0,0 +1,387 @@
+import { createHbGpuRenderer } from "@godot-scene-web/hb-gpu/webgl";
+//#region src/glyph-shape-cache.ts
+/**
+* Small bounded cache for HarfBuzz's scale-free font-unit output. Unknown options deliberately
+* bypass it: forwarding a future shaping option must not accidentally reuse an older result.
+*/
+var GlyphShapeCache = class {
+	maxEntries;
+	maxGlyphs;
+	stats;
+	byFace = /* @__PURE__ */ new Map();
+	tick = 0;
+	constructor(maxEntries, maxGlyphs, stats) {
+		this.maxEntries = maxEntries;
+		this.maxGlyphs = maxGlyphs;
+		this.stats = stats;
+	}
+	key(text, options) {
+		if (!options || Object.keys(options).length === 0) return text;
+		const allowed = new Set([
+			"direction",
+			"script",
+			"language",
+			"features"
+		]);
+		if (Object.keys(options).some((name) => !allowed.has(name))) return null;
+		return JSON.stringify([
+			options.direction,
+			options.script,
+			options.language,
+			options.features,
+			text
+		]);
+	}
+	get(faceId, key) {
+		if (this.maxEntries === 0 || this.maxGlyphs === 0) return null;
+		const entry = this.byFace.get(faceId)?.get(key);
+		if (!entry) return null;
+		entry.usedAt = ++this.tick;
+		this.stats.shapeHits += 1;
+		return entry;
+	}
+	put(faceId, key, shape) {
+		if (this.maxEntries === 0 || this.maxGlyphs === 0 || shape.count > this.maxGlyphs) return;
+		while (this.stats.shapeEntries >= this.maxEntries || this.stats.shapeGlyphs + shape.count > this.maxGlyphs) {
+			let oldestFace;
+			let oldestKey;
+			let oldest = Infinity;
+			for (const entries of this.byFace.values()) for (const [candidateKey, candidate] of entries) if (candidate.usedAt < oldest) {
+				oldest = candidate.usedAt;
+				oldestFace = entries;
+				oldestKey = candidateKey;
+			}
+			if (!oldestFace || oldestKey === void 0) break;
+			const removed = oldestFace.get(oldestKey);
+			oldestFace.delete(oldestKey);
+			this.stats.shapeEntries -= 1;
+			this.stats.shapeGlyphs -= removed.count;
+			this.stats.shapeEvicted += 1;
+		}
+		let entries = this.byFace.get(faceId);
+		if (!entries) {
+			entries = /* @__PURE__ */ new Map();
+			this.byFace.set(faceId, entries);
+		}
+		entries.set(key, {
+			...shape,
+			usedAt: ++this.tick
+		});
+		this.stats.shapeEntries += 1;
+		this.stats.shapeGlyphs += shape.count;
+	}
+	miss() {
+		this.stats.shapeMisses += 1;
+	}
+	clear() {
+		this.byFace.clear();
+		this.stats.shapeEntries = 0;
+		this.stats.shapeGlyphs = 0;
+	}
+};
+//#endregion
+//#region src/glyph-pass-hbgpu.ts
+/**
+* Below this ppem the outline path is measurably blurrier than the alternatives.
+*
+* `ppem` here is `GlyphsView.pixelsPerEm` times the scale in `GlyphsView.m` times the device-pixel
+* ratio — the size in DEVICE pixels, which is the only size the shader can see, and it sees all
+* three factors (it derives ppem from `fwidth`). The number is HarfBuzz's own branch point, not a
+* threshold chosen here: `hb_gpu_draw` switches to a five-tap MSAA approximation under it.
+*/
+const PPEM_FIDELITY_FLOOR = 16;
+/**
+* The id `slotFor` returns for a glyph with no ink, or one the atlas declined.
+*
+* Write it into `GlyphsView.slots` and the pass skips the glyph. It is a distinct value ON PURPOSE:
+* a caller that wrote a real-looking id for a space would get a degenerate quad reading texel 0,
+* which is some other glyph's header.
+*/
+const GLYPH_SLOT_NONE = -1;
+/**
+* Build a glyph pass over a borrowed context, or `null` when the renderer will not build.
+*
+* `null` rather than a throw, following `createCanvasStage` and `createHbGpuRenderer`: a consumer
+* that cannot have the GPU glyph path falls back to its DOM one, and only it knows whether that is
+* acceptable. Pass `onError` to be told why — a pass that declined silently reports as a page with
+* no words on it.
+*/
+function createHbGpuGlyphPass(options) {
+	const report = (failure) => options.onError?.(failure);
+	const rendererOptions = {
+		gl: options.gl,
+		designWidth: options.designWidth,
+		designHeight: options.designHeight,
+		framebufferWidth: options.framebufferWidth,
+		framebufferHeight: options.framebufferHeight,
+		atlasTexels: options.atlasTexels,
+		contrast: options.contrast,
+		perInstanceRunState: options.batchAdjacentRuns === true,
+		onError: report
+	};
+	const renderer = createHbGpuRenderer(options.module, rendererOptions);
+	if (!renderer) return null;
+	const live = renderer;
+	const batchAdjacentRuns = options.batchAdjacentRuns === true;
+	const entries = [];
+	const idByFace = [];
+	const faces = [];
+	const stats = {
+		slots: 0,
+		runs: 0,
+		glyphs: 0,
+		inkless: 0,
+		reuploads: 0,
+		dropped: 0,
+		runsBelowPpemFloor: 0,
+		shapeHits: 0,
+		shapeMisses: 0,
+		shapeEntries: 0,
+		shapeGlyphs: 0,
+		shapeEvicted: 0
+	};
+	const shapeCacheEntries = Math.max(0, options.shapeCacheEntries ?? 512);
+	const shapeCache = new GlyphShapeCache(shapeCacheEntries, Math.max(0, options.shapeCacheGlyphs ?? shapeCacheEntries * 64), stats);
+	let warnedBelowPpemFloor = false;
+	let adjacentBatchOpen = false;
+	let designWidth = Math.max(1, options.designWidth);
+	let designHeight = Math.max(1, options.designHeight);
+	let framebufferWidth = Math.max(1, options.framebufferWidth ?? options.designWidth);
+	let framebufferHeight = Math.max(1, options.framebufferHeight ?? options.designHeight);
+	/**
+	* The slot table, as a plain function rather than only a method.
+	*
+	* `fillRun` needs it too, and reaching it through `this` would break the moment a caller
+	* destructured the pass — a shape the rest of this package supports everywhere else. `live` and
+	* not `renderer` because TypeScript will not carry the null narrowing above into a function
+	* declaration, which could in principle be called before it.
+	*/
+	function slotIdFor(face, glyphId) {
+		let byGlyph = idByFace[face.face.id];
+		if (!byGlyph) {
+			byGlyph = /* @__PURE__ */ new Map();
+			idByFace[face.face.id] = byGlyph;
+		}
+		const cached = byGlyph.get(glyphId);
+		if (cached !== void 0) return cached;
+		const entry = {
+			face,
+			glyphId
+		};
+		const glyph = encode(entry);
+		if (!glyph) return -1;
+		if (glyph.texels.length === 0) return -1;
+		if (!live.upload(face.face, glyphId, glyph)) return -1;
+		const id = entries.length;
+		entries.push(entry);
+		byGlyph.set(glyphId, id);
+		stats.slots = entries.length;
+		return id;
+	}
+	/** Encode one glyph, or say why not. A zero-length blob means "no ink", not "failed". */
+	function encode(entry) {
+		const glyph = entry.face.font.encode(entry.glyphId);
+		if (!glyph) {
+			report({
+				reason: "encoder-unavailable",
+				message: `hb-gpu: hb_gpu_draw_encode refused glyph ${entry.glyphId} of face "${entry.face.label}" — the run will be drawn with a hole in it`
+			});
+			return null;
+		}
+		return glyph;
+	}
+	const pass = {
+		renderer,
+		stats,
+		registerFace(bytes, label) {
+			const name = label ?? `face${faces.length}`;
+			const font = options.module.createFont(bytes);
+			if (!font) return null;
+			const face = renderer.registerFace(font, name);
+			if (!face) {
+				font.destroy();
+				return null;
+			}
+			const registered = {
+				font,
+				face,
+				upem: face.upem,
+				label: name
+			};
+			faces.push(registered);
+			idByFace[face.id] = /* @__PURE__ */ new Map();
+			return registered;
+		},
+		glyphFor(face, codepoint) {
+			return face.font.glyphFor(codepoint);
+		},
+		fillRun(run, face, text, shapeOptions) {
+			const key = shapeCache.key(text, shapeOptions);
+			let cached = key === null ? null : shapeCache.get(face.face.id, key);
+			if (!cached) {
+				shapeCache.miss();
+				const shaped = face.font.shape(text, shapeOptions);
+				if (!shaped) return false;
+				const slots = new Int32Array(shaped.length);
+				const pen = new Int32Array(shaped.length * 2);
+				let penX = 0;
+				let penY = 0;
+				let count = 0;
+				for (const glyph of shaped) {
+					const slot = slotIdFor(face, glyph.glyphId);
+					if (slot !== -1) {
+						slots[count] = slot;
+						pen[count * 2] = penX + glyph.xOffset;
+						pen[count * 2 + 1] = penY + glyph.yOffset;
+						count += 1;
+					}
+					penX += glyph.xAdvance;
+					penY += glyph.yAdvance;
+				}
+				cached = {
+					count,
+					slots: slots.slice(0, count),
+					pen: pen.slice(0, count * 2),
+					advanceX: penX,
+					advanceY: penY
+				};
+				if (key !== null) shapeCache.put(face.face.id, key, cached);
+			}
+			if (run.slots.length < cached.count) run.slots = new Int32Array(cached.count);
+			if (run.positions.length < cached.count * 2) run.positions = new Float32Array(cached.count * 2);
+			const scale = run.pixelsPerEm / face.upem;
+			for (let i = 0; i < cached.count; i += 1) {
+				run.slots[i] = cached.slots[i];
+				run.positions[i * 2] = cached.pen[i * 2] * scale;
+				run.positions[i * 2 + 1] = -cached.pen[i * 2 + 1] * scale;
+			}
+			run.glyphCount = cached.count;
+			return true;
+		},
+		slotFor: slotIdFor,
+		clearShapeCache() {
+			shapeCache.clear();
+		},
+		drawRun(run, projection) {
+			const runDesignWidth = projection.designWidth;
+			const runDesignHeight = projection.designHeight;
+			if (runDesignWidth !== designWidth || runDesignHeight !== designHeight || projection.framebufferWidth !== framebufferWidth || projection.framebufferHeight !== framebufferHeight) {
+				designWidth = runDesignWidth;
+				designHeight = runDesignHeight;
+				framebufferWidth = projection.framebufferWidth;
+				framebufferHeight = projection.framebufferHeight;
+				renderer.setViewport(designWidth, designHeight, framebufferWidth, framebufferHeight);
+			}
+			const axis = (Math.hypot(run.m[0], run.m[1]) + Math.hypot(run.m[2], run.m[3])) / 2;
+			const ppem = run.pixelsPerEm * axis * (framebufferWidth / designWidth);
+			if (ppem < 16) {
+				stats.runsBelowPpemFloor += 1;
+				if (options.warnBelowPpemFloor !== false && !warnedBelowPpemFloor) {
+					warnedBelowPpemFloor = true;
+					console.warn(`[gsw canvas] glyph run drawn at ${ppem.toFixed(1)} device ppem (pixelsPerEm ${run.pixelsPerEm} x model scale ${axis.toFixed(3)} x ${(framebufferWidth / designWidth).toFixed(3)} device ratio), under the 16 this path wants: HarfBuzz's coverage shader falls back to a five-tap approximation below it, measured blurrier than the DOM text path (0.196 vs 0.132 distortion on Han at ppem 14). A baked atlas or DOM text is crisper at this size. Reported once; see stats.runsBelowPpemFloor for the tally.`);
+				}
+			}
+			if (!adjacentBatchOpen) renderer.begin();
+			renderer.setModel(run.m);
+			renderer.setSpread(run.spreadPx);
+			const inverse = run.a > 0 ? 1 / run.a : 0;
+			renderer.setColor(run.r * inverse, run.g * inverse, run.b * inverse, run.a);
+			const count = run.glyphCount;
+			for (let i = 0; i < count; i += 1) {
+				const id = run.slots[i];
+				if (id === -1) {
+					stats.inkless += 1;
+					continue;
+				}
+				const entry = entries[id];
+				if (!entry) {
+					stats.dropped += 1;
+					continue;
+				}
+				let slot = renderer.resolve(entry.face.face, entry.glyphId);
+				if (!slot) {
+					const glyph = encode(entry);
+					if (!glyph || glyph.texels.length === 0) {
+						stats.dropped += 1;
+						continue;
+					}
+					slot = renderer.upload(entry.face.face, entry.glyphId, glyph);
+					stats.reuploads += 1;
+					if (!slot) {
+						stats.dropped += 1;
+						continue;
+					}
+				}
+				renderer.push(slot, run.positions[i * 2], run.positions[i * 2 + 1], run.pixelsPerEm);
+			}
+			const frame = adjacentBatchOpen ? {
+				instances: 0,
+				drawCalls: 0
+			} : renderer.end();
+			stats.runs += 1;
+			stats.glyphs += frame.instances;
+			return {
+				glyphs: frame.instances,
+				drawCalls: frame.drawCalls
+			};
+		},
+		drawRuns(runs, projection) {
+			if (runs.length === 0) return {
+				glyphs: 0,
+				drawCalls: 0
+			};
+			renderer.begin();
+			adjacentBatchOpen = true;
+			let completed = false;
+			try {
+				for (const run of runs) pass.drawRun(run, projection);
+				completed = true;
+			} finally {
+				adjacentBatchOpen = false;
+				if (!completed) renderer.begin();
+			}
+			const frame = renderer.end();
+			stats.glyphs += frame.instances;
+			return {
+				glyphs: frame.instances,
+				drawCalls: frame.drawCalls
+			};
+		},
+		canBatchRuns(runs) {
+			if (!batchAdjacentRuns) return false;
+			for (const run of runs) for (let i = 0; i < run.glyphCount; i += 1) {
+				const id = run.slots[i];
+				if (id === -1) continue;
+				const entry = entries[id];
+				if (!entry || !renderer.resolve(entry.face.face, entry.glyphId)) return false;
+			}
+			return true;
+		},
+		setViewport(width, height, bufferWidth, bufferHeight) {
+			designWidth = Math.max(1, width);
+			designHeight = Math.max(1, height);
+			framebufferWidth = Math.max(1, bufferWidth ?? width);
+			framebufferHeight = Math.max(1, bufferHeight ?? height);
+			renderer.setViewport(designWidth, designHeight, framebufferWidth, framebufferHeight);
+		},
+		notifyContextLost() {
+			renderer.notifyContextLost();
+		},
+		rebuild() {
+			return renderer.rebuild();
+		},
+		dispose() {
+			shapeCache.clear();
+			renderer.dispose();
+		}
+	};
+	if (!batchAdjacentRuns) {
+		delete pass.drawRuns;
+		delete pass.canBatchRuns;
+	}
+	return pass;
+}
+//#endregion
+export { GLYPH_SLOT_NONE, PPEM_FIDELITY_FLOOR, createHbGpuGlyphPass };
+
+//# sourceMappingURL=glyph-pass-hbgpu.js.map