@driftengine/ui2d 3.61.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Drift Technologies
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,9 @@
+DriftEngine
+Copyright 2026 Drift Technologies
+
+This product includes software developed at Drift Technologies
+(https://github.com/drftrun/driftengine).
+
+Licensed under the Apache License, Version 2.0. Section 4(d) of that licence
+requires this NOTICE to be reproduced in any derivative work you distribute,
+in the source, the documentation, or a display generated by the work.

package/README.md

@@ -0,0 +1,228 @@
+# @driftengine/ui2d
+
+The 2D layer: quads with a texture on them, batched, in the order you drew them.
+
+**Cost: 8.4 KB gzipped on top of core.** Measured by `scripts/size-gate.test.mjs`, which fails if it
+drifts more than 3% — the number is derived from the same floors that gate asserts, so a README
+quoting a stale one is a red suite rather than a thing somebody notices.
+
+## What it is
+
+```ts
+import { createAffine2D, createSpritePass, drawSprite, screenToNdc } from '@driftengine/ui2d';
+
+const sprites = createSpritePass({ capacity: 4096 });
+sprites.setTexture(0, await createImageBitmap(sheetImage));
+const handle = renderer.registerPass(sprites);
+
+const affine = createAffine2D();
+
+function frame(): void {
+  sprites.reset();
+  sprites.setTransform(screenToNdc(canvas.clientWidth, canvas.clientHeight, affine));
+  drawSprite(sprites.batch, 0, { x: 24, y: 24, w: 64, h: 64 }, null, null);
+
+  renderer.beginFrame(clear);
+  renderer.bindMeshPass(camera, env);
+  renderer.drawMesh(ground, model);
+  renderer.drawPass(handle); // wherever in the frame you want the 2D layer
+  renderer.endFrame();
+}
+```
+
+**It draws through `registerPass`, not through a verb on the renderer.** That is what lets it be a
+package at all: the renderer's verb surface is fixed and nothing outside `render/` can add to it, so
+this owns its own program on both backends and the caller decides where in the frame it lands.
+`pass.ts` in core names this package as one of the three that mechanism exists for.
+
+## Two coordinate systems, and they count y opposite ways
+
+`screenToNdc(width, height, out)` is **CSS pixels from the top-left** — the convention `InsetRect`
+and `fillPanel` already use, and the one a caller laying out an overlay already has.
+
+`worldToNdc(camera, width, height, out)` is a **2D world seen through a camera**, and there y counts
+**up**. A caller placing a platform above a floor should not have to subtract, and a 2D world is a
+world. The two are different enough that sharing one convention would make every caller wrong half
+the time, so they are named separately and each says which it is.
+
+A `Camera2D` is where it is, how far in (`zoom`, in pixels per world unit) and which way up
+(`rotation`, radians, anticlockwise). Turning the camera turns the world the other way.
+
+## Order is the layering
+
+There is no depth here, on purpose: a sprite writes no depth and tests none, so **the order sprites
+were submitted in is the order they are drawn**. That is the same decision the rest of the engine
+takes about pass ordering — `ROADMAP.md` records gate 1.2 withdrawing dependency ordering because
+the API is immediate-mode and the caller's draw order is already the semantic one.
+
+## One batch, many textures, runs between them
+
+`drawSprite` names a texture slot. Consecutive sprites on the same slot are one **run** and one
+draw; a slot change starts a new run, and going back to the first slot starts a third rather than
+regrouping — regrouping would reorder the picture.
+
+This is the shape `AGENTS.md` asks for: _the number to hold down is material changes, not draws_. A
+tilemap over one sheet is one run however many thousand tiles it is.
+
+A batch has a fixed capacity and does not grow. Past it, `drawSprite` counts into `batch.dropped`
+rather than allocating under a frame — a caller drawing more than it planned for wants counting,
+not absorbing.
+
+## Sheets
+
+A sheet is the rectangles of one texture that each hold a picture. `gridSheet` cuts it into equal
+cells, row-major; `namedSheet` takes whatever rectangles a packer put where. Both answer a frame by
+index, and `frameOf` turns a name into one.
+
+```ts
+const sheet = gridSheet(0, 256, 128, 32, 32); // slot 0, 8 x 4 cells
+const frame = createSpriteFrame(); // reused; reading one allocates nothing
+drawSprite(batch, sheet.texture, place, sheetFrame(sheet, frameOf(sheet, '5'), frame), null);
+```
+
+**A cell that would run off the edge is not emitted.** A sheet 70 texels wide cut into sixteens has
+four whole cells and six texels of margin, and a fifth cell reading into that margin is a frame with
+a stripe of nothing down one side — which reads as a rendering bug rather than as a badly measured
+atlas.
+
+**A frame index the sheet does not have reads as the whole texture rather than throwing**, because
+this is called per sprite per frame and nothing may throw in the frame loop. What a caller then sees
+is the entire atlas drawn where one picture should be, which is unmistakable.
+
+## Tilemaps
+
+```ts
+const map = createTilemap(1000, 1000, 32, 32);
+setTile(map, 4, 7, frameOf(sheet, 'grass'));
+const drawn = drawTilemap(batch, map, sheet, { x: camX, y: camY, w: 1280, h: 720 }, null);
+```
+
+**The cost is the view rather than the map.** The visible span is arithmetic on four numbers, so a
+million-cell map costs the few hundred cells on screen — measured at 25 drawn from a 1,000 by 1,000
+map. A walk over every cell testing each against the view draws exactly the same picture and is
+unusable at the size a tilemap exists for.
+
+**Which way the rows run is the affine's business, not the map's.** A cell's corner is
+`y + row * tileHeight`, so in screen space — where y counts down — row 0 is the top row, and in a 2D
+world it is the bottom. That is the same rule `SpritePlacement` states about its own corner, and one
+rule rather than a flag is what keeps the two agreeing.
+
+## Textures
+
+`setTexture(slot, source, options)` takes an `ImageBitmap`, an `HTMLCanvasElement` or an
+`OffscreenCanvas` — narrower than `TexImageSource` because that is the union both backends take
+without a conversion. An `<img>` reaches it through one `createImageBitmap`, which is also where the
+decode's own orientation and premultiply options live.
+
+`colorSpace` defaults to `srgb`, which is right for anything painted to be looked at; the sampler
+decodes and the pass's own output transform re-encodes, so the blend happens in linear light.
+`filter` defaults to `nearest`, because a sheet is usually pixel art and linear filtering is the
+thing that makes pixel art look wrong.
+
+**Neither backend flips the image.** `surfaceTexture.ts` in core carries the whole argument and the
+bug it came from: WebGL2 ignores `UNPACK_FLIP_Y_WEBGL` for an `ImageBitmap` and honours it for a
+canvas, so a pipeline checked with one source type is half checked. `scripts/sprite-check.mjs`
+checks both.
+
+## The retained interface tree
+
+```ts
+const root = createUiNode({ direction: 'column', width: 'grow', height: 'grow', justify: 'end' });
+const bar = addUiChild(root, createUiNode({ direction: 'row', padding: 10, gap: 10, name: 'bar' }));
+addUiChild(bar, createUiNode({ width: 60, height: 40, interactive: true, name: 'start' }));
+
+layoutUiTree(root, 0, 0, canvas.clientWidth, canvas.clientHeight);
+routeUiPointer(input, root, pointerX, pointerY, pointerDown);
+drawUiTree(sprites.batch, root, sprites.white, null);
+```
+
+**`layoutUiTree` is two passes and no third**: measure what every node comes to on its own,
+bottom-up, then place what got a size, top-down. A `fit` that depended on the space it was given
+would need a rule for when to stop, which is where a layout engine stops being explicable.
+
+Three size cases — a number, `fit`, `grow` — rather than percentages or flex weights. A percentage
+of a parent that is itself `fit` is a cycle. A `grow` child measures as `fit`, which is what lets a
+menu sized to its contents hold a row that fills it.
+
+**It allocates nothing.** Every number lands in a `UiRect` the node already owns, which is why a
+node is an object with mutable fields rather than a description that gets resolved into one: an
+interface tree is tens of nodes built once and mutated, not thousands rebuilt per frame.
+
+The box you give it is what is _available_ — the root resolves its own size against it, so the same
+call lays out a full-screen HUD and a tooltip.
+
+## Hit testing, focus and routing
+
+`uiHitTest` searches **last-drawn first**, so it agrees with the picture. **A node that is not
+`interactive` does not block what is behind it**: a backdrop that swallowed clicks makes every
+button under a plate dead, which no screenshot shows. A modal that wants to swallow them says so by
+being interactive.
+
+`routeUiPointer` activates on **a press and a release on the same node**, so somebody who pressed
+the wrong button can slide off it and let go. It sets `hovered` and `pressed` on the nodes
+themselves, so a caller paints a button from its own state.
+
+`routeUiKey` handles three keys — Tab both ways, Enter and space — and reports everything else
+unhandled, so a caller can have it. Focus order is tree order rather than a declared index, and a
+node hidden since it was focused does not take the keyboard with it.
+
+**Text is the caller's.** This package draws quads; core already draws two kinds of text. Pass a
+`UiContentSink` to `drawUiTree` and it hands you every node with text at its resolved rect, in the
+order it was drawn.
+
+## From DriftScript
+
+**`drift/ui` is bound**: eighteen capabilities over the tree, addressed by the names its nodes were
+built with. A host builds the tree and hands the root to a script through `uses`, the way a
+`Terrain` arrives.
+
+```
+import { layout, hovered, show } from "drift/ui"
+
+fn menu(tree: UiTree) {
+    ui.layout(tree, 0, 0, 1280, 720)
+    ui.show(tree, "start", ui.hovered(tree, "start"))
+}
+```
+
+Reading a laid-out box is `scene.read` and inside the fixed step; `hovered` and `pressed` are
+`input.read` and outside it, so a `@deterministic` system cannot ask where the pointer is.
+
+**`drift/2d` is bound too**, and it is why DriftScript has import aliases. A module's namespace was
+the last segment of its path, so a call would have been `2d.sprite(...)` — a number followed by an
+identifier the lexer refuses — and the binding was written, wired, found uncallable and withdrawn
+rather than shipped. DriftScript 1.11.0 answered it at the import, so the namespace is written out:
+
+```
+import { sprite, tilemap } from "drift/2d" as sprites
+
+fn hud(batch: SpriteBatch) {
+    sprites.sprite(batch, 0, 10, 10, 32, 32)
+}
+```
+
+Twelve capabilities over a batch, a sheet and a tilemap. A draw is `scene.write` and outside the
+fixed step; reading a sheet or a cell is `scene.read` and inside it, so a `@deterministic` system may
+ask what is in a cell and may not draw it. `dropped` is exposed for the same reason it exists: a
+batch that overflows drops draws, and a script with no way to read the count finds out by noticing
+something missing from a corner of the screen.
+
+## What it is checked by
+
+`scripts/sprite-check.mjs`, on a real GPU, on both backends. Every sheet in it is two texels by two
+with four different colours, so a sprite's four quadrants say which corner is which — an assertion a
+mirror fails and a bounding box cannot, since a mirror preserves every count and every box. The
+control is submission order: the same two sprites are drawn both ways round and the overlap changes
+colour.
+
+It found a real defect on its first run. A contributed pass inherits whatever cull state the last
+scene draw left on, and a screen-space quad's winding is not the scene's — so WebGL2 drew **nothing
+at all** while WebGPU, whose pipeline states its own cull mode, was pixel-perfect. No error on
+either side.
+
+`scripts/ui-check.mjs` does the same for the tree, and it asserts the one thing a unit test cannot:
+the page publishes **the boxes the layout computed** and **the bounding boxes of the colours they
+were drawn in**, and the two must agree. A bar sized by its own contents lands at 530, 660, 220 by
+60 on both backends, to **0.0 px**, with the frame byte-identical in all three pointer states. The
+control is the pointer: the middle button paints itself from its own `hovered` and `pressed` flags,
+so routing is a colour in the frame rather than the router's own return value read back.

package/dist/camera2d.d.ts

@@ -0,0 +1,47 @@
+/** The affine that takes a point in a 2D world, or a CSS pixel, to normalised device coordinates. */
+/**
+ * Six numbers, laid out the way a 2D graphics API has laid them out for thirty years:
+ *
+ * ```
+ * ndc.x = m[0] * x + m[2] * y + m[4]
+ * ndc.y = m[1] * x + m[3] * y + m[5]
+ * ```
+ *
+ * A `Float32Array` rather than six fields because it is uploaded as two `vec4`s and read by the
+ * vertex stage every frame; an object would be repacked on the way.
+ */
+export type Affine2D = Float32Array;
+export declare function createAffine2D(): Affine2D;
+/** A 2D camera: where it is, how far in, and which way up. */
+export interface Camera2D {
+    /** World units. The point that lands on the middle of the viewport. */
+    readonly x: number;
+    readonly y: number;
+    /**
+     * Pixels per world unit, and it is the same on both axes on purpose.
+     *
+     * A separate x and y zoom is a non-uniform scale, which turns a circle into an ellipse and a
+     * square tile into a rectangle — the caller who wants that has asked for a stretched picture and
+     * can say so in the sprite's own size, where it is visible.
+     */
+    readonly zoom: number;
+    /** Radians, anticlockwise. The world turns the other way; see `worldToNdc`. */
+    readonly rotation?: number;
+}
+/**
+ * The affine for a 2D world seen through a camera.
+ *
+ * **y counts upward**, which is the opposite of `screenToNdc` below and is deliberate: a 2D world is
+ * a world, and a caller placing a platform above a floor should not have to subtract. A screen-space
+ * overlay is the other convention because that is the one every layout system already uses, and the
+ * two are different enough that sharing one would make each caller wrong half the time.
+ *
+ * Rotation turns the *camera*, so the world turns the other way: at `rotation = +π/2` the camera has
+ * tilted its head anticlockwise and what was to its right is now above it.
+ */
+export declare function worldToNdc(camera: Camera2D, viewportWidth: number, viewportHeight: number, out: Affine2D): Affine2D;
+/**
+ * The affine for CSS pixels with a top-left origin — the convention `InsetRect` and `fillPanel`
+ * already use, and the one a caller laying out an overlay already has.
+ */
+export declare function screenToNdc(viewportWidth: number, viewportHeight: number, out: Affine2D): Affine2D;

package/dist/camera2d.js

@@ -0,0 +1,46 @@
+/** The affine that takes a point in a 2D world, or a CSS pixel, to normalised device coordinates. */
+export function createAffine2D() {
+    return new Float32Array(6);
+}
+/**
+ * The affine for a 2D world seen through a camera.
+ *
+ * **y counts upward**, which is the opposite of `screenToNdc` below and is deliberate: a 2D world is
+ * a world, and a caller placing a platform above a floor should not have to subtract. A screen-space
+ * overlay is the other convention because that is the one every layout system already uses, and the
+ * two are different enough that sharing one would make each caller wrong half the time.
+ *
+ * Rotation turns the *camera*, so the world turns the other way: at `rotation = +π/2` the camera has
+ * tilted its head anticlockwise and what was to its right is now above it.
+ */
+export function worldToNdc(camera, viewportWidth, viewportHeight, out) {
+    const rotation = camera.rotation ?? 0;
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    const perPixelX = 2 / viewportWidth;
+    const perPixelY = 2 / viewportHeight;
+    const a = camera.zoom * cos * perPixelX;
+    const c = camera.zoom * sin * perPixelX;
+    const b = -camera.zoom * sin * perPixelY;
+    const d = camera.zoom * cos * perPixelY;
+    out[0] = a;
+    out[1] = b;
+    out[2] = c;
+    out[3] = d;
+    out[4] = -(a * camera.x + c * camera.y);
+    out[5] = -(b * camera.x + d * camera.y);
+    return out;
+}
+/**
+ * The affine for CSS pixels with a top-left origin — the convention `InsetRect` and `fillPanel`
+ * already use, and the one a caller laying out an overlay already has.
+ */
+export function screenToNdc(viewportWidth, viewportHeight, out) {
+    out[0] = 2 / viewportWidth;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = -2 / viewportHeight;
+    out[4] = -1;
+    out[5] = 1;
+    return out;
+}

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+/*! DriftEngine | Copyright 2026 Drift Technologies | Apache-2.0 | https://github.com/drftrun/driftengine */
+/**
+ * `@driftengine/ui2d` — the 2D layer.
+ *
+ * A quad is the whole of 2D, so this package is one batch and one pass over it: sprites, the
+ * sheets they are cut from, the tilemaps that place thousands of them, and the interface tree that
+ * lays a screen out. It draws through `registerPass` rather than through a verb on the renderer,
+ * which is what lets it be a package at all — see `pass.ts` in core, which names this package as
+ * one of the three that mechanism exists for.
+ */
+export { createAffine2D, screenToNdc, worldToNdc } from './camera2d.ts';
+export type { Affine2D, Camera2D } from './camera2d.ts';
+export { SPRITE_FLOATS, createSpriteBatch, drawSprite, resetSpriteBatch, spriteRun, } from './spriteBatch.ts';
+export type { SpriteBatch, SpritePlacement, SpriteRun, UvRect } from './spriteBatch.ts';
+export { DEFAULT_SPRITE_CAPACITY, DEFAULT_SPRITE_SLOTS, createSpritePass } from './spritePass.ts';
+export type { SpritePass, SpritePassOptions } from './spritePass.ts';
+export { DEFAULT_SPRITE_TEXTURE_OPTIONS } from './spriteTexture.ts';
+export type { SpriteImage, SpriteTextureOptions } from './spriteTexture.ts';
+export { createSpriteFrame, frameOf, gridSheet, namedSheet, sheetFrame, sheetFrameHeight, sheetFrameWidth, } from './spriteSheet.ts';
+export type { SheetEntry, SpriteFrame, SpriteSheet } from './spriteSheet.ts';
+export { TILE_EMPTY, createTilemap, drawTilemap, setTile, tileAt } from './tilemap.ts';
+export type { Tilemap, ViewRect } from './tilemap.ts';
+export { addUiChild, createUiNode, removeUiChild, uiNodeNamed, uiRectHolds } from './uiNode.ts';
+export type { UiAlign, UiJustify, UiNode, UiNodeOptions, UiRect, UiSize } from './uiNode.ts';
+export { layoutUiTree } from './uiLayout.ts';
+export { drawUiTree } from './uiDraw.ts';
+export type { UiContentSink } from './uiDraw.ts';
+export { uiFocusNext, uiFocusOrder, uiFocusPrevious, uiHitTest } from './uiFocus.ts';
+export { createUiInput, resetUiInput, routeUiKey, routeUiPointer, setUiFocus } from './uiInput.ts';
+export type { UiInput } from './uiInput.ts';

package/dist/index.js

@@ -0,0 +1,21 @@
+/*! DriftEngine | Copyright 2026 Drift Technologies | Apache-2.0 | https://github.com/drftrun/driftengine */
+/**
+ * `@driftengine/ui2d` — the 2D layer.
+ *
+ * A quad is the whole of 2D, so this package is one batch and one pass over it: sprites, the
+ * sheets they are cut from, the tilemaps that place thousands of them, and the interface tree that
+ * lays a screen out. It draws through `registerPass` rather than through a verb on the renderer,
+ * which is what lets it be a package at all — see `pass.ts` in core, which names this package as
+ * one of the three that mechanism exists for.
+ */
+export { createAffine2D, screenToNdc, worldToNdc } from './camera2d.js';
+export { SPRITE_FLOATS, createSpriteBatch, drawSprite, resetSpriteBatch, spriteRun, } from './spriteBatch.js';
+export { DEFAULT_SPRITE_CAPACITY, DEFAULT_SPRITE_SLOTS, createSpritePass } from './spritePass.js';
+export { DEFAULT_SPRITE_TEXTURE_OPTIONS } from './spriteTexture.js';
+export { createSpriteFrame, frameOf, gridSheet, namedSheet, sheetFrame, sheetFrameHeight, sheetFrameWidth, } from './spriteSheet.js';
+export { TILE_EMPTY, createTilemap, drawTilemap, setTile, tileAt } from './tilemap.js';
+export { addUiChild, createUiNode, removeUiChild, uiNodeNamed, uiRectHolds } from './uiNode.js';
+export { layoutUiTree } from './uiLayout.js';
+export { drawUiTree } from './uiDraw.js';
+export { uiFocusNext, uiFocusOrder, uiFocusPrevious, uiHitTest } from './uiFocus.js';
+export { createUiInput, resetUiInput, routeUiKey, routeUiPointer, setUiFocus } from './uiInput.js';

package/dist/shaders/generated/sprite.wgsl.d.ts

@@ -0,0 +1,54 @@
+export declare const SPRITE_FRAG_WGSL = "struct Uniforms {\n    uOutputTransform: i32,\n    uOutputExposure: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(32) \nvar uSpriteTexture_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uSpriteTexture_s: sampler;\nvar<private> vUv_1: vec2<f32>;\nvar<private> vTint_1: vec4<f32>;\nvar<private> fragColor: vec4<f32>;\n\nfn linearToSrgb_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var low: vec3<f32>;\n    var high: vec3<f32>;\n\n    let _e55 = (*c);\n    low = (_e55 * 12.92f);\n    let _e57 = (*c);\n    high = ((pow(max(_e57, vec3<f32>(0f, 0f, 0f)), vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3(0.055f));\n    let _e63 = high;\n    let _e64 = low;\n    let _e65 = (*c);\n    return mix(_e63, _e64, step(_e65, vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f)));\n}\n\nfn rrtAndOdtFit_u0028_vf3_u003b(v: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var a: vec3<f32>;\n    var b: vec3<f32>;\n\n    let _e55 = (*v);\n    let _e56 = (*v);\n    a = ((_e55 * (_e56 + vec3(0.0245786f))) - vec3(0.000090537f));\n    let _e62 = (*v);\n    let _e63 = (*v);\n    b = ((_e62 * ((_e63 * 0.983729f) + vec3(0.432951f))) + vec3(0.238081f));\n    let _e70 = a;\n    let _e71 = b;\n    return (_e70 / _e71);\n}\n\nfn acesFilmic_u0028_vf3_u003b(x: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param: vec3<f32>;\n\n    let _e55 = unnamed.uOutputExposure;\n    let _e56 = (*x);\n    (*x) = (_e56 * _e55);\n    let _e58 = (*x);\n    param = (mat3x3<f32>(vec3<f32>(0.59719f, 0.076f, 0.0284f), vec3<f32>(0.35458f, 0.90834f, 0.13383f), vec3<f32>(0.04823f, 0.01566f, 0.83777f)) * _e58);\n    let _e60 = rrtAndOdtFit_u0028_vf3_u003b((&param));\n    return clamp((mat3x3<f32>(vec3<f32>(1.60475f, -0.10208f, -0.00327f), vec3<f32>(-0.53108f, 1.10813f, -0.07276f), vec3<f32>(-0.07367f, -0.00605f, 1.07602f)) * _e60), vec3(0f), vec3(1f));\n}\n\nfn applyOutputTransform_u0028_vf3_u003b(c_1: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param_1: vec3<f32>;\n    var param_2: vec3<f32>;\n\n    let _e56 = unnamed.uOutputTransform;\n    if (_e56 == 0i) {\n        let _e58 = (*c_1);\n        return _e58;\n    }\n    let _e60 = unnamed.uOutputTransform;\n    if (_e60 == 2i) {\n        let _e62 = (*c_1);\n        param_1 = _e62;\n        let _e63 = acesFilmic_u0028_vf3_u003b((&param_1));\n        (*c_1) = _e63;\n    }\n    let _e64 = (*c_1);\n    param_2 = _e64;\n    let _e65 = linearToSrgb_u0028_vf3_u003b((&param_2));\n    return _e65;\n}\n\nfn main_1() {\n    var texel: vec4<f32>;\n    var colour: vec4<f32>;\n    var param_3: vec3<f32>;\n\n    let _e55 = vUv_1;\n    let _e56 = textureSample(uSpriteTexture_t, uSpriteTexture_s, _e55);\n    texel = _e56;\n    let _e57 = texel;\n    let _e58 = vTint_1;\n    colour = (_e57 * _e58);\n    let _e61 = colour[3u];\n    if (_e61 < 0.00392157f) {\n        discard;\n    }\n    let _e63 = colour;\n    param_3 = _e63.xyz;\n    let _e65 = applyOutputTransform_u0028_vf3_u003b((&param_3));\n    let _e66 = colour;\n    colour = vec4<f32>(_e65.x, _e65.y, _e65.z, _e66.w);\n    let _e72 = colour;\n    let _e75 = colour[3u];\n    let _e76 = (_e72.xyz * _e75);\n    let _e78 = colour[3u];\n    fragColor = vec4<f32>(_e76.x, _e76.y, _e76.z, _e78);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>, @location(1) vTint: vec4<f32>) -> @location(0) vec4<f32> {\n    vUv_1 = vUv;\n    vTint_1 = vTint;\n    main_1();\n    let _e5 = fragColor;\n    return _e5;\n}\n";
+export declare const SPRITE_VERT_WGSL = "struct Uniforms {\n    uToNdc0_: vec4<f32>,\n    uToNdc1_: vec4<f32>,\n    uClipCorrection: mat4x4<f32>,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @location(0) member: vec2<f32>,\n    @location(1) member_1: vec4<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n}\n\nvar<private> gl_VertexIndex_1: i32;\nvar<private> aOrigin_1: vec2<f32>;\nvar<private> aEdges_1: vec4<f32>;\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> vUv: vec2<f32>;\nvar<private> aUv_1: vec4<f32>;\nvar<private> vTint: vec4<f32>;\nvar<private> aTint_1: vec4<f32>;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\n\nfn main_1() {\n    var corner: vec2<f32>;\n    var indexable: array<vec2<f32>, 6>;\n    var p: vec2<f32>;\n    var ndc: vec2<f32>;\n\n    let _e28 = gl_VertexIndex_1;\n    indexable = array<vec2<f32>, 6>(vec2<f32>(0f, 0f), vec2<f32>(1f, 0f), vec2<f32>(0f, 1f), vec2<f32>(0f, 1f), vec2<f32>(1f, 0f), vec2<f32>(1f, 1f));\n    let _e30 = indexable[_e28];\n    corner = _e30;\n    let _e31 = aOrigin_1;\n    let _e32 = aEdges_1;\n    let _e35 = corner[0u];\n    let _e38 = aEdges_1;\n    let _e41 = corner[1u];\n    p = ((_e31 + (_e32.xy * _e35)) + (_e38.zw * _e41));\n    let _e46 = unnamed.uToNdc0_[0u];\n    let _e48 = p[0u];\n    let _e52 = unnamed.uToNdc0_[2u];\n    let _e54 = p[1u];\n    let _e59 = unnamed.uToNdc1_[0u];\n    let _e63 = unnamed.uToNdc0_[1u];\n    let _e65 = p[0u];\n    let _e69 = unnamed.uToNdc0_[3u];\n    let _e71 = p[1u];\n    let _e76 = unnamed.uToNdc1_[1u];\n    ndc = vec2<f32>((((_e46 * _e48) + (_e52 * _e54)) + _e59), (((_e63 * _e65) + (_e69 * _e71)) + _e76));\n    let _e79 = aUv_1;\n    let _e81 = aUv_1;\n    let _e83 = corner;\n    vUv = mix(_e79.xy, _e81.zw, _e83);\n    let _e85 = aTint_1;\n    vTint = _e85;\n    let _e87 = unnamed.uClipCorrection;\n    let _e88 = ndc;\n    unnamed_1.gl_Position = (_e87 * vec4<f32>(_e88.x, _e88.y, 0f, 1f));\n    return;\n}\n\n@vertex \nfn main(@builtin(vertex_index) gl_VertexIndex: u32, @location(3) aOrigin: vec2<f32>, @location(0) aEdges: vec4<f32>, @location(1) aUv: vec4<f32>, @location(2) aTint: vec4<f32>) -> VertexOutput {\n    gl_VertexIndex_1 = i32(gl_VertexIndex);\n    aOrigin_1 = aOrigin;\n    aEdges_1 = aEdges;\n    aUv_1 = aUv;\n    aTint_1 = aTint;\n    main_1();\n    let _e16 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e16);\n    let _e18 = vUv;\n    let _e19 = vTint;\n    let _e20 = unnamed_1.gl_Position;\n    return VertexOutput(_e18, _e19, _e20);\n}\n";
+/**
+ * What the transform assigned, so the renderer binds the same numbers.
+ *
+ * A permuted shader has one entry per variant, keyed as `FLAT_FRAG_WGSL` is.
+ */
+export declare const SPRITE_BINDINGS: {
+    readonly SPRITE_FRAG: {
+        readonly uniforms: 1;
+        readonly uniformSize: 16;
+        readonly fields: {
+            readonly uOutputTransform: {
+                readonly offset: 0;
+                readonly size: 4;
+                readonly type: "int";
+            };
+            readonly uOutputExposure: {
+                readonly offset: 4;
+                readonly size: 4;
+                readonly type: "float";
+            };
+        };
+        readonly textures: {
+            readonly uSpriteTexture: {
+                readonly texture: 32;
+                readonly sampler: 33;
+                readonly type: "sampler2D";
+            };
+        };
+    };
+    readonly SPRITE_VERT: {
+        readonly uniforms: 0;
+        readonly uniformSize: 96;
+        readonly fields: {
+            readonly uToNdc0: {
+                readonly offset: 0;
+                readonly size: 16;
+                readonly type: "vec4";
+            };
+            readonly uToNdc1: {
+                readonly offset: 16;
+                readonly size: 16;
+                readonly type: "vec4";
+            };
+            readonly uClipCorrection: {
+                readonly offset: 32;
+                readonly size: 64;
+                readonly type: "mat4";
+            };
+        };
+        readonly textures: {};
+    };
+};