progpu-renderer 0.1.0-preview.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wiesław Šoltés
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,97 @@
+# ProGPU for JavaScript
+
+An ES-module library using ProGPU's retained C++ vector renderer, compiled to
+WebAssembly and running on WebGPU. No .NET installation or global Module object
+is required. A browser with WebGPU and a secure origin (HTTPS or localhost) is
+required; there is no Canvas2D, WebGL, or software-renderer fallback.
+
+```js
+import { createRenderer, SceneBuilder, Path } from 'progpu-renderer';
+
+const canvas = document.querySelector('canvas');
+const renderer = await createRenderer({ canvas });
+renderer.resize({ width: 640, height: 360, pixelRatio: Math.max(1, Math.min(4, devicePixelRatio)) });
+
+const curve = new Path()
+  .moveTo(80, 160)
+  .cubicTo(80, 20, 280, 20, 280, 160)
+  .lineTo(80, 160)
+  .close();
+const scene = new SceneBuilder({ sceneId: 1n, generation: 1n })
+  .fillRect(20, 20, 40, 40, [1, 0.2, 0.1, 1])
+  .fillPath(curve, [0.1, 0.5, 1, 1])
+  .build();
+
+renderer.updateScene(scene); // Only when the immutable scene changes.
+renderer.render({ clearColor: [0.06, 0.06, 0.08, 1] });
+// Keep the renderer for subsequent frames. It does not install an animation loop.
+// renderer.dispose(); // When the view is permanently removed.
+```
+
+Use your application's requestAnimationFrame scheduling for animated views.
+Call `resize` when the logical size or device-pixel ratio changes. Geometry
+coordinates are logical pixels; colors are RGBA values between zero and one.
+Paths preserve line, quadratic and cubic segments through the native renderer.
+
+## Packaging and assets
+
+The archive includes its JavaScript modules, TypeScript declarations, generated
+`progpu-native.mjs`, and `progpu-native.wasm`. Serve the Wasm file alongside the
+generated module. Bundlers must copy/preserve that asset URL; check the emitted
+network request rather than treating a successful JavaScript build as proof that
+Wasm was deployed. `progpu-renderer/progpu-native.wasm` is an exported asset subpath.
+For unbundled use, map the bare `progpu-renderer` specifier to the installed `index.js`
+with an import map. Node.js can inspect/pack the library, but is not a supported
+WebGPU rendering host for this browser build.
+
+This source tree is packaged by `eng/progpu-pack-npm.mjs`; it is not itself a
+complete publishable archive until the native target has been built and staged.
+PR builds never receive a publishing token. The separate manual release workflow
+uses the repository's `NPM_TOKEN` only for the final publish step after verifying
+the successful Build, merged source commit and exact archive digest. Prereleases
+use the `next` distribution tag. There is no install or publish lifecycle script.
+
+## TypeScript
+
+The installed-package declaration gate uses TypeScript 6.0.3 with `strict`,
+`noEmit`, `target: "ES2022"`, `module: "NodeNext"` and `lib: ["ES2022", "DOM"]`.
+The browser DOM declarations supply the real `GPUDevice` type; the package does
+not substitute a reduced device interface or add a runtime typing dependency.
+The same installed consumer was also checked with TypeScript 7.0.2.
+
+TypeScript 5 users need the supplemental `@webgpu/types` package and must opt it
+into their compiler's `types` list (verified with TypeScript 5.9.3 and
+`@webgpu/types` 0.1.74). Do not unconditionally include that supplement with newer
+DOM libraries: duplicate WebGPU declarations fail strict compilation. Follow the
+[GPUWeb type package's compatibility guidance](https://github.com/gpuweb/types)
+when selecting a compiler and DOM declaration version.
+
+## Ownership and supported authoring
+
+`Path` and `SceneBuilder` are mutable authoring objects. Recording a path/brush
+copies its input; `build()` returns an immutable scene snapshot. Use a new
+generation for changed content with an existing scene ID. Stable frames reuse
+the accepted native scene instead of crossing into Wasm per drawing command.
+
+The typed authoring surface includes solid/linear-gradient fills, nonzero and
+even-odd curved paths, connected polyline strokes, transforms, rectangular clips,
+opacity state and opacity layers. Text layout, SVG parsing and custom shaders
+are not typed JavaScript authoring APIs in this preview. They are not silently
+approximated.
+
+Advanced integrations may supply an existing complete native semantic stream as
+a Uint8Array to `updateScene`. It goes through the same native validation and
+compiler as other ProGPU hosts. `getSceneStream()` returns an owned copy of the
+currently accepted stream; modifying that copy cannot mutate the renderer.
+The exported native module is a low-level, versioned ABI, not a promise that raw
+native pointers or wire layouts are stable across package versions.
+
+Each factory creates an isolated Wasm module and renderer. Pass `{ canvas, device }`
+to borrow an existing WebGPU device; `dispose()` never destroys a supplied device.
+The device must remain live while the renderer is used. Device errors remain
+explicit; disposal is not automatic recovery or permission to reconfigure a
+borrowed device. Runtime-owned handles are released through the native engine.
+
+See `build-info.json`, LICENSE and THIRD-PARTY-NOTICES.md for exact source,
+toolchain and runtime notices. CI's installed-package browser checks are bounded
+rendering/ownership checks, not a claim of complete third-party engine integration.

package/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,22 @@
+# Runtime notices
+
+ProGPU's original renderer and JavaScript adapter are MIT licensed; see LICENSE.
+The generated JavaScript and WebAssembly also contain the Emscripten runtime,
+C/C++ standard-library runtime, and Emdawnwebgpu browser bindings.
+
+The package build copies original notices from the actual pinned Emscripten
+4.0.18 toolchain and its hash-verified Emdawnwebgpu port into `licenses/`.
+`build-info.json` records their file hashes and the exact ProGPU source commit.
+Notices are retained in full; some toolchain notices cover optional runtime
+components which this package does not use.
+
+No font files, third-party renderer implementations, Chromium, Playwright,
+native operating-system libraries, .NET runtime, or NuGet packages are included.
+
+Toolchain references:
+
+- https://github.com/emscripten-core/emscripten/tree/4.0.18
+- https://github.com/emscripten-core/emscripten/blob/4.0.18/tools/ports/emdawnwebgpu.py
+
+The existing pinned Emdawnwebgpu port supplies browser WebGPU ABI bindings.
+It is a declared build dependency, not source copied into ProGPU implementation.

package/build-info.json

@@ -0,0 +1,20 @@
+{
+  "sourceCommit": "bdc27c31e2cdea294790cc0b8e7f66d6ac5961bc",
+  "sourceDirty": false,
+  "emscripten": "4.0.18",
+  "emdawnPortSha256": "119ddcb024a537e5e7afdcbfe3a033a460b2c0bd335dff84552f3e87603eee9c",
+  "buildRunId": "36265448220",
+  "buildRunAttempt": "1",
+  "licenses": {
+    "licenses/emscripten/LICENSE": "620a78084fc7ca97c0b5dea9abf891f3ffcadfdbf305276f099c9c4e12fc1d86",
+    "licenses/emscripten/system/lib/compiler-rt/LICENSE.TXT": "1a8f1058753f1ba890de984e48f0242a3a5c29a6a8f2ed9fd813f36985387e8d",
+    "licenses/emscripten/system/lib/libc/musl/COPYRIGHT": "f9bc4423732350eb0b3f7ed7e91d530298476f8fec0c6c427a1c04ade22655af",
+    "licenses/emscripten/system/lib/libcxx/LICENSE.TXT": "539dd7aed86e8a4f12cbdd0e6c50c189c7d74847e4fecc64ce2c6ee3a01da38b",
+    "licenses/emscripten/system/lib/libcxxabi/LICENSE.TXT": "e2b35be49f7284a45b7baca8fc7b3ab7440e7902392b2528a457816b5bb2a15c",
+    "licenses/emscripten/system/lib/libunwind/LICENSE.TXT": "b5efebcaca80879234098e52d1725e6d9eb8fb96a19fce625d39184b705f7b6d",
+    "licenses/emscripten/system/lib/llvm-libc/LICENSE.TXT": "ebcd9bbf783a73d05c53ba4d586b8d5813dcdf3bbec50265860ccc885e606f47",
+    "licenses/emscripten/system/lib/mimalloc/LICENSE": "19c99805e7a44a34b297a75d1edea9985e300066dfc024d5c99d4236d4573b5d",
+    "licenses/emdawnwebgpu/webgpu/src/LICENSE": "2f79bf3699b0870251255b381670237f73f21a04a38c094f791eba39c5fd1df7",
+    "licenses/emdawnwebgpu/webgpu_cpp/LICENSE": "7e1efc85a78732a13d7ddfc8b52912da7c8f8d3c6d334624b20e3f3a96297de0"
+  }
+}

package/index.d.ts

@@ -0,0 +1,91 @@
+export type Color = readonly [number, number, number, number];
+export type Point = readonly [number, number];
+/** Row-vector affine [m11,m12,m21,m22,m31,m32]. */
+export type Transform = readonly [number, number, number, number, number, number];
+export type Rect = readonly [number, number, number, number];
+export interface LinearGradient {
+    readonly type: 'linearGradient';
+    readonly start: Point;
+    readonly end: Point;
+    readonly stops: readonly {readonly offset: number; readonly color: Color}[];
+    readonly opacity?: number;
+    readonly spread?: 'pad' | 'reflect' | 'repeat';
+}
+export type Brush = Color | LinearGradient;
+export type StrokeCap = 'flat' | 'square' | 'round' | 'triangle';
+export type StrokeJoin = 'miter' | 'bevel' | 'round';
+export interface StrokeOptions {
+    width?: number; closed?: boolean; startCap?: StrokeCap; endCap?: StrokeCap;
+    lineJoin?: StrokeJoin; dashCap?: StrokeCap; miterLimit?: number;
+    /** Alternating on/off thickness multipliers; odd counts repeat. */
+    dashes?: readonly number[];
+    dashOffset?: number; transform?: Transform;
+}
+export class Path {
+    constructor();
+    moveTo(x: number, y: number): this;
+    lineTo(x: number, y: number): this;
+    quadraticTo(cx: number, cy: number, x: number, y: number): this;
+    cubicTo(c1x: number, c1y: number, c2x: number, c2y: number, x: number, y: number): this;
+    close(): this;
+}
+export class Scene {
+    private constructor();
+    readonly sceneId: bigint;
+    readonly generation: bigint;
+}
+export class SceneBuilder {
+    constructor(options?: {sceneId?: bigint; generation?: bigint});
+    fillRect(x: number, y: number, width: number, height: number, brush: Brush, options?: {transform?: Transform}): this;
+    fillPath(path: Path, brush: Brush, options?: {fillRule?: 'nonzero' | 'evenodd'; transform?: Transform}): this;
+    strokePolyline(points: readonly Point[], brush: Brush, options?: StrokeOptions): this;
+    /** Absolute transform/opacity. clipRect is in logical target coordinates. */
+    save(options?: {transform?: Transform; opacity?: number; clipRect?: Rect}): this;
+    restore(): this;
+    /** Isolated source-over compositing; opacity is applied once on pop. */
+    pushLayer(options?: {opacity?: number; bounds?: Rect}): this;
+    popLayer(): this;
+    /** Snapshots authoring data; unbalanced scopes are rejected. */
+    build(): Scene;
+}
+export interface SceneUpdateMetrics {
+    readonly sceneId: bigint; readonly generation: bigint;
+    readonly commandCount: number; readonly resourceCount: number;
+    readonly streamBytes: number; readonly snapshotReused: boolean;
+    readonly drawCount: number; readonly payloadBytes: number;
+}
+export interface FrameMetrics {
+    readonly commandCount: number; readonly drawCallCount: number; readonly familySwitchCount: number;
+    readonly submissionCount: bigint; readonly payloadHash: bigint;
+    readonly vertexUploadBytes: number; readonly indexUploadBytes: number;
+    readonly textureUploadBytes: number; readonly uniformUploadBytes: number;
+    readonly coverageStagingBytes: number; readonly brushUploadBytes: number;
+    readonly gradientStopUploadBytes: number; readonly textStyleUploadBytes: number;
+    readonly colorGlyphUploadBytes: number;
+}
+export interface CanvasMetrics {
+    readonly width: number; readonly height: number;
+    readonly logicalWidth: number; readonly logicalHeight: number; readonly scale: number;
+}
+export interface Renderer {
+    readonly device: GPUDevice;
+    readonly error: Error | null;
+    /** Logical extent with explicit physical-pixel scale (1..4). */
+    resize(options: {width: number; height: number; pixelRatio?: number}): CanvasMetrics;
+    /** One changed immutable generation, or a complete native stream. */
+    updateScene(scene: Scene | Uint8Array): SceneUpdateMetrics;
+    /** Independent copy of the last accepted full native stream. */
+    getSceneStream(): Uint8Array;
+    /** Submits GPU work; return is not a GPU/display completion fence. */
+    render(options?: {clearColor?: Color}): FrameMetrics;
+    /** Idempotent. Never destroys a caller-supplied GPUDevice. */
+    dispose(): void;
+}
+/** Browser DOM + WebGPU only; no Canvas2D/WebGL/software renderer fallback.
+ * The caller owns requestAnimationFrame, CSS sizing and resize notifications.
+ * TypeScript 6+ DOM declarations provide GPUDevice. TypeScript 5 consumers must
+ * explicitly enable supplemental @webgpu/types; do not mix those declarations
+ * with newer DOM libraries that already define WebGPU. */
+export function createRenderer(options: {
+    canvas: HTMLCanvasElement; device?: GPUDevice; onError?: (error: Error) => void;
+}): Promise<Renderer>;

package/index.js

@@ -0,0 +1,158 @@
+import {Scene, SceneBuilder, Path, scenePacket} from './scene.js';
+export {Scene, SceneBuilder, Path};
+
+const canvasOwners = new WeakSet();
+
+// Construct this callback outside createRenderer's lexical environment. A
+// pending borrowed-device promise must retain only the detachable token, not
+// the factory's canvas, module, renderer methods or other closed-over state.
+function deviceLossCallback(lifetime) {
+    return (info) => lifetime.report?.(new Error(`WebGPU device lost (${info.reason}): ${info.message}`));
+}
+
+/** One isolated native module/renderer. No DOM work or GPU initialization occurs
+ * on import. The application owns its animation loop and resize policy. */
+export async function createRenderer({canvas, device: suppliedDevice, onError} = {}) {
+    if (typeof HTMLCanvasElement === 'undefined' || !(canvas instanceof HTMLCanvasElement) ||
+        !canvas.isConnected || canvas.ownerDocument !== document)
+        throw new TypeError('canvas must be a connected HTMLCanvasElement in the current document');
+    if (!globalThis.navigator?.gpu) throw new Error('WebGPU is unavailable');
+    if (canvasOwners.has(canvas) || canvas.hasAttribute('data-progpu-renderer'))
+        throw new Error('The canvas already has a ProGPU renderer');
+    if (onError !== undefined && typeof onError !== 'function') throw new TypeError('onError must be a function');
+
+    canvasOwners.add(canvas);
+    const marker = crypto.randomUUID();
+    canvas.setAttribute('data-progpu-renderer', marker);
+    let device = suppliedDevice, module, disposed = false, initialized = false;
+    let failure = null, listener = null, metricsPointer = 0, errorPointer = 0;
+    let currentScene = null, updateMetrics = null;
+    const lifetime = {report: null};
+    function report(error) {
+        if (disposed || failure) return;
+        failure = error;
+        if (initialized) module._progpu_browser_device_lost();
+        if (onError) onError(error);
+    }
+    lifetime.report = report;
+    function check() {
+        if (disposed) throw new Error('Renderer is disposed');
+        if (failure) throw failure;
+        if (!canvas.isConnected || canvas.getAttribute('data-progpu-renderer') !== marker)
+            throw new Error('The renderer canvas was removed or its ownership marker changed');
+    }
+    function nativeCheck(success) {
+        if (success) return;
+        const heap = module.HEAPU8;
+        let end = errorPointer;
+        while (end < errorPointer + 1024 && heap[end] !== 0) ++end;
+        throw new Error(new TextDecoder().decode(heap.subarray(errorPointer, end)) || 'Native renderer operation failed');
+    }
+    function withBytes(bytes, call) {
+        const pointer = module._malloc(bytes.byteLength);
+        if (!pointer) throw new Error('Native transport allocation failed');
+        try { module.HEAPU8.set(bytes, pointer); return call(pointer); }
+        finally { module._free(pointer); }
+    }
+    function word(index) { return new DataView(module.HEAPU8.buffer).getBigUint64(metricsPointer + index * 8, true); }
+    function count(index) { return Number(word(index)); }
+    function resize({width, height, pixelRatio = Math.max(1, Math.min(4, globalThis.devicePixelRatio || 1))}) {
+        check();
+        for (const value of [width, height, pixelRatio])
+            if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) throw new RangeError('Canvas dimensions and pixel ratio must be positive and finite');
+        if (pixelRatio < 1 || pixelRatio > 4) throw new RangeError('The native browser host supports pixel ratios from one to four');
+        const physicalWidth = Math.max(1, Math.round(width * pixelRatio));
+        const physicalHeight = Math.max(1, Math.round(height * pixelRatio));
+        if (physicalWidth > device.limits.maxTextureDimension2D || physicalHeight > device.limits.maxTextureDimension2D)
+            throw new RangeError('Canvas size exceeds this device maxTextureDimension2D');
+        const metrics = Object.freeze({width: physicalWidth, height: physicalHeight,
+            logicalWidth: width, logicalHeight: height, scale: pixelRatio});
+        // Original browser host contract: physical texture dimensions plus a
+        // separate logical extent/DPI. Resizing never recompiles the scene.
+        if (canvas.width !== physicalWidth) canvas.width = physicalWidth;
+        if (canvas.height !== physicalHeight) canvas.height = physicalHeight;
+        module.progpuBrowserMetrics = metrics;
+        return metrics;
+    }
+    function dispose() {
+        if (disposed) return;
+        disposed = true; lifetime.report = null;
+        if (listener && device) device.removeEventListener('uncapturederror', listener);
+        try { if (initialized) { module._progpu_browser_dispose(); initialized = false; } }
+        finally {
+            if (!suppliedDevice && device) device.destroy();
+            if (canvas.getAttribute('data-progpu-renderer') === marker) canvas.removeAttribute('data-progpu-renderer');
+            canvasOwners.delete(canvas); currentScene = null; updateMetrics = null;
+            // Break the retained promise/listener chain without touching a
+            // borrowed device or leaving a live callback into freed wasm state.
+            module = null;
+        }
+    }
+    try {
+        if (!device) {
+            const adapter = await navigator.gpu.requestAdapter({powerPreference: 'high-performance'});
+            if (!adapter) throw new Error('No WebGPU adapter is available');
+            device = await adapter.requestDevice();
+        }
+        if (typeof device.addEventListener !== 'function' || typeof device.queue?.submit !== 'function')
+            throw new TypeError('device must be a GPUDevice');
+        listener = (event) => lifetime.report?.(new Error(`WebGPU: ${event.error.message}`));
+        device.addEventListener('uncapturederror', listener);
+        // The promise captures only the detachable lifetime token, not the
+        // renderer/module/device. A borrowed device may long outlive dispose.
+        device.lost.then(deviceLossCallback(lifetime));
+        const format = navigator.gpu.getPreferredCanvasFormat();
+        if (format !== 'rgba8unorm' && format !== 'bgra8unorm') throw new Error(`Unsupported native canvas format: ${format}`);
+        const {default: factory} = await import('./progpu-native.mjs');
+        module = await factory({canvas, preinitializedWebGPUDevice: device,
+            progpuBrowserCanvasFormat: format});
+        const rect = canvas.getBoundingClientRect();
+        resize({width: Math.max(1, rect.width), height: Math.max(1, rect.height)});
+        check();
+        const selector = new TextEncoder().encode(`canvas[data-progpu-renderer="${marker}"]\0`);
+        errorPointer = module._progpu_browser_error();
+        withBytes(selector, (pointer) => nativeCheck(module._progpu_browser_initialize(pointer)));
+        initialized = true; metricsPointer = module._progpu_browser_metrics();
+        check();
+        return Object.freeze({
+            device,
+            get error() { return failure; },
+            resize,
+            updateScene(scene) {
+                check();
+                const packet = scenePacket(scene);
+                if (!packet && !(scene instanceof Uint8Array)) throw new TypeError('Expected an immutable Scene or full native stream Uint8Array');
+                // A repeated immutable snapshot needs no compilation/crossing.
+                // Do not cache caller-owned raw byte arrays by object identity.
+                if (packet && scene === currentScene) return updateMetrics;
+                const bytes = packet ?? scene;
+                if (bytes.byteLength === 0) throw new RangeError('Scene stream must not be empty');
+                withBytes(bytes, (pointer) => nativeCheck(module._progpu_browser_update(pointer, bytes.byteLength, packet ? 1 : 0)));
+                currentScene = packet ? scene : null;
+                updateMetrics = Object.freeze({sceneId: word(0), generation: word(1), commandCount: count(2),
+                    resourceCount: count(3), streamBytes: count(4), snapshotReused: word(5) !== 0n,
+                    drawCount: count(6), payloadBytes: count(7)});
+                return updateMetrics;
+            },
+            getSceneStream() {
+                check();
+                const size = module._progpu_browser_stream_size();
+                if (!size) throw new Error('Update a scene before exporting its native stream');
+                const pointer = module._progpu_browser_stream();
+                return module.HEAPU8.slice(pointer, pointer + size);
+            },
+            render({clearColor = [0, 0, 0, 0]} = {}) {
+                check();
+                if (!clearColor || clearColor.length !== 4 || Array.from(clearColor).some((v) => typeof v !== 'number' || !Number.isFinite(v) || v < 0 || v > 1))
+                    throw new TypeError('clearColor must contain four finite zero-to-one components');
+                nativeCheck(module._progpu_browser_render(...clearColor));
+                return Object.freeze({commandCount: count(0), drawCallCount: count(1), familySwitchCount: count(2),
+                    submissionCount: word(3), vertexUploadBytes: count(4), indexUploadBytes: count(5),
+                    textureUploadBytes: count(6), uniformUploadBytes: count(7), coverageStagingBytes: count(8),
+                    payloadHash: word(9), brushUploadBytes: count(10), gradientStopUploadBytes: count(11),
+                    textStyleUploadBytes: count(12), colorGlyphUploadBytes: count(13)});
+            },
+            dispose,
+        });
+    } catch (error) { dispose(); throw error; }
+}

package/licenses/emdawnwebgpu/webgpu/src/LICENSE

@@ -0,0 +1,68 @@
+Emscripten is available under 2 licenses, the MIT license and the
+University of Illinois/NCSA Open Source License.
+
+Both are permissive open source licenses, with little if any
+practical difference between them.
+
+The reason for offering both is that (1) the MIT license is
+well-known, while (2) the University of Illinois/NCSA Open Source
+License allows Emscripten's code to be integrated upstream into
+LLVM, which uses that license, should the opportunity arise.
+
+The full text of both licenses follows.
+
+==============================================================================
+
+Copyright (c) 2010-2014 Emscripten authors, see AUTHORS file.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+==============================================================================
+
+Copyright (c) 2010-2014 Emscripten authors, see AUTHORS file.
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal with the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+    Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimers.
+
+    Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimers
+    in the documentation and/or other materials provided with the
+    distribution.
+
+    Neither the names of Mozilla,
+    nor the names of its contributors may be used to endorse
+    or promote products derived from this Software without specific prior
+    written permission.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE SOFTWARE.

package/licenses/emdawnwebgpu/webgpu_cpp/LICENSE

@@ -0,0 +1,26 @@
+// Copyright 2017-2025 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/licenses/emscripten/LICENSE

@@ -0,0 +1,102 @@
+Emscripten is available under 2 licenses, the MIT license and the
+University of Illinois/NCSA Open Source License.
+
+Both are permissive open source licenses, with little if any
+practical difference between them.
+
+The reason for offering both is that (1) the MIT license is
+well-known, while (2) the University of Illinois/NCSA Open Source
+License allows Emscripten's code to be integrated upstream into
+LLVM, which uses that license, should the opportunity arise.
+
+The full text of both licenses follows.
+
+==============================================================================
+
+Copyright (c) 2010-2014 Emscripten authors, see AUTHORS file.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+==============================================================================
+
+Copyright (c) 2010-2014 Emscripten authors, see AUTHORS file.
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal with the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+    Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimers.
+
+    Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimers
+    in the documentation and/or other materials provided with the
+    distribution.
+
+    Neither the names of Mozilla,
+    nor the names of its contributors may be used to endorse
+    or promote products derived from this Software without specific prior
+    written permission. 
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE SOFTWARE.
+
+==============================================================================
+
+This program uses portions of Node.js source code located in src/library_path.js,
+in accordance with the terms of the MIT license. Node's license follows:
+
+    """
+        Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to
+        deal in the Software without restriction, including without limitation the
+        rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+        sell copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+
+        The above copyright notice and this permission notice shall be included in
+        all copies or substantial portions of the Software.
+
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+        FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+        IN THE SOFTWARE.
+    """
+
+The musl libc project is bundled in this repo, and it has the MIT license, see
+system/lib/libc/musl/COPYRIGHT
+
+The third_party/ subdirectory contains code with other licenses. None of it is
+used by default, but certain options use it (e.g., the optional closure compiler
+flag will run closure compiler from third_party/).
+