@pascal-app/viewer 1.0.0-beta.5 → 1.0.0

package/dist/lib/perf-panel-store.d.ts

@@ -0,0 +1,71 @@
+export type PerfTrackLine = {
+    name: string;
+    totalMs: number;
+    count: number;
+    maxMs: number;
+};
+export type PerfStats = {
+    fps: number;
+    frameMs: number;
+    frameMaxMs: number;
+    encodeMs: number;
+    encodeMaxMs: number;
+    gpuMs: number;
+    gpuMaxMs: number;
+    gpuTracked: boolean;
+    queueMs: number;
+    queueMaxMs: number;
+    drawCalls: number;
+    triangles: number;
+    batch: PerfBatchStats;
+    dirty: number;
+    dirtyDetail: string;
+    geometries: number;
+    textures: number;
+    gpuBytes: number;
+    heapBytes: number;
+    meshes: number;
+    lines: number;
+    sprites: number;
+    lights: number;
+    tracks: PerfTrackLine[];
+};
+export declare function publishPerfStats(stats: PerfStats): void;
+export declare function usePerfStats(): PerfStats | null;
+/**
+ * Batch membership, published by the batch systems themselves (the panel's
+ * collector cannot read their stores across packages). Stable truth — items
+ * and instances currently drawn through batch containers — unlike the
+ * per-pass `_multiDrawCount`, which snapshots whichever camera (main, shadow,
+ * outline) culled the batch last and flips between passes. On WebGPU each
+ * batched instance still counts once in `drawCalls` (the backend loops
+ * drawIndexed per visible instance), so without this row a batched scene
+ * looks no cheaper than an unbatched one — the saving is encode cost per
+ * call, not call count.
+ */
+export type PerfBatchStats = {
+    items: number;
+    instances: number;
+    containers: number;
+    releases?: number;
+    joins?: number;
+    geometryReplacements?: number;
+    overflowRebuilds?: number;
+    wallDrain?: {
+        initialBuildActive: boolean;
+        wallsConsumedThisFrame: number;
+        budgetExits: number;
+        heavyExits: number;
+        drainedExits: number;
+        capExits: number;
+        pendingNeighbours: number;
+        firstBuilds: number;
+        reinvalidationBuilds: number;
+        neighbourEnqueues: number;
+    };
+    geometryBytesCopied?: number;
+};
+export declare function publishPerfBatchStats(stats: Partial<PerfBatchStats>): void;
+export declare function publishPerfWallDrainStats(stats: NonNullable<PerfBatchStats['wallDrain']>): void;
+export declare function readPerfBatchStats(): PerfBatchStats;
+//# sourceMappingURL=perf-panel-store.d.ts.map

package/dist/lib/perf-panel-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"perf-panel-store.d.ts","sourceRoot":"","sources":["../../src/lib/perf-panel-store.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,aAAa,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAE3F,MAAM,MAAM,SAAS,GAAG;IACtB,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,OAAO,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,cAAc,CAAA;IACrB,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,aAAa,EAAE,CAAA;CACxB,CAAA;AAKD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAGvD;AAOD,wBAAgB,YAAY,IAAI,SAAS,GAAG,IAAI,CAM/C;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,SAAS,CAAC,EAAE;QACV,kBAAkB,EAAE,OAAO,CAAA;QAC3B,sBAAsB,EAAE,MAAM,CAAA;QAC9B,WAAW,EAAE,MAAM,CAAA;QACnB,UAAU,EAAE,MAAM,CAAA;QAClB,YAAY,EAAE,MAAM,CAAA;QACpB,QAAQ,EAAE,MAAM,CAAA;QAChB,iBAAiB,EAAE,MAAM,CAAA;QACzB,WAAW,EAAE,MAAM,CAAA;QACnB,oBAAoB,EAAE,MAAM,CAAA;QAC5B,iBAAiB,EAAE,MAAM,CAAA;KAC1B,CAAA;IACD,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAC7B,CAAA;AAID,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAE1E;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,WAAW,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI,CAE/F;AAED,wBAAgB,kBAAkB,IAAI,cAAc,CAEnD"}

package/dist/lib/perf-panel-store.js

@@ -0,0 +1,29 @@
+// Bridge between the in-canvas collector (perf-monitor.tsx, R3F reconciler)
+// and the DOM panel (perf-panel.tsx). react-dom portals can't cross the R3F
+// renderer boundary, so the collector publishes here and the panel — mounted
+// outside <Canvas> — subscribes via useSyncExternalStore.
+import { useSyncExternalStore } from 'react';
+let current = null;
+const listeners = new Set();
+export function publishPerfStats(stats) {
+    current = stats;
+    for (const listener of listeners)
+        listener();
+}
+function subscribe(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+export function usePerfStats() {
+    return useSyncExternalStore(subscribe, () => current, () => null);
+}
+let batchStats = { items: 0, instances: 0, containers: 0 };
+export function publishPerfBatchStats(stats) {
+    batchStats = { ...batchStats, ...stats };
+}
+export function publishPerfWallDrainStats(stats) {
+    batchStats.wallDrain = stats;
+}
+export function readPerfBatchStats() {
+    return batchStats;
+}

package/dist/lib/perf-tracks.d.ts

@@ -0,0 +1,43 @@
+export type PerfCounterBucket = {
+    totalMs: number;
+    maxMs: number;
+    count: number;
+};
+/** DevTools palette names accepted by the extensibility API. */
+export type PerfTrackColor = 'primary' | 'primary-light' | 'primary-dark' | 'secondary' | 'secondary-light' | 'secondary-dark' | 'tertiary' | 'tertiary-light' | 'tertiary-dark' | 'error';
+type PerfSampleListener = (track: string, ms: number) => void;
+export declare function subscribePerfSamples(listener: PerfSampleListener): () => void;
+/**
+ * Time a synchronous block and file it under `track`. The label defaults to
+ * the track name; pass `name` for per-entry granularity (e.g. a node id) —
+ * it only affects the DevTools lane, not the aggregate bucket.
+ */
+export declare function timeSpan<T>(track: string, fn: () => T, opts?: {
+    name?: string;
+    color?: PerfTrackColor;
+    properties?: Array<[string, string]>;
+}): T;
+/**
+ * Span for non-callback shapes (spans crossing await points or frames).
+ * `beginSpan` returns null when perf is off — callers pass the handle back to
+ * `endSpan`, which no-ops on null.
+ */
+export type PerfSpanHandle = {
+    track: string;
+    name: string;
+    start: number;
+    color: PerfTrackColor;
+};
+export declare function beginSpan(track: string, opts?: {
+    name?: string;
+    color?: PerfTrackColor;
+}): PerfSpanHandle | null;
+export declare function endSpan(handle: PerfSpanHandle | null, properties?: Array<[string, string]>): void;
+/** Record a duration measured externally (no measure emitted). */
+export declare function recordPerfSample(track: string, ms: number): void;
+/** Hand the current window's buckets to the overlay and start a new window. */
+export declare function drainPerfCounters(): Map<string, PerfCounterBucket>;
+/** Drop accumulated timeline entries so long `?perf` sessions don't leak. */
+export declare function clearPerfMeasures(): void;
+export {};
+//# sourceMappingURL=perf-tracks.d.ts.map

package/dist/lib/perf-tracks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"perf-tracks.d.ts","sourceRoot":"","sources":["../../src/lib/perf-tracks.ts"],"names":[],"mappings":"AAkBA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,gEAAgE;AAChE,MAAM,MAAM,cAAc,GACtB,SAAS,GACT,eAAe,GACf,cAAc,GACd,WAAW,GACX,iBAAiB,GACjB,gBAAgB,GAChB,UAAU,GACV,gBAAgB,GAChB,eAAe,GACf,OAAO,CAAA;AAOX,KAAK,kBAAkB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;AAG7D,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,IAAI,CAG7E;AAyCD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,CAAC,EACX,IAAI,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,cAAc,CAAC;IAAC,UAAU,CAAC,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAAE,GACrF,CAAC,CAUH;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,cAAc,CAAA;CAAE,CAAA;AAElG,wBAAgB,SAAS,CACvB,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,cAAc,CAAA;CAAE,GAC/C,cAAc,GAAG,IAAI,CAQvB;AAED,wBAAgB,OAAO,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,EAAE,UAAU,CAAC,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,IAAI,CAKjG;AAED,kEAAkE;AAClE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAGhE;AAED,+EAA+E;AAC/E,wBAAgB,iBAAiB,IAAI,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAIlE;AAED,6EAA6E;AAC7E,wBAAgB,iBAAiB,IAAI,IAAI,CAOxC"}

package/dist/lib/perf-tracks.js

@@ -0,0 +1,113 @@
+// Shared sink for `?perf` instrumentation.
+//
+// Two outputs from one call site:
+//  1. Chrome DevTools Performance panel custom tracks — every span becomes a
+//     `performance.measure` with a `detail.devtools` payload, so Pascal systems
+//     show up as named lanes in the flame chart while recording.
+//  2. Per-window aggregates — `drainPerfCounters()` hands the overlay one
+//     bucket per track (total/max/count since the last drain), so the panel can
+//     print "wall-csg 9.8ms" without touching the timeline.
+//
+// Everything is gated on PERF_OVERLAY_ENABLED: when `?perf` is absent the
+// helpers reduce to calling `fn()` directly / returning early, so hot paths pay
+// only a boolean check. Measures otherwise accumulate in the browser's
+// timeline buffer indefinitely — the overlay is responsible for calling
+// `clearPerfMeasures()` on its drain tick.
+import { PERF_OVERLAY_ENABLED } from './gpu-perf';
+const counters = new Map();
+const sampleListeners = new Set();
+export function subscribePerfSamples(listener) {
+    sampleListeners.add(listener);
+    return () => sampleListeners.delete(listener);
+}
+function record(track, ms) {
+    const bucket = counters.get(track);
+    if (bucket) {
+        bucket.totalMs += ms;
+        bucket.count += 1;
+        if (ms > bucket.maxMs)
+            bucket.maxMs = ms;
+    }
+    else {
+        counters.set(track, { totalMs: ms, maxMs: ms, count: 1 });
+    }
+    for (const listener of sampleListeners)
+        listener(track, ms);
+}
+function emitMeasure(track, name, start, end, color, properties) {
+    try {
+        performance.measure(name, {
+            start,
+            end,
+            detail: {
+                devtools: {
+                    dataType: 'track-entry',
+                    track,
+                    trackGroup: 'Pascal',
+                    color,
+                    ...(properties ? { properties } : {}),
+                },
+            },
+        });
+    }
+    catch {
+        // Older browsers reject the options bag — aggregates still work.
+    }
+}
+/**
+ * Time a synchronous block and file it under `track`. The label defaults to
+ * the track name; pass `name` for per-entry granularity (e.g. a node id) —
+ * it only affects the DevTools lane, not the aggregate bucket.
+ */
+export function timeSpan(track, fn, opts) {
+    if (!PERF_OVERLAY_ENABLED)
+        return fn();
+    const start = performance.now();
+    try {
+        return fn();
+    }
+    finally {
+        const end = performance.now();
+        record(track, end - start);
+        emitMeasure(track, opts?.name ?? track, start, end, opts?.color ?? 'primary', opts?.properties);
+    }
+}
+export function beginSpan(track, opts) {
+    if (!PERF_OVERLAY_ENABLED)
+        return null;
+    return {
+        track,
+        name: opts?.name ?? track,
+        start: performance.now(),
+        color: opts?.color ?? 'primary',
+    };
+}
+export function endSpan(handle, properties) {
+    if (!handle)
+        return;
+    const end = performance.now();
+    record(handle.track, end - handle.start);
+    emitMeasure(handle.track, handle.name, handle.start, end, handle.color, properties);
+}
+/** Record a duration measured externally (no measure emitted). */
+export function recordPerfSample(track, ms) {
+    if (!PERF_OVERLAY_ENABLED)
+        return;
+    record(track, ms);
+}
+/** Hand the current window's buckets to the overlay and start a new window. */
+export function drainPerfCounters() {
+    const out = new Map(counters);
+    counters.clear();
+    return out;
+}
+/** Drop accumulated timeline entries so long `?perf` sessions don't leak. */
+export function clearPerfMeasures() {
+    try {
+        performance.clearMeasures();
+        performance.clearMarks();
+    }
+    catch {
+        // ignore
+    }
+}

package/dist/lib/pointer-events.d.ts

@@ -0,0 +1,7 @@
+import { events as createWebEvents, type EventManager, type RootStore } from '@react-three/fiber';
+import * as THREE from 'three';
+/** Opt in only when the raycast appends hits without reading prior hits or mutating scene/query state. */
+export declare function markPureRaycast<T extends THREE.Object3D['raycast']>(raycast: T): T;
+export declare function choosePointerEvents(search?: string): typeof createWebEvents;
+export declare function createPascalPointerEvents(store: RootStore): EventManager<HTMLElement>;
+//# sourceMappingURL=pointer-events.d.ts.map

package/dist/lib/pointer-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointer-events.d.ts","sourceRoot":"","sources":["../../src/lib/pointer-events.ts"],"names":[],"mappings":"AA6BA,OAAO,EACL,MAAM,IAAI,eAAe,EAGzB,KAAK,YAAY,EAMjB,KAAK,SAAS,EAEf,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAqC9B,0GAA0G;AAC1G,wBAAgB,eAAe,CAAC,CAAC,SAAS,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAGlF;AAYD,wBAAgB,mBAAmB,CACjC,MAAM,SAA8D,GACnE,OAAO,eAAe,CAIxB;AAiLD,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,SAAS,GAAG,YAAY,CAAC,WAAW,CAAC,CAmBrF"}