@downdraft/engine 0.1.0 → 0.1.2-alpha.5

package/dist/shader-graph/src/wgsl-struct.js

@@ -0,0 +1,251 @@
+// ============================================================================
+// wgsl-struct — typed WGSL struct definitions with computed layout
+//
+// Single source of truth for uniform/storage struct layout. Define a struct
+// once in TS; the layout (offsets/alignment/padding/size) is computed at module
+// load per the WGSL spec §14.4 (uniform address space). The struct emits its
+// own WGSL declaration string, and a zero-copy typed view wraps a Float32Array
+// with named field setters (type-checked at the TS level).
+//
+// This replaces the hand-mirrored struct + magic-offset buffer-write pattern
+// (e.g. `data.set(viewProj, 0); data.set(prevViewProj, 16); ...`) that relies
+// on "MUST match the WGSL below" comments.
+// ============================================================================
+// ─── Layout helpers ─────────────────────────────────────────────────────────
+const roundUp = (alignment, n) => (n + alignment - 1) & ~(alignment - 1);
+function makeType(wgsl, align, size, stride = size, isInt = false, isStruct = false) {
+    return Object.freeze({
+        wgsl,
+        align,
+        size,
+        stride,
+        floatCount: size / 4,
+        isInt,
+        isStruct,
+    });
+}
+// ─── Scalar type descriptors ────────────────────────────────────────────────
+export const f32 = makeType("f32", 4, 4);
+export const u32 = makeType("u32", 4, 4, 4, true);
+export const i32 = makeType("i32", 4, 4, 4, true);
+export const f16 = makeType("f16", 2, 2);
+// ─── Vector type descriptors ────────────────────────────────────────────────
+// Per WGSL §14.4: vec2<T> align 8 size 8; vec3<T> align 16 size 12;
+// vec4<T> align 16 size 16. (For f16 element the align/size differ, but the
+// engine only uses f32/u32/i32 vectors — keep it simple.)
+function vec(n, el, isInt) {
+    const elSize = el === "f16" ? 2 : 4;
+    const elAlign = elSize;
+    if (n === 2) {
+        return makeType(`vec2<${el}>`, Math.max(8, elAlign * 2), elSize * 2, elSize * 2, isInt);
+    }
+    if (n === 3) {
+        // vec3: align 16 (for f32/u32/i32), size 12.
+        return makeType(`vec3<${el}>`, 16, elSize * 3, 16, isInt);
+    }
+    if (n === 4) {
+        return makeType(`vec4<${el}>`, 16, elSize * 4, elSize * 4, isInt);
+    }
+    throw new Error(`wgsl: unsupported vector length ${n}`);
+}
+export const vec2f = vec(2, "f32", false);
+export const vec3f = vec(3, "f32", false);
+export const vec4f = vec(4, "f32", false);
+export const vec2u = vec(2, "u32", true);
+export const vec3u = vec(3, "u32", true);
+export const vec4u = vec(4, "u32", true);
+export const vec2i = vec(2, "i32", true);
+export const vec3i = vec(3, "i32", true);
+export const vec4i = vec(4, "i32", true);
+// ─── Matrix type descriptors ────────────────────────────────────────────────
+// Per WGSL §14.4: matCxR<T> has alignment = alignment of vecR<T>, and size =
+// C * RoundUp(16, stride) where stride = size of vecR<T> rounded up to 16.
+// For mat4x4<f32>: align 16, size 4*16 = 64, stride 16.
+// For mat3x3<f32>: align 16, size 3*16 = 48, stride 16 (vec3 size 12 → 16).
+// For mat4x3<f32>: align 16, size 4*16 = 64, stride 16.
+// For mat3x4<f32>: align 16, size 3*16 = 48, stride 16.
+function mat(cols, rows, el = "f32") {
+    if (el !== "f32" && el !== "f16") {
+        throw new Error(`wgsl: matrix element type must be f32 or f16, got ${el}`);
+    }
+    const elSize = el === "f16" ? 2 : 4;
+    // Column type is vec<rows, el>. Its align and padded stride:
+    let colAlign;
+    let colStride;
+    if (rows === 2) {
+        colAlign = Math.max(8, elSize * 2);
+        colStride = roundUp(16, elSize * 2);
+    }
+    else if (rows === 3) {
+        colAlign = 16;
+        colStride = 16; // vec3 size 12 → padded to 16
+    }
+    else if (rows === 4) {
+        colAlign = 16;
+        colStride = elSize * 4; // = 16 for f32
+        colStride = roundUp(16, colStride);
+    }
+    else {
+        throw new Error(`wgsl: unsupported matrix row count ${rows}`);
+    }
+    const size = cols * colStride;
+    return makeType(`mat${cols}x${rows}<${el}>`, colAlign, size, colStride);
+}
+export const mat4x4f = mat(4, 4);
+export const mat3x3f = mat(3, 3);
+export const mat4x3f = mat(4, 3);
+export const mat3x4f = mat(3, 4);
+export const mat2x2f = mat(2, 2);
+export const mat2x4f = mat(2, 4);
+export const mat4x2f = mat(4, 2);
+// ─── Array type descriptor ──────────────────────────────────────────────────
+/** `array<T, N>` — fixed-size array. Stride = RoundUp(alignof(T), sizeOf(T)). */
+export function arrayOf(element, count) {
+    const stride = roundUp(element.align, element.size);
+    const size = stride * count;
+    const wgsl = `array<${element.wgsl}, ${count}>`;
+    return makeType(wgsl, element.align, size, stride, element.isInt);
+}
+/**
+ * Define a WGSL struct. Layout is computed once at call time per WGSL §14.4
+ * (uniform address space). Returns a frozen `WgslStruct` descriptor.
+ *
+ * @example
+ * const CameraUniforms = wgsl.struct("CameraUniforms", {
+ *   viewProj: wgsl.mat4x4f,
+ *   prevViewProj: wgsl.mat4x4f,
+ * });
+ * CameraUniforms.size; // 128
+ * CameraUniforms.wgsl; // "struct CameraUniforms {\n  viewProj: mat4x4<f32>,\n  ...\n}\n"
+ */
+export const wgsl = {
+    // Scalar/vector/matrix/array descriptors re-exported for ergonomics.
+    f32, u32, i32, f16,
+    vec2f, vec3f, vec4f, vec2u, vec3u, vec4u, vec2i, vec3i, vec4i,
+    mat4x4f, mat3x3f, mat4x3f, mat3x4f, mat2x2f, mat2x4f, mat4x2f,
+    array: arrayOf,
+    /**
+     * Reference a previously-defined `WgslStruct` as a field type inside another
+     * struct (nested-struct layout). The emitted WGSL field line uses the struct
+     * name (e.g. `inner: Inner,`); the nested struct's own declaration must be
+     * emitted separately via `inner.wgsl`.
+     */
+    ref(s) {
+        return makeType(s.name, s.align, s.size, s.size, false, true);
+    },
+    struct(name, fields) {
+        const layouts = [];
+        let offset = 0;
+        let structAlign = 4; // minimum alignment is 4 (size of largest scalar)
+        for (const [fieldName, type] of Object.entries(fields)) {
+            // Advance offset to the field's alignment boundary.
+            offset = roundUp(type.align, offset);
+            layouts.push({
+                name: fieldName,
+                offset,
+                type,
+                isInt: type.isInt,
+            });
+            offset += type.size;
+            if (type.align > structAlign)
+                structAlign = type.align;
+        }
+        // Struct size = round up to struct alignment (trailing pad).
+        const size = roundUp(structAlign, offset);
+        // Build the WGSL declaration string.
+        const fieldLines = layouts.map((f) => `  ${f.name}: ${f.type.wgsl},`).join("\n");
+        const wgslStr = `struct ${name} {\n${fieldLines}\n}`;
+        const fieldMap = new Map();
+        layouts.forEach((f) => { fieldMap.set(f.name, f); ; });
+        const fieldNames = layouts.map((f) => f.name);
+        const descriptor = {
+            name,
+            size,
+            align: structAlign,
+            floatCount: size / 4,
+            fields: Object.freeze(layouts),
+            fieldNames: Object.freeze(fieldNames),
+            fieldMap,
+            wgsl: wgslStr,
+            view(buffer) {
+                return new StructViewImpl(descriptor, buffer);
+            },
+        };
+        return Object.freeze(descriptor);
+    },
+};
+class StructViewImpl {
+    struct;
+    floats;
+    u32s = null;
+    constructor(struct, buffer) {
+        if (buffer.length * 4 < struct.size) {
+            throw new Error(`StructView: buffer too small for struct "${struct.name}" ` +
+                `(need ${struct.size} bytes / ${struct.floatCount} floats, got ${buffer.length} floats)`);
+        }
+        this.struct = struct;
+        this.floats = buffer;
+    }
+    u32View() {
+        if (!this.u32s) {
+            this.u32s = new Uint32Array(this.floats.buffer, this.floats.byteOffset, this.floats.length);
+        }
+        return this.u32s;
+    }
+    fieldOffset(field) {
+        const f = this.struct.fieldMap.get(field);
+        if (!f) {
+            throw new Error(`StructView("${this.struct.name}"): unknown field "${field}". ` +
+                `Known: ${[...this.struct.fieldMap.keys()].join(", ")}`);
+        }
+        return f.offset / 4; // float index
+    }
+    set(field, value) {
+        const f = this.struct.fieldMap.get(field);
+        if (!f) {
+            throw new Error(`StructView("${this.struct.name}"): unknown field "${field}"`);
+        }
+        const start = f.offset / 4;
+        if (typeof value === "number") {
+            this.floats[start] = value;
+        }
+        else {
+            this.floats.set(value, start);
+        }
+    }
+    setU32(field, value) {
+        const f = this.struct.fieldMap.get(field);
+        if (!f) {
+            throw new Error(`StructView("${this.struct.name}"): unknown field "${field}"`);
+        }
+        if (!f.isInt && f.type.wgsl !== "u32" && f.type.wgsl !== "i32") {
+            // Allow setU32 on any field but warn in strict? For packed-handle fields
+            // the engine uses u32. Keep it permissive — the caller knows the field.
+        }
+        const start = f.offset / 4;
+        this.u32View()[start] = value >>> 0;
+    }
+    get(field) {
+        const f = this.struct.fieldMap.get(field);
+        if (!f) {
+            throw new Error(`StructView("${this.struct.name}"): unknown field "${field}"`);
+        }
+        const start = f.offset / 4;
+        const count = f.type.size / 4;
+        return this.floats.subarray(start, start + count);
+    }
+    getU32(field) {
+        const f = this.struct.fieldMap.get(field);
+        if (!f) {
+            throw new Error(`StructView("${this.struct.name}"): unknown field "${field}"`);
+        }
+        const start = f.offset / 4;
+        return this.u32View()[start];
+    }
+    zero() {
+        this.floats.fill(0, 0, this.struct.floatCount);
+    }
+    get size() {
+        return this.struct.size;
+    }
+}

package/dist/test/src/index.js

@@ -0,0 +1 @@
+export { VisionTest, VisionTestSuite } from "./vision-test.js";

package/dist/test/src/vision-test.js

@@ -0,0 +1,228 @@
+export class VisionTest {
+    device;
+    readbackBuffer = null;
+    width = 0;
+    height = 0;
+    constructor(device) {
+        this.device = device;
+    }
+    async captureTexture(texture, width, height, format = "rgba8unorm") {
+        const bytesPerPixel = format.includes("16float") ? 8 : 4;
+        const bytesPerRow = Math.ceil((width * bytesPerPixel) / 256) * 256;
+        const bufferSize = bytesPerRow * height;
+        if (!this.readbackBuffer ||
+            this.width !== width ||
+            this.height !== height) {
+            this.readbackBuffer?.destroy();
+            this.readbackBuffer = this.device.createBuffer({
+                size: bufferSize,
+                usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+            });
+            this.width = width;
+            this.height = height;
+        }
+        const encoder = this.device.createCommandEncoder();
+        encoder.copyTextureToBuffer({ texture, mipLevel: 0, origin: [0, 0, 0] }, {
+            buffer: this.readbackBuffer,
+            bytesPerRow,
+            rowsPerImage: height,
+        }, [width, height, 1]);
+        this.device.queue.submit([encoder.finish()]);
+        await this.readbackBuffer.mapAsync(GPUMapMode.READ);
+        const arrayBuffer = this.readbackBuffer.getMappedRange();
+        const result = new Uint8Array(arrayBuffer.slice(0));
+        this.readbackBuffer.unmap();
+        if (bytesPerRow !== width * bytesPerPixel) {
+            const unstripped = new Uint8Array(width * height * bytesPerPixel);
+            for (let y = 0; y < height; y++) {
+                const srcOffset = y * bytesPerRow;
+                const dstOffset = y * width * bytesPerPixel;
+                unstripped.set(result.subarray(srcOffset, srcOffset + width * bytesPerPixel), dstOffset);
+            }
+            return unstripped;
+        }
+        return result;
+    }
+    async captureCanvas(canvas, width, height) {
+        const context = canvas.getContext("webgpu");
+        if (!context)
+            throw new Error("Canvas does not have a WebGPU context");
+        const texture = context.getCurrentTexture();
+        if (!texture)
+            throw new Error("Surface acquire failed (resize in flight?) — retry next frame");
+        return this.captureTexture(texture, width, height);
+    }
+    getPixel(data, width, x, y) {
+        const idx = (y * width + x) * 4;
+        return {
+            x,
+            y,
+            r: data[idx],
+            g: data[idx + 1],
+            b: data[idx + 2],
+            a: data[idx + 3],
+        };
+    }
+    scanRegion(data, width, x, y, regionWidth, regionHeight) {
+        const results = [];
+        for (let dy = 0; dy < regionHeight; dy++) {
+            for (let dx = 0; dx < regionWidth; dx++) {
+                const px = x + dx;
+                const py = y + dy;
+                if (px >= width)
+                    break;
+                results.push(this.getPixel(data, width, px, py));
+            }
+        }
+        return results;
+    }
+    assertPixel(data, width, x, y, expected, tolerance = 5) {
+        const pixel = this.getPixel(data, width, x, y);
+        return (Math.abs(pixel.r - expected[0]) <= tolerance &&
+            Math.abs(pixel.g - expected[1]) <= tolerance &&
+            Math.abs(pixel.b - expected[2]) <= tolerance &&
+            Math.abs(pixel.a - expected[3]) <= tolerance);
+    }
+    assertRegionColor(data, width, x, y, regionWidth, regionHeight, expected, tolerance = 5) {
+        for (let dy = 0; dy < regionHeight; dy++) {
+            for (let dx = 0; dx < regionWidth; dx++) {
+                if (!this.assertPixel(data, width, x + dx, y + dy, expected, tolerance)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    averageColor(data, width, x, y, regionWidth, regionHeight) {
+        let r = 0, g = 0, b = 0, a = 0;
+        let count = 0;
+        for (let dy = 0; dy < regionHeight; dy++) {
+            for (let dx = 0; dx < regionWidth; dx++) {
+                const pixel = this.getPixel(data, width, x + dx, y + dy);
+                r += pixel.r;
+                g += pixel.g;
+                b += pixel.b;
+                a += pixel.a;
+                count++;
+            }
+        }
+        return [r / count, g / count, b / count, a / count];
+    }
+    compare(actual, expected, width, height, options = { tolerance: 5 }) {
+        const tolerance = options.tolerance;
+        const ignoreAlpha = options.ignoreAlpha ?? false;
+        let diffPixels = 0;
+        let maxDiff = 0;
+        const diffImage = new Uint8Array(width * height * 4);
+        for (let i = 0; i < width * height; i++) {
+            const idx = i * 4;
+            const mask = options.mask ? options.mask[i] : 1;
+            if (mask === 0) {
+                diffImage[idx] = 0;
+                diffImage[idx + 1] = 0;
+                diffImage[idx + 2] = 0;
+                diffImage[idx + 3] = 255;
+                continue;
+            }
+            const dr = Math.abs(actual[idx] - expected[idx]);
+            const dg = Math.abs(actual[idx + 1] - expected[idx + 1]);
+            const db = Math.abs(actual[idx + 2] - expected[idx + 2]);
+            const da = ignoreAlpha ? 0 : Math.abs(actual[idx + 3] - expected[idx + 3]);
+            const pixelDiff = Math.max(dr, dg, db, da);
+            maxDiff = Math.max(maxDiff, pixelDiff);
+            if (pixelDiff > tolerance) {
+                diffPixels++;
+                diffImage[idx] = 255;
+                diffImage[idx + 1] = 0;
+                diffImage[idx + 2] = 0;
+                diffImage[idx + 3] = 255;
+            }
+            else {
+                diffImage[idx] = actual[idx];
+                diffImage[idx + 1] = actual[idx + 1];
+                diffImage[idx + 2] = actual[idx + 2];
+                diffImage[idx + 3] = actual[idx + 3];
+            }
+        }
+        const totalPixels = width * height;
+        return {
+            totalPixels,
+            diffPixels,
+            diffPercentage: (diffPixels / totalPixels) * 100,
+            maxDiff,
+            diffImage,
+        };
+    }
+    async screenshotToDataURL(texture, width, height) {
+        const data = await this.captureTexture(texture, width, height);
+        const canvas = document.createElement("canvas");
+        canvas.width = width;
+        canvas.height = height;
+        const ctx = canvas.getContext("2d");
+        const imageData = ctx.createImageData(width, height);
+        imageData.data.set(data);
+        ctx.putImageData(imageData, 0, 0);
+        return canvas.toDataURL("image/png");
+    }
+    destroy() {
+        this.readbackBuffer?.destroy();
+        this.readbackBuffer = null;
+    }
+}
+export class VisionTestSuite {
+    vision;
+    results = [];
+    constructor(device) {
+        this.vision = new VisionTest(device);
+    }
+    async runPixelTest(name, texture, width, height, assertions) {
+        const data = await this.vision.captureTexture(texture, width, height);
+        let allPassed = true;
+        const failures = [];
+        assertions.forEach((assertion) => {
+            const passed = this.vision.assertPixel(data, width, assertion.x, assertion.y, assertion.expected, assertion.tolerance ?? 5);
+            if (!passed) {
+                allPassed = false;
+                const pixel = this.vision.getPixel(data, width, assertion.x, assertion.y);
+                failures.push(`Pixel (${assertion.x}, ${assertion.y}): expected [${assertion.expected}], got [${pixel.r}, ${pixel.g}, ${pixel.b}, ${pixel.a}]`);
+            }
+        });
+        const result = {
+            name,
+            passed: allPassed,
+            diffPercentage: 0,
+            message: allPassed ? "All pixel assertions passed" : failures.join("; "),
+        };
+        this.results.push(result);
+        return result;
+    }
+    async runComparisonTest(name, texture, width, height, baseline, tolerance = 5, threshold = 1.0) {
+        const data = await this.vision.captureTexture(texture, width, height);
+        const diff = this.vision.compare(data, baseline, width, height, { tolerance });
+        const passed = diff.diffPercentage <= threshold;
+        const result = {
+            name,
+            passed,
+            diffPercentage: diff.diffPercentage,
+            message: passed
+                ? `Diff ${diff.diffPercentage.toFixed(2)}% within threshold ${threshold}%`
+                : `Diff ${diff.diffPercentage.toFixed(2)}% exceeds threshold ${threshold}% (max pixel diff: ${diff.maxDiff})`,
+        };
+        this.results.push(result);
+        return result;
+    }
+    getResults() {
+        return this.results;
+    }
+    getSummary() {
+        const passed = this.results.filter((r) => r.passed).length;
+        return {
+            total: this.results.length,
+            passed,
+            failed: this.results.length - passed,
+        };
+    }
+    destroy() {
+        this.vision.destroy();
+    }
+}

package/libraries/asset-browser/src/software-thumbnails.ts

@@ -224,7 +224,7 @@ export class SoftwareThumbnailRenderer {
       // already has its materials (the worker snapshots PNGs immediately).
       await this.cache.get(contentId)?.texReady;
     } catch (err) {
-      log.warn("SoftwareThumbnailRenderer", `Failed to load ${contentId} (${modelUri}): ${err}`);
+      log.warn("software-thumbnail-renderer", `Failed to load ${contentId} (${modelUri}): ${err}`);
       this.loadBuiltinCube(contentId);
     } finally {
       this.loading.delete(contentId);
@@ -497,7 +497,7 @@ export class SoftwareThumbnailRenderer {
         skelIndices: null, bonePos: null,
       };
     } catch (err) {
-      log.warn("SoftwareThumbnailRenderer", `Pose sampler failed for ${contentId}: ${err}`);
+      log.warn("software-thumbnail-renderer", `Pose sampler failed for ${contentId}: ${err}`);
       return null;
     }
   }

package/libraries/audio-kira/src/backend.ts

@@ -9,6 +9,7 @@ import type {
     AudioSourceHandle,
 } from "@downdraft/engine";
 import { createLogger } from "@downdraft/engine";
+import { findPackageRoot } from "@downdraft/engine/platform/pkg-root";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -44,7 +45,7 @@ async function loadAudioLib(): Promise<AudioLib | null> {
     const { dlopen, ptr, resolveNativeLibrary } = await import("@downdraft/platform-native");
     const libPath = resolveNativeLibrary("downdraft_audio", {
       envVars: ["AUDIO_NATIVE_PATH"],
-      crateDir: join(dirname(fileURLToPath(import.meta.url)), "..", "native"),
+      crateDir: join(findPackageRoot(dirname(fileURLToPath(import.meta.url))), "libraries", "audio-kira", "native"),
       buildHint: 'run "bun run build:native" from the repo root',
       optional: true,
     });

package/libraries/blitz-ui/native/src/shell.rs

@@ -15,7 +15,7 @@ use std::sync::Arc;
 use anyrender::ImageRenderer;
 use anyrender_vello_cpu::VelloCpuImageRenderer;
 use atomic_refcell::AtomicRefCell;
-use blitz_dom::Document;
+use blitz_dom::{BaseDocument, Document};
 use blitz_paint::paint_scene;
 use blitz_traits::events::{
     BlitzPointerEvent, BlitzPointerId, BlitzWheelDelta, BlitzWheelEvent, MouseEventButton,
@@ -234,6 +234,7 @@ impl HeadlessShell {
         };
         let mut inner = self.doc.inner_mut();
         inner.resolve(t);
+        restore_collapsed_borders(&mut inner);
         let (w, h) = inner.viewport().window_size;
         let scale = inner.viewport().scale_f64();
         let is_animating = inner.is_animating();
@@ -253,6 +254,39 @@ impl HeadlessShell {
 
 // ---- public API (game crates expose these via #[wasm_bindgen] shims) ----
 
+/// taffy's `round_layout` snaps each border side to whole layout units via
+/// `round(c + w) - round(c)`, so a sub-unit border side (a 1px border at
+/// zoom 1.25 computes as 0.8px) can round to 0 depending on the node's
+/// cumulative position. A zero side makes blitz-paint's corner-split math
+/// divide by zero and emit NaN border paths — the adjacent edges (e.g. the
+/// left border) then paint nothing. Restore any side taffy collapsed that
+/// layout says is nonzero.
+fn restore_collapsed_borders(doc: &mut BaseDocument) {
+    let root = doc.root_element().id;
+    doc.iter_subtree_mut(root, |id, doc| {
+        let Some(node) = doc.get_node_mut(id) else {
+            return;
+        };
+        let Some(ld) = node.try_layout_data_mut() else {
+            return;
+        };
+        let ub = ld.unrounded_layout.border;
+        let fb = &mut ld.final_layout.border;
+        if fb.left == 0.0 && ub.left > 0.0 {
+            fb.left = ub.left;
+        }
+        if fb.right == 0.0 && ub.right > 0.0 {
+            fb.right = ub.right;
+        }
+        if fb.top == 0.0 && ub.top > 0.0 {
+            fb.top = ub.top;
+        }
+        if fb.bottom == 0.0 && ub.bottom > 0.0 {
+            fb.bottom = ub.bottom;
+        }
+    });
+}
+
 pub fn init(config: ShellConfig, width: f64, height: f64, scale: f64) {
     console_error_panic_hook::set_once();
     BRIDGE.with(|b| b.borrow_mut().shutdown = false);

package/libraries/blitz-ui/native-osr/Cargo.toml

@@ -14,11 +14,19 @@ blitz-html = { git = "https://github.com/DioxusLabs/blitz", rev = "efef6519fe652
 blitz-dom = { git = "https://github.com/DioxusLabs/blitz", rev = "efef6519fe6520caf66dc82df557580eecbf652b", default-features = false, features = ["woff"] }
 blitz-traits = { git = "https://github.com/DioxusLabs/blitz", rev = "efef6519fe6520caf66dc82df557580eecbf652b" }
 blitz-paint = { git = "https://github.com/DioxusLabs/blitz", rev = "efef6519fe6520caf66dc82df557580eecbf652b", features = ["custom-widget"] }
+# Enable the vendored glifo's FreeType mask path (see [patch.crates-io] in the
+# workspace root). Feature unification turns it on inside vello_cpu's copy.
+glifo = { version = "0.2", features = ["freetype"] }
 anyrender_vello_cpu = "0.17.0"
 anyrender = "0.13.0"
 atomic_refcell = "0.1"
 keyboard-types = "0.7"
 linebender_resource_handle = "0.1"
+env_logger = "0.11.11"
+# System clipboard for blitz text editing (Ctrl+C/X/V) — same crate the
+# platform shim uses; no Android backend (clipboard ops no-op there).
+[target.'cfg(not(target_os = "android"))'.dependencies]
+arboard = "3"
 # Workaround copied from blitz examples: disable unicode URL support
 # (see https://github.com/hsivonen/idna_adapter)
 idna_adapter = "=1.0.0"