@uptimizr/playcanvas 0.1.2 → 0.2.0

package/dist/collector.d.ts

@@ -18,6 +18,14 @@ export interface PlayCanvasCaptureOptions {
     perf?: boolean;
     /** WebGL `webglcontextlost` / `webglcontextrestored` transitions on the canvas. */
     contextLoss?: boolean;
+    /**
+     * Asset / resource load timing (`asset_load`, #14). **On by default**: it hooks
+     * the PlayCanvas `app.assets` registry load lifecycle (`load:start` → `load` /
+     * `error`) and emits one `asset_load` per observed load with its duration and
+     * (when known) byte size. Privacy (ADR 0003): only the asset's app-defined
+     * **name** is recorded — never the file URL.
+     */
+    assetLoad?: boolean;
     /**
      * Per-object dwell / attention capture (`mesh_visibility`, #37). **Opt-in, off
      * by default** (privacy, ADR 0003). Each window the connector emits one

package/dist/collector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collector.d.ts","sourceRoot":"","sources":["../src/collector.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"collector.d.ts","sourceRoot":"","sources":["../src/collector.ts"],"names":[],"mappings":"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"}

package/dist/collector.js

@@ -1,4 +1,5 @@
-import { classifyCameraGesture, resolveCadence, toCanonicalDirection, toCanonicalPosition, toCanonicalQuat, } from "@uptimizr/sdk-core";
+import { poseUnchanged, resolveCadence, toCanonicalDirection, toCanonicalPosition, toCanonicalQuat, } from "@uptimizr/sdk-core";
+import { LIMITS } from "@uptimizr/schema";
 import { clamp01, toVec3 } from "./vec.js";
 import { createGazeRaycaster, createSceneRaycaster } from "./raycast.js";
 /**
@@ -24,30 +25,14 @@ function isPointerLocked(getCanvas) {
     const locked = document.pointerLockElement;
     return locked != null && locked === getCanvas();
 }
-function vec3Close(a, b, eps) {
-    return (Math.abs(a[0] - b[0]) <= eps && Math.abs(a[1] - b[1]) <= eps && Math.abs(a[2] - b[2]) <= eps);
-}
-/** True when two poses are equal within `eps`. */
-function poseUnchanged(a, b, eps) {
-    if (!vec3Close(a.position, b.position, eps))
-        return false;
-    if (!vec3Close(a.direction, b.direction, eps))
-        return false;
-    if ((a.fov === undefined) !== (b.fov === undefined))
-        return false;
-    if (a.fov !== undefined && b.fov !== undefined && Math.abs(a.fov - b.fov) > eps)
-        return false;
-    return true;
-}
+/** Max stored `asset_load.name` length (schema bound, ADR 0003). */
+const ASSET_NAME_MAX = LIMITS.maxAssetNameLength;
 function sub3(a, b) {
     return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
 }
 function dot3(a, b) {
     return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
 }
-function len3(a) {
-    return Math.hypot(a[0], a[1], a[2]);
-}
 /**
  * Derive the per-tick capture rate from a `sampling.nodes` entry: either a bare
  * {@link SampleRate} (root-only, ADR 0027) or a {@link NodeSamplingConfig} whose
@@ -138,22 +123,6 @@ function readNodeTransform(node, scaleEps) {
     }
     return sample;
 }
-/** True when two node samples are equal within `eps` (scale presence must also match). */
-function nodeSampleUnchanged(a, b, eps) {
-    if (!vec3Close(a.position, b.position, eps))
-        return false;
-    if (Math.abs(a.rotation[0] - b.rotation[0]) > eps ||
-        Math.abs(a.rotation[1] - b.rotation[1]) > eps ||
-        Math.abs(a.rotation[2] - b.rotation[2]) > eps ||
-        Math.abs(a.rotation[3] - b.rotation[3]) > eps) {
-        return false;
-    }
-    if ((a.scale === undefined) !== (b.scale === undefined))
-        return false;
-    if (a.scale && b.scale && !vec3Close(a.scale, b.scale, eps))
-        return false;
-    return true;
-}
 /**
  * Resolve a declared {@link PlayCanvasActor} to a live node, or `null` when it is
  * not (yet) in the scene. A function is called each time (robust to load order
@@ -240,17 +209,6 @@ function readPlayCanvasBoneTransform(bone, scaleEps) {
     }
     return sample;
 }
-/** Round an AABB to mm precision so tiny float jitter doesn't re-send the box. */
-function roundAabb(b) {
-    return b.map((v) => Math.round(v * 1000) / 1000);
-}
-/** True when two AABBs match within `eps` on every axis. */
-function aabbClose(a, b, eps) {
-    for (let i = 0; i < 6; i++)
-        if (Math.abs((a[i] ?? 0) - (b[i] ?? 0)) > eps)
-            return false;
-    return true;
-}
 function meshInstancesOf(node) {
     return node.render?.meshInstances ?? node.model?.meshInstances ?? [];
 }
@@ -344,6 +302,8 @@ export function playcanvasCollector(options) {
         meshPicks: capture.meshPicks ?? true,
         perf: (capture.perf ?? true) && perfCadence.mode !== "off",
         contextLoss: capture.contextLoss ?? true,
+        // Asset load timing is on by default (#14): startup perf, name-only (no URL).
+        assetLoad: capture.assetLoad ?? true,
         // Opt-in, off by default (privacy, ADR 0003).
         meshVisibility: capture.meshVisibility ?? false,
         hoverDwell: capture.hoverDwell ?? false,
@@ -417,6 +377,17 @@ export function playcanvasCollector(options) {
         name: "playcanvas",
         start(ctx) {
             const appView = app;
+            // The engine-agnostic aggregator (#10): the connector reads live engine
+            // state into plain-number snapshot DTOs and hands them here; the
+            // offload-eligible math (matrix-free decompose idle-diffs, visibility
+            // bucketing, gesture classification) runs main-thread by default or inside
+            // the offload worker, behind the client `offload` flag.
+            const aggregatorConfig = {
+                perf: { suppressIdle: suppressIdlePerfSamples, fpsThreshold: perfFpsThreshold },
+                node: { suppressIdle: suppressIdleSamples },
+                visibility: { centeredCos: visCenteredCos, boundingBox: visBoundingBox, boundsEps: 1e-3 },
+            };
+            const snapshot = ctx.createAggregation(aggregatorConfig);
             const timers = [];
             const domListeners = [];
             const frameCallbacks = [];
@@ -426,7 +397,6 @@ export function playcanvasCollector(options) {
             let disposed = false;
             let lastPointerMove = 0;
             let lastPose;
-            let lastFps;
             // camera_gesture (ADR 0025) bracket state: the camera snapshot at
             // pointer-down, diffed against pointer-up to classify the navigation.
             let gestureStart = null;
@@ -476,8 +446,8 @@ export function playcanvasCollector(options) {
                     ? toCanonicalPosition(gazeHit.point, "right")
                     : undefined;
                 const hitMesh = gazeHit && gazeHit.name ? gazeHit.name : undefined;
-                ctx.emit({
-                    type: "camera_sample",
+                snapshot({
+                    channel: "camera",
                     position: pose.position,
                     direction: pose.direction,
                     ...(pose.fov !== undefined ? { fov: pose.fov } : {}),
@@ -508,13 +478,11 @@ export function playcanvasCollector(options) {
                 const fps = readFps();
                 if (fps <= 0)
                     return;
-                if (suppressIdlePerfSamples &&
-                    lastFps !== undefined &&
-                    Math.abs(fps - lastFps) <= perfFpsThreshold) {
-                    return;
-                }
-                lastFps = fps;
-                ctx.emit({ type: "frame_perf", fps });
+                // Hand the engine FPS read to the aggregator; it owns the idle-diff (and,
+                // for engines that supply a frame-time window, the percentiles/longFrames).
+                // PlayCanvas exposes only an averaged FPS, so the window stays empty and the
+                // aggregator emits `frame_perf` with `fps` alone — byte-for-byte unchanged.
+                snapshot({ channel: "perf", frameTimes: new Float32Array(0), fps, jankFrameMs: 0 });
             };
             // Drive a continuous channel either on a timer (fixed interval) or once per
             // engine frame ("frame"). PlayCanvas owns its render loop, so the connector
@@ -553,10 +521,12 @@ export function playcanvasCollector(options) {
                 // actor gets its own cadence-driven sampler: resolve the node (lazily —
                 // resolvers handle load order), refuse cameras (the visitor camera is
                 // already `camera_sample`; "events live once"), read the WORLD transform,
-                // convert it to the canonical frame, and emit. Idle suppression skips
-                // samples where the transform is unchanged so a static actor costs nothing.
+                // convert it to the canonical frame, and hand the decomposed sample to the
+                // aggregator. PlayCanvas applies a right-handed→canonical conversion (ADR
+                // 0018), so we pass the already-decomposed sample (never the raw matrix
+                // path); the aggregator owns the idle-diff so a static actor stays off the
+                // wire (#10).
                 const root = appView.root;
-                const lastNodeSample = new Map();
                 const refusedCamera = new Set();
                 for (const id of actorIds) {
                     const actor = actorMap[id];
@@ -580,40 +550,24 @@ export function playcanvasCollector(options) {
                             }
                             return;
                         }
-                        const sample = readNodeTransform(node, cameraEpsilon);
-                        const prev = lastNodeSample.get(id);
-                        if (!(suppressIdleSamples && prev && nodeSampleUnchanged(prev, sample, cameraEpsilon))) {
-                            lastNodeSample.set(id, sample);
-                            ctx.emit({
-                                type: "node_transform",
-                                nodeId: id,
-                                position: sample.position,
-                                rotation: sample.rotation,
-                                ...(sample.scale ? { scale: sample.scale } : {}),
-                            });
-                        }
-                        // Subtree descendants (ADR 0033): walk the bounded hierarchy and emit
-                        // each kept node's WORLD transform with its `childPath`. Idle
-                        // suppression is keyed per (actor, childPath) so a static part costs
-                        // nothing on the wire.
+                        snapshot({
+                            channel: "node",
+                            nodeId: id,
+                            decomposed: readNodeTransform(node, cameraEpsilon),
+                            scaleEps: cameraEpsilon,
+                        });
+                        // Subtree descendants (ADR 0033): walk the bounded hierarchy and hand
+                        // each kept node's WORLD transform with its `childPath` to the
+                        // aggregator, which idle-diffs per (actor, childPath) so a static part
+                        // costs nothing on the wire.
                         if (subtree) {
                             for (const { childPath, node: child } of collectSubtree(node, subtree)) {
-                                const childSample = readNodeTransform(child, cameraEpsilon);
-                                const key = `${id}\u0000${childPath}`;
-                                const childPrev = lastNodeSample.get(key);
-                                if (suppressIdleSamples &&
-                                    childPrev &&
-                                    nodeSampleUnchanged(childPrev, childSample, cameraEpsilon)) {
-                                    continue;
-                                }
-                                lastNodeSample.set(key, childSample);
-                                ctx.emit({
-                                    type: "node_transform",
+                                snapshot({
+                                    channel: "node",
                                     nodeId: id,
                                     childPath,
-                                    position: childSample.position,
-                                    rotation: childSample.rotation,
-                                    ...(childSample.scale ? { scale: childSample.scale } : {}),
+                                    decomposed: readNodeTransform(child, cameraEpsilon),
+                                    scaleEps: cameraEpsilon,
                                 });
                             }
                         }
@@ -626,11 +580,13 @@ export function playcanvasCollector(options) {
                 // Skeleton bone capture (`node_transform` + `boneId`, ADR 0027 Tier 2).
                 // For each declared skinned actor, resolve its skeleton bones (by the
                 // configured allowlist or "*"), then sample each bone's skeleton-LOCAL
-                // pose at the actor's cadence. Per-bone idle suppression keeps a still
-                // rig free. The local frame is parent-relative, so motion replays onto a
-                // differently-placed instance of the same rig (ADR 0027).
+                // pose at the actor's cadence and hand the decomposed sample to the
+                // aggregator (which idle-diffs per (actor, bone), #10). PlayCanvas reads
+                // the local TRS via `getLocal*` and applies the canonical conversion (ADR
+                // 0018), so — like nodes — we pass the decomposed sample, never the raw
+                // matrix path. The local frame is parent-relative, so motion replays onto
+                // a differently-placed instance of the same rig (ADR 0027).
                 const root = appView.root;
-                const lastBoneSample = new Map();
                 const warnedNoSkeleton = new Set();
                 for (const id of boneActorIds) {
                     const actor = actorMap[id];
@@ -658,19 +614,12 @@ export function playcanvasCollector(options) {
                             const sample = readPlayCanvasBoneTransform(bone, cameraEpsilon);
                             if (!sample)
                                 continue;
-                            const key = `${id}\u0000${boneName}`;
-                            const prev = lastBoneSample.get(key);
-                            if (suppressIdleSamples && prev && nodeSampleUnchanged(prev, sample, cameraEpsilon)) {
-                                continue;
-                            }
-                            lastBoneSample.set(key, sample);
-                            ctx.emit({
-                                type: "node_transform",
+                            snapshot({
+                                channel: "node",
                                 nodeId: id,
                                 boneId: boneName,
-                                position: sample.position,
-                                rotation: sample.rotation,
-                                ...(sample.scale ? { scale: sample.scale } : {}),
+                                decomposed: sample,
+                                scaleEps: cameraEpsilon,
                             });
                         }
                     };
@@ -679,14 +628,12 @@ export function playcanvasCollector(options) {
                 }
             }
             // --- Per-object dwell (`mesh_visibility`, #37) ---
-            // Accumulate on-screen / near-centre time per object every engine frame
-            // (frameend pauses when the tab is hidden — like Babylon's onBeforeRender),
-            // then flush one bucketed summary per object per window (ADR 0012).
+            // Each engine frame we read which tracked objects are on-screen (the engine
+            // bounds/frustum reads must stay main-thread) and hand the raw per-tick
+            // observations to the aggregator; it owns the dwell/centred/screen-fraction
+            // bucketing and the per-window flush (ADR 0012, #10). `frameend` pauses when
+            // the tab is hidden — like Babylon's onBeforeRender.
             if (want.meshVisibility) {
-                const accum = new Map();
-                // Last AABB sent per mesh, so a static box is sent once then suppressed.
-                const sentBounds = new Map();
-                const boundsEps = 1e-3;
                 let lastVisTime = ctx.now();
                 const sampleVisibility = () => {
                     const now = ctx.now();
@@ -699,11 +646,12 @@ export function playcanvasCollector(options) {
                     const cf = camView.forward;
                     const camPos = [cp.x, cp.y, cp.z];
                     const forward = [cf.x, cf.y, cf.z];
-                    const fwdLen = len3(forward) || 1;
-                    // Half vertical FOV in radians; fall back for ortho / missing fov.
-                    const vfov = verticalFovRad(camView.camera);
-                    const halfFov = vfov !== undefined ? vfov / 2 : 0.4;
+                    // Vertical FOV in radians; `0` lets the aggregator apply its `0.8`
+                    // default (→ half-FOV `0.4`), matching the previous ortho/missing-fov
+                    // fallback.
+                    const fov = verticalFovRad(camView.camera) ?? 0;
                     let tracked = 0;
+                    const observations = [];
                     appView.root?.forEach?.((raw) => {
                         const node = raw;
                         if (meshInstancesOf(node).length === 0)
@@ -728,54 +676,41 @@ export function playcanvasCollector(options) {
                         if (!sphereInFront(bounds.center, bounds.radius, camPos, forward)) {
                             return;
                         }
-                        const toCenter = sub3(bounds.center, camPos);
-                        const dist = len3(toCenter) || 1e-6;
-                        const cosAngle = dot3(toCenter, forward) / (dist * fwdLen);
-                        const screenFraction = clamp01(Math.atan2(bounds.radius, dist) / (halfFov || 1e-6));
-                        let entry = accum.get(name);
-                        if (!entry) {
-                            entry = { visibleMs: 0, centeredMs: 0, maxScreenFraction: 0 };
-                            accum.set(name, entry);
-                        }
-                        entry.visibleMs += stepMs;
-                        if (cosAngle >= visCenteredCos)
-                            entry.centeredMs += stepMs;
-                        if (screenFraction > entry.maxScreenFraction)
-                            entry.maxScreenFraction = screenFraction;
-                        if (visBoundingBox) {
-                            // Canonical frame negates Z (right-handed PlayCanvas → canonical),
-                            // which swaps the Z min/max — match hitPoint / camera_sample (ADR 0018).
-                            const [aMinX, aMinY, aMinZ, aMaxX, aMaxY, aMaxZ] = bounds.aabb;
-                            entry.bounds = [aMinX, aMinY, -aMaxZ, aMaxX, aMaxY, -aMinZ];
-                        }
-                    });
-                };
-                const flushVisibility = () => {
-                    for (const [mesh, entry] of accum) {
-                        if (entry.visibleMs <= 0)
-                            continue;
-                        let bounds;
-                        if (entry.bounds) {
-                            const rounded = roundAabb(entry.bounds);
-                            const prev = sentBounds.get(mesh);
-                            if (!prev || !aabbClose(prev, rounded, boundsEps)) {
-                                bounds = rounded;
-                                sentBounds.set(mesh, rounded);
-                            }
-                        }
-                        ctx.emit({
-                            type: "mesh_visibility",
-                            mesh,
-                            visibleMs: Math.round(entry.visibleMs),
-                            ...(entry.centeredMs > 0 ? { centeredMs: Math.round(entry.centeredMs) } : {}),
-                            ...(entry.maxScreenFraction > 0
-                                ? { maxScreenFraction: entry.maxScreenFraction }
+                        observations.push({
+                            mesh: name,
+                            center: bounds.center,
+                            radius: bounds.radius,
+                            // Ride the world AABB along only when bounds capture is on (#53). The
+                            // canonical frame negates Z (right-handed PlayCanvas → canonical),
+                            // swapping the Z min/max — match hitPoint / camera_sample (ADR 0018);
+                            // the aggregator dedupes/rounds it across the window.
+                            ...(visBoundingBox
+                                ? {
+                                    aabb: [
+                                        bounds.aabb[0],
+                                        bounds.aabb[1],
+                                        -bounds.aabb[5],
+                                        bounds.aabb[3],
+                                        bounds.aabb[4],
+                                        -bounds.aabb[2],
+                                    ],
+                                }
                                 : {}),
-                            ...(bounds ? { bounds } : {}),
                         });
-                    }
-                    accum.clear();
+                    });
+                    if (observations.length === 0)
+                        return;
+                    snapshot({
+                        channel: "visibilityTick",
+                        stepMs,
+                        camPos,
+                        // Pass the raw (un-normalized) forward; the aggregator normalizes.
+                        forward,
+                        fov,
+                        meshes: observations,
+                    });
                 };
+                const flushVisibility = () => snapshot({ channel: "visibilityFlush" });
                 // Sample every frame; flush on the window timer + once on stop (trailing).
                 frameCallbacks.push(sampleVisibility);
                 ensureFrameendBound();
@@ -840,8 +775,8 @@ export function playcanvasCollector(options) {
                 if (hoverMesh !== undefined && !hoverActed) {
                     const dwellMs = now - hoverStartMs;
                     if (dwellMs >= hoverMinDwellMs) {
-                        ctx.emit({
-                            type: "hover_dwell",
+                        snapshot({
+                            channel: "hover",
                             mesh: hoverMesh,
                             dwellMs,
                             ...(hoverSource ? { source: hoverSource } : {}),
@@ -977,19 +912,14 @@ export function playcanvasCollector(options) {
                     gestureStart = null;
                     if (!opened)
                         return;
-                    const classified = classifyCameraGesture(opened.sample, readGestureSample(), {
-                        sensitivity: cameraGestureSensitivity,
-                    });
-                    if (!classified)
-                        return;
-                    ctx.emit({
-                        type: "camera_gesture",
-                        kind: classified.kind,
+                    // Hand the start→end bracket to the aggregator; the (pure) classification
+                    // math runs there, main-thread or in the worker (#10).
+                    snapshot({
+                        channel: "gesture",
+                        start: opened.sample,
+                        end: readGestureSample(),
                         durationMs: Math.max(0, Math.round(ctx.now() - opened.ts)),
-                        ...(classified.orbitDeg !== undefined ? { orbitDeg: classified.orbitDeg } : {}),
-                        ...(classified.rollDeg !== undefined ? { rollDeg: classified.rollDeg } : {}),
-                        ...(classified.zoomRatio !== undefined ? { zoomRatio: classified.zoomRatio } : {}),
-                        ...(classified.panDist !== undefined ? { panDist: classified.panDist } : {}),
+                        options: { sensitivity: cameraGestureSensitivity },
                         ...(opened.source ? { source: opened.source } : {}),
                     });
                 };
@@ -1006,6 +936,54 @@ export function playcanvasCollector(options) {
                 addListener("webglcontextlost", () => ctx.emit({ type: "context_lost" }));
                 addListener("webglcontextrestored", () => ctx.emit({ type: "context_restored" }));
             }
+            // Asset / resource load timing (`asset_load`, #14). PlayCanvas' `app.assets`
+            // registry (an EventHandler) exposes the load lifecycle: `load:start` fires
+            // when an asset begins network loading, `load` on success, `error` on
+            // failure. We bracket start→load to report a duration; assets whose load we
+            // never observed from the start (already-loaded, or added before tracking)
+            // are skipped so `loadMs` is never fabricated. Privacy (ADR 0003): only the
+            // asset's app-defined `name` is recorded — never the file URL.
+            const assets = appView.assets;
+            if (want.assetLoad && assets) {
+                const startTimes = new Map();
+                const keyOf = (asset) => asset.id ?? asset;
+                const onLoadStart = (raw) => {
+                    startTimes.set(keyOf(raw), ctx.now());
+                };
+                const onLoad = (raw) => {
+                    const asset = raw;
+                    const key = keyOf(asset);
+                    const start = startTimes.get(key);
+                    if (start === undefined)
+                        return; // load not observed from the start
+                    startTimes.delete(key);
+                    const event = {
+                        type: "asset_load",
+                        name: (asset.name ?? "asset").slice(0, ASSET_NAME_MAX),
+                        loadMs: Math.max(0, Math.round(ctx.now() - start)),
+                    };
+                    const bytes = asset.file?.size;
+                    if (typeof bytes === "number" && bytes > 0)
+                        event.bytes = bytes;
+                    ctx.emit(event);
+                };
+                const onError = (...args) => {
+                    // Registry fires `error(err, asset)`; drop the pending start (no emit —
+                    // `asset_load` is a success-timing signal with no error field).
+                    const asset = args[1];
+                    if (asset)
+                        startTimes.delete(keyOf(asset));
+                };
+                assets.on("load:start", onLoadStart);
+                assets.on("load", onLoad);
+                assets.on("error", onError);
+                stopCallbacks.push(() => {
+                    assets.off("load:start", onLoadStart);
+                    assets.off("load", onLoad);
+                    assets.off("error", onError);
+                    startTimes.clear();
+                });
+            }
             // GPU / memory footprint (`resource_sample`, #44). A low-rate timer samples
             // the triangles PlayCanvas submitted last frame (`app.stats.frame.triangles`)
             // and the JS heap. PlayCanvas exposes no per-frame vertex count or resident