@haiyue/extensions 0.1.0 → 0.2.0

package/dist/ray-tracing/sampling/revision.d.ts

@@ -0,0 +1,15 @@
+import type { RayAccelerationSnapshot } from '../acceleration/index.js';
+import type { RayPackedMaterialScene } from '../material/index.js';
+import type { RayPathSceneFacts } from '../renderer/index.js';
+import type { RayProgressiveAccumulationKey, RayProgressiveFrameRevision, RayProgressiveResetReason } from './types.js';
+export declare function createRayProgressiveFrameRevision(acceleration: RayAccelerationSnapshot, materials: RayPackedMaterialScene, facts: RayPathSceneFacts): RayProgressiveFrameRevision;
+export declare function createRayProgressiveAccumulationKey(revision: RayProgressiveFrameRevision, viewport: Readonly<{
+    width: number;
+    height: number;
+}>, quality: Readonly<{
+    revision: string;
+    maxBounces: number;
+}>, sampling: Readonly<{
+    baseSeed: number;
+}>, denoiseRevision: string): RayProgressiveAccumulationKey;
+export declare function classifyRayProgressiveReset(previous: RayProgressiveAccumulationKey | null, next: RayProgressiveAccumulationKey, pending?: ReadonlySet<RayProgressiveResetReason>): readonly RayProgressiveResetReason[];

package/dist/ray-tracing/sampling/runtime.d.ts

@@ -0,0 +1,44 @@
+import type { RaySpatialTemporalDenoiser } from '../denoise/index.js';
+import type { RayPathTracingRenderer } from '../renderer/index.js';
+import type { RayProgressiveCreateResult, RayProgressiveFrame, RayProgressiveOptions, RayProgressiveRenderResult, RayProgressiveResetReason } from './types.js';
+export declare class RayProgressiveRenderer {
+    readonly artifactHash: "68dbd34a27343815b6b1af275d7909c28b21bd0558b9a0aea6bc8cd54c5bc060";
+    private readonly _device;
+    private _baseRenderer;
+    private _denoiser;
+    private _layouts;
+    private _accumulatePipeline;
+    private _presentPipeline;
+    private _accumulation;
+    private _moments;
+    private _feature;
+    private _age;
+    private _output;
+    private _width;
+    private _height;
+    private _sampleCount;
+    private _resetCount;
+    private _key;
+    private _lastReset;
+    private readonly _pendingReasons;
+    private _generation;
+    private _rendering;
+    private _destroyed;
+    private _lostMessage;
+    private readonly _uncapturedErrors;
+    private readonly _uncapturedHandler;
+    private constructor();
+    static create(device: GPUDevice, baseRenderer: RayPathTracingRenderer, denoiser?: RaySpatialTemporalDenoiser | null): Promise<RayProgressiveCreateResult>;
+    get destroyed(): boolean;
+    get sampleCount(): number;
+    get outputTexture(): GPUTexture | null;
+    get liveResourceCount(): number;
+    reset(reason?: RayProgressiveResetReason): void;
+    replaceBaseRenderer(renderer: RayPathTracingRenderer): void;
+    setDenoiser(denoiser: RaySpatialTemporalDenoiser | null): void;
+    render(frame: RayProgressiveFrame, options: RayProgressiveOptions): Promise<RayProgressiveRenderResult>;
+    destroy(): void;
+    private resize;
+    private destroyTextures;
+    private memory;
+}

package/dist/ray-tracing/sampling/sequence.d.ts

@@ -0,0 +1,2 @@
+import { type RayProgressiveSequenceSample } from './types.js';
+export declare function createRayProgressiveSequenceSample(sampleIndex: number, baseSeed: number): RayProgressiveSequenceSample;

package/dist/ray-tracing/sampling/types.d.ts

@@ -0,0 +1,96 @@
+import type { RayPathDiagnostic, RayPathDiagnosticPhase, RayPathSceneFacts, RayToneMapping } from '../renderer/index.js';
+export declare const RAY_PROGRESSIVE_SEQUENCE_ID: "haiyue-halton23-cranley-pcg32-v1";
+export declare const RAY_ACCUMULATION_FORMAT: "rgba16float";
+export interface RayProgressiveDiagnostic extends Omit<RayPathDiagnostic, 'phase'> {
+    readonly phase: RayPathDiagnosticPhase | 'sampling' | 'accumulation' | 'denoise' | 'present';
+}
+export type RayProgressiveView = 'raw' | 'denoised' | 'variance' | 'history-age' | 'feature';
+export type RayProgressiveResetReason = 'initial' | 'explicit' | 'scene-owner' | 'geometry' | 'membership' | 'transform' | 'material' | 'camera' | 'light' | 'viewport' | 'quality' | 'sampling' | 'denoise' | 'renderer' | 'device';
+export interface RayProgressiveSequenceSample {
+    readonly sequenceId: typeof RAY_PROGRESSIVE_SEQUENCE_ID;
+    readonly sampleIndex: number;
+    readonly baseSeed: number;
+    readonly pathSeed: number;
+    readonly jitter: readonly [number, number];
+}
+/** Read-only revisions derived from the canonical acceleration, material and scene facts. */
+export interface RayProgressiveFrameRevision {
+    readonly sceneOwner: string;
+    readonly acceleration: string;
+    readonly geometry: string;
+    readonly membership: string;
+    readonly transform: string;
+    readonly material: string;
+    readonly camera: string;
+    readonly light: string;
+}
+export interface RayProgressiveFrame {
+    readonly facts: RayPathSceneFacts;
+    readonly revision: RayProgressiveFrameRevision;
+}
+export interface RayProgressiveAccumulationKey extends RayProgressiveFrameRevision {
+    readonly viewport: string;
+    readonly quality: string;
+    readonly sampling: string;
+    readonly denoise: string;
+}
+export interface RayProgressiveOptions {
+    readonly width: number;
+    readonly height: number;
+    readonly baseSeed?: number;
+    readonly maxBounces?: number;
+    readonly qualityRevision?: string;
+    readonly exposure?: number;
+    readonly toneMapping?: RayToneMapping;
+    readonly view?: RayProgressiveView;
+    readonly readback?: boolean;
+}
+export interface RayProgressiveResetEvent {
+    readonly resetIndex: number;
+    readonly reasons: readonly RayProgressiveResetReason[];
+    readonly previousSampleCount: number;
+    readonly revision: string;
+}
+export interface RayProgressiveStageTiming {
+    readonly samplingNs: number | null;
+    readonly accumulationNs: number | null;
+    readonly denoiseTemporalNs: number | null;
+    readonly denoiseSpatialNs: number | null;
+    readonly presentNs: number | null;
+    readonly kind: 'timestamp-query' | 'unavailable';
+}
+export interface RayProgressiveMemory {
+    readonly historyBytes: number;
+    readonly denoiseScratchBytes: number;
+    readonly readbackBytes: number;
+    readonly peakBytes: number;
+    readonly liveResourceCount: number;
+}
+export interface RayProgressiveStatistics {
+    readonly sampleIndex: number;
+    readonly sampleCount: number;
+    readonly historyAge: number;
+    readonly resetCount: number;
+    readonly lastReset: RayProgressiveResetEvent | null;
+    readonly varianceMean: number;
+    readonly varianceMax: number;
+    readonly varianceSampleCount: number;
+    readonly sequence: RayProgressiveSequenceSample;
+}
+export interface RayProgressiveRenderResult {
+    readonly status: 'ok' | 'failed';
+    readonly width: number;
+    readonly height: number;
+    readonly revision: string;
+    readonly view: RayProgressiveView;
+    readonly outputTexture: GPUTexture | null;
+    readonly pixels: Uint8Array | null;
+    readonly statistics: RayProgressiveStatistics;
+    readonly timing: RayProgressiveStageTiming;
+    readonly memory: RayProgressiveMemory;
+    readonly diagnostics: readonly RayProgressiveDiagnostic[];
+}
+export interface RayProgressiveCreateResult {
+    readonly renderer: import('./runtime.js').RayProgressiveRenderer | null;
+    readonly diagnostics: readonly RayProgressiveDiagnostic[];
+}

package/dist/ray-tracing/scene/index.d.ts

@@ -0,0 +1,41 @@
+import type { World } from '@haiyue/engine/ecs';
+import type { Scene } from '@haiyue/engine/scene';
+import type { RayDiagnostic, RayReferenceScene } from '../reference/index.js';
+export interface RaySceneSourceRevision {
+    readonly worldId: number;
+    readonly structureVersion: number;
+    readonly componentChangeRevision: number;
+}
+export interface RaySceneMaterialFacts {
+    readonly materialId: string;
+    readonly revision: number;
+    readonly type: string;
+}
+export interface RaySceneInstanceProvenance {
+    readonly instanceId: string;
+    readonly entityId: string;
+    readonly meshComponentId: number;
+    readonly hierarchyVersion: number;
+    readonly transformLocalVersion: number;
+    readonly material: RaySceneMaterialFacts;
+}
+export interface RaySceneSnapshot extends RayReferenceScene {
+    readonly schemaVersion: 1;
+    readonly sourceRevision: RaySceneSourceRevision;
+    readonly revision: string;
+    readonly fingerprint: string;
+    readonly provenance: readonly RaySceneInstanceProvenance[];
+    readonly diagnostics: readonly RayDiagnostic[];
+}
+export interface RaySceneExtractionResult {
+    readonly snapshot: RaySceneSnapshot;
+    readonly diagnostics: readonly RayDiagnostic[];
+    readonly valid: boolean;
+}
+/**
+ * Copies public Engine facts into a resource-free immutable snapshot.
+ * The extractor never calls Transform3D.updateWorldMatrix and never writes to source objects.
+ */
+export declare function extractRayTracingScene(source: Scene | World): RaySceneExtractionResult;
+/** Cheap source revision check; fingerprint comparison remains authoritative after unversioned raw-array mutation. */
+export declare function hasRaySceneSourceRevisionChanged(snapshot: RaySceneSnapshot, source: Scene | World): boolean;

package/dist/ray-tracing/traversal/index.d.ts

@@ -0,0 +1,4 @@
+export { RayTraversalRuntime } from './runtime.js';
+export { createRayTraversalDispatchPlan } from './plan.js';
+export { RAY_TRAVERSAL_LAYOUT } from './layout.js';
+export type { RayTraversalCounters, RayTraversalCreateResult, RayTraversalDiagnostic, RayTraversalDispatchPlan, RayTraversalDispatchPlanPass, RayTraversalExecuteOptions, RayTraversalHit, RayTraversalInput, RayTraversalMemory, RayTraversalMode, RayTraversalResult, } from './types.js';

package/dist/ray-tracing/traversal/layout.d.ts

@@ -0,0 +1,16 @@
+export declare const RAY_TRAVERSAL_LAYOUT: Readonly<{
+    artifactFormat: "haiyue-precompiled-shader-artifact";
+    artifactVersion: 2;
+    artifactHash: "3c7d275ae06d1510db7b454d2dc93cae66d5ef453371e252706d1b69fb281a9a";
+    compilerVersion: "shader-language-ray-traversal-v1";
+    passId: "ray-traversal";
+    workgroupSize: 64;
+    rayStride: 32;
+    hitStride: 96;
+    diagnosticSize: 32;
+    parameterSize: 32;
+    stackCapacity: 64;
+    requiredStorageBuffersPerShaderStage: 8;
+    requiredBindingsPerBindGroup: 9;
+}>;
+export declare function createRayTraversalBindGroupLayout(device: GPUDevice): GPUBindGroupLayout;

package/dist/ray-tracing/traversal/plan.d.ts

@@ -0,0 +1,2 @@
+import type { RayTraversalDispatchPlan } from './types.js';
+export declare function createRayTraversalDispatchPlan(rayCount: number, maxRaysPerDispatch: number): RayTraversalDispatchPlan;

package/dist/ray-tracing/traversal/runtime.d.ts

@@ -0,0 +1,25 @@
+import type { RayPackedAcceleration } from '../acceleration/index.js';
+import type { RayInput } from '../reference/index.js';
+import type { RayTraversalCreateResult, RayTraversalExecuteOptions, RayTraversalResult } from './types.js';
+export declare class RayTraversalRuntime {
+    readonly artifactHash: "3c7d275ae06d1510db7b454d2dc93cae66d5ef453371e252706d1b69fb281a9a";
+    readonly accelerationFingerprint: string;
+    private readonly _device;
+    private readonly _packed;
+    private readonly _buffers;
+    private _bindGroupLayout;
+    private _pipeline;
+    private _destroyed;
+    private _executing;
+    private _generation;
+    private _lostMessage;
+    private readonly _uncapturedErrors;
+    private readonly _uncapturedHandler;
+    private constructor();
+    static create(device: GPUDevice, packed: RayPackedAcceleration): Promise<RayTraversalCreateResult>;
+    get destroyed(): boolean;
+    get liveResourceCount(): number;
+    execute(inputs: readonly RayInput[], options?: RayTraversalExecuteOptions): Promise<RayTraversalResult>;
+    destroy(): void;
+    private _staticBytes;
+}

package/dist/ray-tracing/traversal/types.d.ts

@@ -0,0 +1,79 @@
+import type { RayInput, RayVec3 } from '../reference/index.js';
+export type RayTraversalMode = 'closest-hit' | 'any-hit';
+export type RayTraversalPhase = 'shader' | 'upload' | 'traversal' | 'readback' | 'lifecycle';
+export type RayTraversalSeverity = 'info' | 'warning' | 'error';
+export interface RayTraversalDiagnostic {
+    readonly phase: RayTraversalPhase;
+    readonly severity: RayTraversalSeverity;
+    readonly code: string;
+    readonly message: string;
+    readonly context: Readonly<Record<string, string | number | boolean | null>>;
+}
+export interface RayTraversalHit {
+    readonly primitiveKind: 'triangle' | 'sphere';
+    readonly instanceIdentityIndex: number;
+    readonly instanceIdentity: string;
+    readonly geometryIdentityIndex: number;
+    readonly geometryIdentity: string;
+    readonly primitiveIndex: number;
+    readonly t: number;
+    readonly position: RayVec3;
+    readonly barycentric: RayVec3 | null;
+    readonly frontFace: boolean;
+    readonly geometricNormal: RayVec3;
+    readonly shadingNormal: RayVec3;
+    readonly facingNormal: RayVec3;
+}
+export interface RayTraversalCounters {
+    readonly rays: number;
+    readonly tlasNodeTests: number;
+    readonly blasNodeTests: number;
+    readonly primitiveTests: number;
+    readonly hits: number;
+    readonly misses: number;
+    readonly stackOverflows: number;
+    readonly invalidAccesses: number;
+}
+export interface RayTraversalMemory {
+    readonly accelerationBytes: number;
+    readonly rayBytes: number;
+    readonly hitBytes: number;
+    readonly diagnosticBytes: number;
+    readonly parameterBytes: number;
+    readonly readbackBytes: number;
+    readonly peakBytes: number;
+    readonly liveResourceCount: number;
+}
+export interface RayTraversalResult {
+    readonly status: 'ok' | 'failed';
+    readonly mode: RayTraversalMode;
+    readonly hits: readonly (RayTraversalHit | null)[];
+    readonly counters: RayTraversalCounters;
+    readonly dispatchCount: number;
+    readonly gpuTimeNs: number | null;
+    readonly gpuTimeKind: 'timestamp-query' | 'unavailable';
+    readonly memory: RayTraversalMemory;
+    readonly diagnostics: readonly RayTraversalDiagnostic[];
+}
+export interface RayTraversalExecuteOptions {
+    readonly mode?: RayTraversalMode;
+    readonly maxRaysPerDispatch?: number;
+    /** Test/diagnostic override; production defaults to the frozen ABI limit of 64. */
+    readonly stackLimit?: number;
+}
+export interface RayTraversalCreateResult {
+    readonly runtime: import('./runtime.js').RayTraversalRuntime | null;
+    readonly diagnostics: readonly RayTraversalDiagnostic[];
+}
+export interface RayTraversalDispatchPlanPass {
+    readonly kind: 'upload' | 'traversal' | 'consumer';
+    readonly label: string;
+    readonly dispatchIndex: number | null;
+}
+export interface RayTraversalDispatchPlan {
+    readonly rayCount: number;
+    readonly maxRaysPerDispatch: number;
+    readonly dispatchCount: number;
+    readonly passes: readonly RayTraversalDispatchPlanPass[];
+}
+export type RayTraversalInput = RayInput;

package/dist/ray-tracing/worker/client.d.ts

@@ -0,0 +1,25 @@
+import type { RaySceneSnapshot } from '../scene/index.js';
+import { type RayAccelerationWorkerBuildOptions, type RayAccelerationWorkerBuildResult, type RayAccelerationWorkerClientCreateResult, type RayAccelerationWorkerClientOptions, type RayWorkerDiagnostic, type RayWorkerFactory } from './types.js';
+export declare class RayAccelerationWorkerClient {
+    private readonly workerFactory;
+    private readonly options;
+    private channel;
+    private readonly owners;
+    private readonly diagnosticValues;
+    private readonly queueOverflowErrors;
+    private readonly maxRecoveryAttempts;
+    private disposedValue;
+    private recoveryPromise;
+    private constructor();
+    static create(workerFactory: RayWorkerFactory, options?: RayAccelerationWorkerClientOptions): RayAccelerationWorkerClientCreateResult;
+    get destroyed(): boolean;
+    get pendingCount(): number;
+    get liveOwnerCount(): number;
+    get diagnostics(): readonly RayWorkerDiagnostic[];
+    build(ownerId: string, snapshot: RaySceneSnapshot, options?: RayAccelerationWorkerBuildOptions): Promise<RayAccelerationWorkerBuildResult>;
+    releaseOwner(ownerId: string): Promise<boolean>;
+    dispose(): void;
+    private createChannel;
+    private recover;
+    private emit;
+}

package/dist/ray-tracing/worker/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './serialization.js';
+export * from './runtime.js';
+export * from './source.js';
+export * from './client.js';

package/dist/ray-tracing/worker/runtime.d.ts

@@ -0,0 +1,11 @@
+import { type RayAccelerationWorkerRequest, type RayAccelerationWorkerResponse } from './types.js';
+/** Worker-owned incremental BLAS/TLAS builders. No scene or GPU resource crosses this boundary. */
+export declare class RayAccelerationWorkerRuntime {
+    private readonly owners;
+    private destroyedValue;
+    get destroyed(): boolean;
+    get liveOwnerCount(): number;
+    build(request: RayAccelerationWorkerRequest): RayAccelerationWorkerResponse;
+    release(ownerId: string): boolean;
+    destroy(): void;
+}

package/dist/ray-tracing/worker/serialization.d.ts

@@ -0,0 +1,16 @@
+import { type RayPackedAcceleration } from '../acceleration/index.js';
+import type { RaySceneSnapshot } from '../scene/index.js';
+import type { RayAccelerationWorkerResponse, RayPackedAccelerationDto, RaySceneSnapshotDto } from './types.js';
+export declare function serializeRaySceneSnapshot(snapshot: RaySceneSnapshot): {
+    readonly snapshot: RaySceneSnapshotDto;
+    readonly transfer: readonly Transferable[];
+};
+export declare function deserializeRaySceneSnapshot(dto: RaySceneSnapshotDto): RaySceneSnapshot;
+/** Clones buffers before transfer so the worker's incremental builder keeps an intact previous revision. */
+export declare function clonePackedAccelerationForTransfer(packed: RayPackedAcceleration): {
+    readonly packed: RayPackedAccelerationDto;
+    readonly transfer: readonly Transferable[];
+    readonly transferBytes: number;
+};
+export declare function deserializePackedAcceleration(dto: RayPackedAccelerationDto): RayPackedAcceleration;
+export declare function collectRayWorkerResponseTransferables(response: RayAccelerationWorkerResponse): readonly Transferable[];

package/dist/ray-tracing/worker/source.d.ts

@@ -0,0 +1 @@
+export declare function createRayAccelerationWorkerSource(rayTracingModuleUrl: string): string;

package/dist/ray-tracing/worker/types.d.ts

@@ -0,0 +1,91 @@
+import type { RayAccelerationDiagnostic, RayAccelerationRuntimeStatistics, RayAccelerationUpdateKind, RayDirtyUploadRange, RayPackedAcceleration } from '../acceleration/index.js';
+import type { RayDiagnostic, RayMatrix4, RayPrimitiveIdentity, RayVec3 } from '../reference/index.js';
+import type { RaySceneInstanceProvenance, RaySceneMaterialFacts, RaySceneSourceRevision, RaySceneSnapshot } from '../scene/index.js';
+export declare const RAY_ACCELERATION_WORKER_PROTOCOL_VERSION: 1;
+export declare const RAY_ACCELERATION_WORKER_REQUEST_FORMAT: "haiyue-ray-acceleration-worker-request@1";
+export declare const RAY_ACCELERATION_WORKER_RESPONSE_FORMAT: "haiyue-ray-acceleration-worker-response@1";
+export type RayWorkerDiagnosticCode = 'RAY_WORKER_QUEUE_OVERFLOW' | 'RAY_WORKER_CRASH' | 'RAY_WORKER_MESSAGE_ERROR' | 'RAY_WORKER_PROTOCOL_ERROR' | 'RAY_WORKER_STALE_REPLY' | 'RAY_WORKER_ABORTED' | 'RAY_WORKER_RECOVERY_STARTED' | 'RAY_WORKER_RECOVERY_COMPLETED' | 'RAY_WORKER_RECOVERY_FAILED' | 'RAY_WORKER_OWNER_RELEASED' | 'RAY_WORKER_DISPOSED';
+export interface RayWorkerDiagnostic {
+    readonly phase: 'worker-request' | 'worker-recovery' | 'worker-lifecycle';
+    readonly severity: 'info' | 'warning' | 'error';
+    readonly code: RayWorkerDiagnosticCode;
+    readonly message: string;
+    readonly context: Readonly<Record<string, string | number | boolean | null>>;
+}
+export interface RayWorkerGeometryDto {
+    readonly kind: 'triangle-mesh';
+    readonly geometryId: string;
+    readonly revision: number;
+    readonly positions: Float64Array<ArrayBuffer>;
+    readonly normals: Float64Array<ArrayBuffer> | null;
+    readonly indices: Uint32Array<ArrayBuffer> | null;
+    readonly primitiveCount: number;
+}
+export interface RayWorkerInstanceDto {
+    readonly instanceId: string;
+    readonly entityId: string;
+    readonly geometryId: string;
+    readonly geometryRevision: number;
+    readonly transform: readonly number[];
+}
+export interface RayWorkerAnalyticSphereDto {
+    readonly kind: 'sphere';
+    readonly identity: RayPrimitiveIdentity;
+    readonly center: RayVec3;
+    readonly radius: number;
+    readonly transform: RayMatrix4;
+}
+export interface RaySceneSnapshotDto {
+    readonly schemaVersion: 1;
+    readonly sourceRevision: RaySceneSourceRevision;
+    readonly revision: string;
+    readonly fingerprint: string;
+    readonly geometries: readonly RayWorkerGeometryDto[];
+    readonly instances: readonly RayWorkerInstanceDto[];
+    readonly analyticPrimitives: readonly RayWorkerAnalyticSphereDto[];
+    readonly provenance: readonly RaySceneInstanceProvenance[];
+    readonly diagnostics: readonly RayDiagnostic[];
+}
+export interface RayAccelerationWorkerRequest {
+    readonly format: typeof RAY_ACCELERATION_WORKER_REQUEST_FORMAT;
+    readonly ownerId: string;
+    readonly generation: number;
+    readonly sourceFingerprint: string;
+    readonly forceRebuild: boolean;
+    readonly snapshot: RaySceneSnapshotDto;
+}
+export interface RayPackedAccelerationDto extends Omit<RayPackedAcceleration, 'buffers'> {
+    readonly buffers: RayPackedAcceleration['buffers'];
+}
+export interface RayAccelerationWorkerResponse {
+    readonly format: typeof RAY_ACCELERATION_WORKER_RESPONSE_FORMAT;
+    readonly ownerId: string;
+    readonly generation: number;
+    readonly sourceFingerprint: string;
+    readonly updateKind: RayAccelerationUpdateKind;
+    readonly packed: RayPackedAccelerationDto | null;
+    readonly dirtyRanges: readonly RayDirtyUploadRange[];
+    readonly diagnostics: readonly RayAccelerationDiagnostic[];
+    readonly statistics: RayAccelerationRuntimeStatistics;
+    readonly transferBytes: number;
+}
+export interface RayAccelerationWorkerBuildOptions {
+    readonly signal?: AbortSignal;
+    readonly forceRebuild?: boolean;
+}
+export interface RayAccelerationWorkerBuildResult extends Omit<RayAccelerationWorkerResponse, 'packed'> {
+    readonly packed: RayPackedAcceleration | null;
+    readonly workerDiagnostics: readonly RayWorkerDiagnostic[];
+}
+export interface RayAccelerationWorkerClientOptions {
+    readonly maxPending?: number;
+    readonly maxRecoveryAttempts?: number;
+    readonly onDiagnostic?: (diagnostic: RayWorkerDiagnostic) => void;
+}
+export interface RayAccelerationWorkerClientCreateResult {
+    readonly client: import('./client.js').RayAccelerationWorkerClient | null;
+    readonly diagnostics: readonly RayWorkerDiagnostic[];
+}
+export type RayWorkerFactory = () => import('@haiyue/engine/experimental/async').WorkerChannelLike;
+export declare function isRaySceneSnapshot(value: unknown): value is RaySceneSnapshot;
+export declare function isRaySceneMaterialFacts(value: unknown): value is RaySceneMaterialFacts;

package/dist/ray-tracing.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Experimental WebGPU compute ray-tracing capability.
+ *
+ * The namespace exports keep each owner boundary visible to consumers and
+ * prevent this optional capability from leaking into the extensions root.
+ */
+export * as rayReference from './ray-tracing/reference/index.js';
+export * as rayScene from './ray-tracing/scene/index.js';
+export * as rayAcceleration from './ray-tracing/acceleration/index.js';
+export * as rayTraversal from './ray-tracing/traversal/index.js';
+export * as rayMaterial from './ray-tracing/material/index.js';
+export * as rayPathTracing from './ray-tracing/renderer/index.js';
+export * as raySampling from './ray-tracing/sampling/index.js';
+export * as rayDenoise from './ray-tracing/denoise/index.js';
+export * as rayHybrid from './ray-tracing/hybrid/index.js';
+export * as rayWorker from './ray-tracing/worker/index.js';
+export * as rayLifecycle from './ray-tracing/lifecycle/index.js';