oria-webgpu 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 cheonghakim
+
+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.ko.md

@@ -0,0 +1,175 @@
+# oria-webgpu
+
+[English](README.md) | **한국어**
+
+그래픽과 컴퓨트를 위한 최소한의, 타입이 명확한 WebGPU 래퍼입니다. "WebGPU용 TWGL"이라고 생각하시면 됩니다.
+
+**[라이브 데모](https://cheonghakim.github.io/oria-webgpu/)**
+
+**이 라이브러리는 렌더링 엔진이 아닙니다.** 씬(scene), 라이팅, 머티리얼, 로더, 애니메이션 시스템이 필요하다면 Three.js나 Babylon.js를 사용하세요.
+
+## 이 라이브러리가 존재하는 이유
+
+WebGPU는 장황하지만 복잡하지는 않습니다. oria-webgpu는 반복되는 부분들 —
+어댑터/디바이스 설정, 버퍼 크기 계산, 파이프라인 디스크립터 보일러플레이트, 렌더 패스
+생명주기 — 을 제거하면서도 모든 네이티브 WebGPU 개념(`GPUDevice`, `GPUBuffer`,
+`GPURenderPipeline` 등)을 보이고 접근 가능하게 유지합니다. 여전히 WebGPU 방식으로
+생각해야 하지만, 코드는 훨씬 적게 씁니다.
+
+## 상태
+
+v0.1 (진행 중). 지금까지 구현된 것: `createGPU`, 버퍼(`storageBuffer` 축약 헬퍼 포함),
+텍스처(ImageBitmap/canvas/VideoFrame로부터의 업로드 및 캔버스 크기에 맞춘 `depthTexture`
+헬퍼 포함), 샘플러, 공유 파이프라인 캐시가 적용된 렌더/컴퓨트 파이프라인, 렌더패스/컴퓨트패스
+빌더, named bind group을 지원하는 WGSL 바인딩 리플렉션, GPU 버퍼 리드백(`gpu.readBuffer`).
+
+실제 WebGPU 브라우저(Chromium, headed 모드 — WebGPU는 실제 GPU 접근이 필요한데, 이
+플랫폼의 headless 모드는 GPU 접근을 허용하지 않습니다)에서 정상 렌더링됨을 확인했습니다:
+정확한 삼각형 geometry, 정확한 정점별 색상 보간, 유니폼으로 구동되는 실시간 회전,
+그리고 동작하는 WebGPU-vs-WebGL2 instanced-draw 비교. 그 전까지는 mock을 사용한
+유닛 테스트 로직만 검증되어 있었고, 아직 이를 실행하는 CI/Playwright 스위트는 없습니다
+(Limitations 참고).
+
+## 데모
+
+**[cheonghakim.github.io/oria-webgpu](https://cheonghakim.github.io/oria-webgpu/)** — 또는 로컬에서 실행:
+
+```bash
+npm install
+npm run demo
+```
+
+두 개의 탭으로 구성됩니다: **Usage** — 실제로 실행 중인 oria-webgpu 코드가 옆에 그대로
+표시되는(패널 자체가 그 함수의 소스 코드이므로, 실제 실행되는 코드와 어긋날 수 없습니다)
+작은 회전 삼각형 — 그리고 **WebGPU vs WebGL** — 동일한 per-instance 움직임을 두 API로
+나란히 렌더링하며 실시간 fps와 CPU submit 시간을 보여줍니다. [examples/demo](examples/demo)
+참고.
+
+instance 개수가 적을 때는 양쪽 다 디스플레이의 vsync fps에 그냥 걸려 있을 뿐입니다 —
+이건 "차이가 없다"는 뜻이 아니라, 유의미한 결과를 낼 만큼 부하가 크지 않다는 뜻입니다.
+약 150,000개 이상에서는 프래그먼트당 셰이더 작업이 실제로 vsync를 넘어설 만큼 무거워지고,
+이 지점에서는 두 API가 사실상 동일한 fps를 보입니다: 단일 steady-state instanced draw call은
+성숙한 WebGL2 드라이버에서 이미 거의 최적화되어 있어서, 이 워크로드는 WebGPU의 진짜
+장점(많은 draw call/상태 변경, 컴퓨트, 낮은 드라이버 오버헤드)이 드러나는 지점이 아닙니다.
+
+## 빠른 시작
+
+```bash
+npm install oria-webgpu
+```
+
+```ts
+import { createGPU } from "oria-webgpu"
+
+const gpu = await createGPU(canvas)
+
+const pipeline = gpu.renderPipeline({
+  vertex: { code: shaderWGSL, entryPoint: "vsMain" },
+  fragment: { code: shaderWGSL, entryPoint: "fsMain", targets: [gpu.format] },
+})
+
+gpu.render((pass) => {
+  pass.pipeline(pipeline).draw(3)
+})
+```
+
+또는 이 저장소를 클론해서 예제를 바로 실행할 수도 있습니다. 별도 프로젝트가 필요 없습니다:
+
+```bash
+npm install
+npm run example:triangle
+```
+
+## 바인딩
+
+이름이 붙은 리소스는 셰이더의 `@group`/`@binding` 선언을 훑는 작은 WGSL 리플렉션
+과정을 통해 bind group으로 해석됩니다 — 일반적인 경우라면 수동으로
+`GPUBindGroupLayout`/`GPUBindGroup`을 만들 필요가 없습니다:
+
+```ts
+const pipeline = gpu.renderPipeline({
+  vertex: { code: shaderWGSL, entryPoint: "vsMain" },
+  fragment: { code: shaderWGSL, entryPoint: "fsMain", targets: [gpu.format] },
+  bindings: {
+    camera: cameraBuffer, // `@group(0) @binding(0) var<uniform> camera: Camera;` 와 매칭
+  },
+})
+
+// 바인딩은 나중에 다시 (재)해석하거나, 패스 단위로도 지정할 수 있습니다:
+pipeline.bindings({ camera: cameraBuffer })
+gpu.render((pass) => {
+  pass.pipeline(pipeline).bindings({ camera: cameraBuffer }).draw(3)
+})
+```
+
+`@group`은 선언된 모든 바인딩이 채워졌을 때만 빌드됩니다 — 한 번에 모두 넘기거나,
+여러 번에 걸쳐 점진적으로 넘겨도 됩니다. 이것은 작고 예측 가능한 파서이며(`reflectWGSLBindings`
+참고) 완전한 WGSL 문법 분석기가 아닙니다. 확신 있게 분류할 수 없는 선언은 그냥 건너뜁니다.
+언제든 네이티브 `device.createBindGroup(...)`과 `pass.raw.setBindGroup(...)`으로
+직접 내려갈 수 있습니다.
+
+## 파이프라인은 캐싱됩니다
+
+`gpu.renderPipeline(...)`/`gpu.computePipeline(...)`은 서로 다른 디스크립터별로
+캐싱됩니다 — 동일한 셰이더 소스, entry point, vertex layout, target, format으로
+다시 호출하면 WebGPU에게 다시 컴파일을 요청하는 대신 *동일한* 파이프라인 객체를
+반환합니다. `bindings`는 이 identity에 포함되지 않습니다(캐시 hit이든 miss든 매
+호출마다 다시 해석·적용되므로), 그래서 매 프레임 새로운 바인딩 리소스로
+`gpu.renderPipeline({...})`을 호출하는 것이 정상적인 패턴입니다. 강제로 다시
+빌드해야 한다면 `gpu.clearPipelineCache()`를 호출하세요.
+
+## 컴퓨트 리드백
+
+```ts
+const particles = gpu.storageBuffer({ data }) // 기본값: STORAGE | COPY_DST | COPY_SRC
+
+gpu.compute((pass) => {
+  pass.pipeline(pipeline).bindings({ particles }).dispatch(particles.size / 4 / 64)
+})
+
+const result = await gpu.readBuffer(particles, Float32Array)
+```
+
+`readBuffer`는 버퍼를 staging 버퍼로 복사하고, 매핑한 뒤, 데이터를 복사해내고,
+staging 버퍼를 정리합니다. 소스 버퍼는 `COPY_SRC` usage가 필요합니다
+(`storageBuffer()`는 기본으로 포함합니다).
+
+## 탈출구 (Escape hatches)
+
+래핑된 모든 객체는 자신의 네이티브 WebGPU 대응물을 그대로 노출합니다:
+
+```ts
+gpu.device        // GPUDevice
+gpu.context       // GPUCanvasContext
+buffer.raw        // GPUBuffer
+pipeline.raw      // GPURenderPipeline
+pass.raw          // GPURenderPassEncoder (gpu.render 콜백 내부)
+
+gpu.command((encoder) => {
+  // 완전한 네이티브 WebGPU 커맨드 인코더
+})
+```
+
+## 한계 (v0.1)
+
+- `gpu.render()`는 아직 멀티샘플 resolve target을 지원하지 않습니다 — 파이프라인의
+  `multisample` 옵션은 노출되어 있지만, 패스 헬퍼에 멀티샘플 attachment + resolve
+  target을 넘길 방법이 없어서 이 헬퍼를 통해서는 MSAA를 실제로 사용할 수 없습니다
+  (완전히 수동으로 구성하는 `gpu.command()` 탈출구를 통해서만 가능). 데모를 만들면서
+  발견했습니다: WebGL2 캔버스는 기본값이 `antialias: true`라서, 그대로 두면 WebGPU는
+  받지 못하는 공짜 MSAA 스무딩을 WebGL만 조용히 받게 되어 불공정한 비교가 됩니다 —
+  `antialias: false`를 명시해서 맞춰줬습니다.
+- WGSL 리플렉션은 완전한 문법 분석기가 아니라 작은 패턴 기반 파서입니다 — 정확히 무엇을
+  인식하는지는 [src/shader/reflection.ts](src/shader/reflection.ts)를 참고하세요.
+- 선언된 바인딩을 전부 채우지 못한 `@group`은 bind group을 만들어내지 않습니다;
+  이는 Oria가 아니라 WebGPU 자체의 검증(validation)이 draw/dispatch 시점에 보고합니다.
+- `depthTexture()`는 호출 시점의 캔버스 크기를 스냅샷으로 찍습니다 — 캔버스 크기를
+  따라가게 하려면 `gpu.resize()` 이후 다시 호출하세요(암묵적인 auto-resize는 없습니다).
+- 아직 indexed-cube/texture/particles 예제나 Playwright 통합 테스트는 없습니다.
+- `storageBuffer()`/`buffer()`는 상향된 limit을 요청하지 않으므로, *기본값*
+  `maxStorageBufferBindingSize`(128 MiB)나 `maxBufferSize`(256 MiB)를 넘는 버퍼는
+  검증에 실패합니다 — 이는 에러를 던지는 게 아니라 콘솔 warning으로만 나타나므로
+  놓치기 쉽습니다. 더 큰 버퍼가 필요하다면 `createGPU(...)`에 `requiredLimits`를
+  넘기세요(먼저 `adapter.limits`로 확인해야 합니다).
+
+이 항목들은 다음 단계들에서 채워질 예정입니다 — 전체 로드맵은 개발 계획을 참고하세요.

package/README.md

@@ -0,0 +1,179 @@
+# oria-webgpu
+
+**English** | [한국어](README.ko.md)
+
+A minimal, typed WebGPU wrapper for graphics and compute. Think "TWGL for WebGPU."
+
+**[Live demo](https://cheonghakim.github.io/oria-webgpu/)**
+
+**This library is not a rendering engine.** If you need scenes, lighting, materials,
+loaders, or animation systems, use Three.js or Babylon.js instead.
+
+## Why this library exists
+
+WebGPU is verbose but not complicated. oria-webgpu removes the repetitive parts —
+adapter/device setup, buffer sizing, pipeline descriptor boilerplate, render-pass
+lifecycle — while keeping every native WebGPU concept (`GPUDevice`, `GPUBuffer`,
+`GPURenderPipeline`, ...) visible and reachable. You should still think in WebGPU
+terms; you just write less of it.
+
+## Status
+
+v0.1 (in progress). Implemented so far: `createGPU`, buffers (including a
+`storageBuffer` shorthand), textures (including upload from
+ImageBitmap/canvas/VideoFrame and a canvas-sized `depthTexture` helper),
+samplers, render pipelines, compute pipelines with a shared pipeline cache,
+the render-pass/compute-pass builders, WGSL binding reflection with named bind
+groups, and GPU buffer readback (`gpu.readBuffer`).
+
+Verified rendering correctly in a real WebGPU browser (Chromium, headed —
+WebGPU needs actual GPU access, which headless mode on this platform doesn't
+grant): correct triangle geometry, correct per-vertex color interpolation, a
+live uniform-driven rotation, and a working WebGPU-vs-WebGL2 instanced-draw
+comparison. Only unit-tested logic had been checked before that; there is no
+CI/Playwright suite running this yet (see Limitations).
+
+## Demo
+
+**[cheonghakim.github.io/oria-webgpu](https://cheonghakim.github.io/oria-webgpu/)** — or run it locally:
+
+```bash
+npm install
+npm run demo
+```
+
+Two tabs: **Usage** — a small rotating triangle with the exact running
+oria-webgpu code shown alongside it (the panel is that function's own source, so
+it can't drift from what's actually executing) — and **WebGPU vs WebGL** — the
+same per-instance motion rendered by both APIs side by side, with live fps and
+CPU submit-time readouts. See [examples/demo](examples/demo).
+
+At low instance counts both sides just idle at the display's vsync fps — that's
+not "no difference," it's not enough load to mean anything. Above ~150,000
+instances the per-fragment shader work is heavy enough to genuinely exceed
+vsync, and at that point both APIs land at essentially the same fps: a single
+steady-state instanced draw call is already near-optimal on a mature WebGL2
+driver, so this particular workload isn't where WebGPU's real advantages (many
+draw calls / state changes, compute, lower driver overhead) would show up.
+
+## Quick start
+
+```bash
+npm install oria-webgpu
+```
+
+```ts
+import { createGPU } from "oria-webgpu"
+
+const gpu = await createGPU(canvas)
+
+const pipeline = gpu.renderPipeline({
+  vertex: { code: shaderWGSL, entryPoint: "vsMain" },
+  fragment: { code: shaderWGSL, entryPoint: "fsMain", targets: [gpu.format] },
+})
+
+gpu.render((pass) => {
+  pass.pipeline(pipeline).draw(3)
+})
+```
+
+Or clone this repo and run the examples directly, no separate project needed:
+
+```bash
+npm install
+npm run example:triangle
+```
+
+## Bindings
+
+Named resources are resolved to bind groups using a small WGSL reflection pass
+over your shader's `@group`/`@binding` declarations — no manual
+`GPUBindGroupLayout`/`GPUBindGroup` wiring for the common case:
+
+```ts
+const pipeline = gpu.renderPipeline({
+  vertex: { code: shaderWGSL, entryPoint: "vsMain" },
+  fragment: { code: shaderWGSL, entryPoint: "fsMain", targets: [gpu.format] },
+  bindings: {
+    camera: cameraBuffer, // matches `@group(0) @binding(0) var<uniform> camera: Camera;`
+  },
+})
+
+// Bindings can also be (re)resolved later, or per-pass:
+pipeline.bindings({ camera: cameraBuffer })
+gpu.render((pass) => {
+  pass.pipeline(pipeline).bindings({ camera: cameraBuffer }).draw(3)
+})
+```
+
+A `@group` is only built once every binding it declares has been supplied — set
+them together, or incrementally across calls. This is a small, predictable
+parser (see `reflectWGSLBindings`), not a full WGSL grammar; anything it can't
+confidently classify is skipped. You can always fall back to a native
+`device.createBindGroup(...)` and `pass.raw.setBindGroup(...)`.
+
+## Pipelines are cached
+
+`gpu.renderPipeline(...)`/`gpu.computePipeline(...)` are cached per distinct
+descriptor — calling them again with the same shader source, entry points,
+vertex layout, targets, and format returns the *same* pipeline object rather
+than asking WebGPU to recompile it. `bindings` isn't part of that identity (it's
+resolved and reapplied on every call, cache hit or miss), so it's normal to call
+`gpu.renderPipeline({...})` every frame with fresh binding resources. Call
+`gpu.clearPipelineCache()` if you need to force a rebuild.
+
+## Compute readback
+
+```ts
+const particles = gpu.storageBuffer({ data }) // STORAGE | COPY_DST | COPY_SRC by default
+
+gpu.compute((pass) => {
+  pass.pipeline(pipeline).bindings({ particles }).dispatch(particles.size / 4 / 64)
+})
+
+const result = await gpu.readBuffer(particles, Float32Array)
+```
+
+`readBuffer` copies the buffer into a staging buffer, maps it, copies the data
+out, and cleans the staging buffer up. The source buffer needs `COPY_SRC` usage
+(`storageBuffer()` includes it by default).
+
+## Escape hatches
+
+Every wrapped object exposes its native WebGPU counterpart:
+
+```ts
+gpu.device        // GPUDevice
+gpu.context       // GPUCanvasContext
+buffer.raw        // GPUBuffer
+pipeline.raw      // GPURenderPipeline
+pass.raw          // GPURenderPassEncoder (inside gpu.render callbacks)
+
+gpu.command((encoder) => {
+  // full native WebGPU command encoder
+})
+```
+
+## Limitations (v0.1)
+
+- `gpu.render()` doesn't support a multisample resolve target yet — a pipeline's
+  `multisample` option is exposed, but there's no way to give the pass helper a
+  multisampled attachment + resolve target, so MSAA isn't actually reachable
+  through it (only via the `gpu.command()` escape hatch, built fully by hand).
+  Found via the demo: WebGL2's canvas defaults to `antialias: true`, so an
+  unfair comparison would silently give WebGL free MSAA smoothing that WebGPU
+  wasn't also getting — fixed there by passing `antialias: false` to match.
+- WGSL reflection is a small pattern-based parser, not a full grammar — see
+  [src/shader/reflection.ts](src/shader/reflection.ts) for exactly what it recognizes.
+- A `@group` that never gets all of its declared bindings produces no bind group;
+  WebGPU's own validation (not Oria's) reports that at draw/dispatch time.
+- `depthTexture()` snapshots the canvas's current size — call it again after
+  `gpu.resize()` if you need it to track the canvas (no implicit auto-resize).
+- No indexed-cube/texture/particles examples or Playwright integration tests yet.
+- `storageBuffer()`/`buffer()` don't request elevated limits, so a buffer past
+  the *default* `maxStorageBufferBindingSize` (128 MiB) or `maxBufferSize`
+  (256 MiB) fails validation — as a warning in the console, not a thrown error,
+  so it's easy to miss. Pass `requiredLimits` to `createGPU(...)` (checked
+  against `adapter.limits` first) if you need larger buffers.
+
+These land in subsequent phases — see the development plan for the full roadmap.

package/dist/binding/bind-group-layout.d.ts

@@ -0,0 +1,6 @@
+import type { BindingReflection } from "../shader/reflection";
+/** Groups flat reflection results by their @group index. */
+export declare function groupByGroupIndex(reflection: BindingReflection[]): Map<number, BindingReflection[]>;
+/** Merges reflection from multiple shader stages (e.g. vertex + fragment) by name. */
+export declare function mergeReflection(...stages: BindingReflection[][]): BindingReflection[];
+//# sourceMappingURL=bind-group-layout.d.ts.map

package/dist/binding/bind-group-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind-group-layout.d.ts","sourceRoot":"","sources":["../../src/binding/bind-group-layout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAE7D,4DAA4D;AAC5D,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,iBAAiB,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAQnG;AAED,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,GAAG,MAAM,EAAE,iBAAiB,EAAE,EAAE,GAAG,iBAAiB,EAAE,CAQrF"}

package/dist/binding/bind-group.d.ts

@@ -0,0 +1,26 @@
+import type { BindingReflection } from "../shader/reflection";
+import type { BindingResource } from "../types/public";
+/**
+ * Resolves named resources to GPUBindGroups for one pipeline, using its WGSL
+ * reflection and the pipeline's own auto-generated bind group layouts.
+ *
+ * State accumulates across calls: setting `camera` now and `texSampler`/`tex`
+ * later keeps `camera` in that @group's bind group. A group is only (re)built
+ * once every binding it declares has been supplied at least once; until then
+ * `apply()` just caches what it was given and waits. A group that never gets
+ * completed produces no entry in `boundGroups` — WebGPU's own validation will
+ * report a missing bind group if you draw/dispatch with the pipeline anyway.
+ */
+export declare class BindGroupResolver {
+    private readonly device;
+    private readonly getBindGroupLayout;
+    private readonly byName;
+    private readonly byGroup;
+    private readonly resourceCache;
+    private readonly groupCache;
+    constructor(device: GPUDevice, getBindGroupLayout: (group: number) => GPUBindGroupLayout, reflection: BindingReflection[]);
+    get boundGroups(): ReadonlyMap<number, GPUBindGroup>;
+    apply(namedResources: Record<string, BindingResource>): void;
+    private buildGroup;
+}
+//# sourceMappingURL=bind-group.d.ts.map

package/dist/binding/bind-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind-group.d.ts","sourceRoot":"","sources":["../../src/binding/bind-group.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAoB,MAAM,sBAAsB,CAAA;AAC/E,OAAO,KAAK,EAAE,eAAe,EAAsD,MAAM,iBAAiB,CAAA;AAyG1G;;;;;;;;;;GAUG;AACH,qBAAa,iBAAiB;IAO1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IAPrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;IACvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAC1D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqC;IACnE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAkC;gBAG1C,MAAM,EAAE,SAAS,EACjB,kBAAkB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,kBAAkB,EAC1E,UAAU,EAAE,iBAAiB,EAAE;IAMjC,IAAI,WAAW,IAAI,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAEnD;IAED,KAAK,CAAC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GAAG,IAAI;IAgB5D,OAAO,CAAC,UAAU;CAcnB"}

package/dist/commands/command-encoder.d.ts

@@ -0,0 +1,3 @@
+/** Creates a command encoder, runs `fn` against it, and submits the result. */
+export declare function withCommandEncoder(device: GPUDevice, label: string | undefined, fn: (encoder: GPUCommandEncoder) => void): void;
+//# sourceMappingURL=command-encoder.d.ts.map

package/dist/commands/command-encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-encoder.d.ts","sourceRoot":"","sources":["../../src/commands/command-encoder.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,EAAE,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,IAAI,GACvC,IAAI,CAIN"}

package/dist/core/context.d.ts

@@ -0,0 +1,8 @@
+import type { CreateGPUOptions } from "../types/public";
+export interface ConfiguredContext {
+    context: GPUCanvasContext;
+    format: GPUTextureFormat;
+}
+export declare function configureCanvasContext(canvas: HTMLCanvasElement, device: GPUDevice, options: CreateGPUOptions): ConfiguredContext;
+export declare function resizeCanvas(canvas: HTMLCanvasElement, width?: number, height?: number, pixelRatio?: number): void;
+//# sourceMappingURL=context.d.ts.map

package/dist/core/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/core/context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAEvD,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,gBAAgB,CAAA;IACzB,MAAM,EAAE,gBAAgB,CAAA;CACzB;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,iBAAiB,EACzB,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,gBAAgB,GACxB,iBAAiB,CAkBnB;AAED,wBAAgB,YAAY,CAC1B,MAAM,EAAE,iBAAiB,EACzB,KAAK,CAAC,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,MAAM,EACf,UAAU,SAA8D,GACvE,IAAI,CAKN"}

package/dist/core/device.d.ts

@@ -0,0 +1,7 @@
+import type { CreateGPUOptions } from "../types/public";
+export interface RequestedDevice {
+    adapter: GPUAdapter;
+    device: GPUDevice;
+}
+export declare function requestDevice(options: CreateGPUOptions): Promise<RequestedDevice>;
+//# sourceMappingURL=device.d.ts.map

package/dist/core/device.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device.d.ts","sourceRoot":"","sources":["../../src/core/device.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAEvD,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,UAAU,CAAA;IACnB,MAAM,EAAE,SAAS,CAAA;CAClB;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,CAoCvF"}

package/dist/core/gpu.d.ts

@@ -0,0 +1,3 @@
+import type { CreateGPUOptions, GPUContext } from "../types/public";
+export declare function createGPU(canvas: HTMLCanvasElement, options?: CreateGPUOptions): Promise<GPUContext>;
+//# sourceMappingURL=gpu.d.ts.map

package/dist/core/gpu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu.d.ts","sourceRoot":"","sources":["../../src/core/gpu.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAMV,gBAAgB,EAEhB,UAAU,EAWX,MAAM,iBAAiB,CAAA;AA2KxB,wBAAsB,SAAS,CAC7B,MAAM,EAAE,iBAAiB,EACzB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,UAAU,CAAC,CAOrB"}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { createGPU } from "./core/gpu";
+export { OriaError } from "./utils/validation";
+export { alignTo, alignBufferSize } from "./utils/alignment";
+export { reflectWGSLBindings } from "./shader/reflection";
+export type { BindingResource, Buffer, BufferDescriptor, ComputePassBuilder, ComputePipeline, ComputePipelineDescriptor, CreateGPUOptions, DepthTextureDescriptor, FragmentState, GPUContext, RenderPassBuilder, RenderPipeline, RenderPipelineDescriptor, RenderTargetOptions, ResizeOptions, StorageBufferDescriptor, Texture, TextureDescriptor, TextureFromSourceDescriptor, TextureSource, TypedArrayConstructor, VertexState, } from "./types/public";
+export type { BindingReflection, ResourceCategory } from "./shader/reflection";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAEzD,YAAY,EACV,eAAe,EACf,MAAM,EACN,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,yBAAyB,EACzB,gBAAgB,EAChB,sBAAsB,EACtB,aAAa,EACb,UAAU,EACV,iBAAiB,EACjB,cAAc,EACd,wBAAwB,EACxB,mBAAmB,EACnB,aAAa,EACb,uBAAuB,EACvB,OAAO,EACP,iBAAiB,EACjB,2BAA2B,EAC3B,aAAa,EACb,qBAAqB,EACrB,WAAW,GACZ,MAAM,gBAAgB,CAAA;AAEvB,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA"}