@uptimizr/sdk-core 0.1.2 → 0.3.0

package/dist/graphicsDiagnostics.d.ts

@@ -0,0 +1,301 @@
+import type { GraphicsApi } from "@uptimizr/schema";
+import type { CollectorContext } from "./types.js";
+/**
+ * Structural view of a WebGPU `GPUDeviceLostInfo` (the value the `GPUDevice.lost`
+ * promise resolves with). Declared locally — rather than depending on
+ * `@webgpu/types` — so the helper stays dependency-free and tolerant of partial
+ * shapes across browsers.
+ *
+ * @see https://www.w3.org/TR/webgpu/#gpudevicelostinfo
+ */
+export interface GpuDeviceLostInfoLike {
+    /** `"destroyed"` for a requested loss (`device.destroy()`); otherwise unknown. */
+    reason?: string;
+    /** Human-readable detail (driver/agent text). Length-capped before emit. */
+    message?: string;
+}
+/**
+ * Structural view of the one field we read off a WebGPU `GPUDevice`: its `lost`
+ * promise. We read structurally so connectors can keep their engine
+ * (`@babylonjs/core`, `three`) a peer dependency and stay version-tolerant.
+ */
+export interface GpuDeviceLostLike {
+    lost?: Promise<GpuDeviceLostInfoLike>;
+}
+/** Tuning for how long we wait for an async-initialized WebGPU device. */
+export interface WireGpuDeviceLostOptions {
+    /**
+     * Max number of times to poll for the device before giving up. Defaults to 20
+     * which, with the default {@link intervalMs}, spans ~5s — comfortably longer
+     * than a WebGPU backend's async init while staying bounded (no leak).
+     */
+    maxAttempts?: number;
+    /** Delay between device-acquisition attempts, in ms. Defaults to 250. */
+    intervalMs?: number;
+}
+/**
+ * Wire a WebGPU `GPUDevice.lost` into a `graphics_diagnostic` (ADR 0021 part 2,
+ * `category: "device-lost"`). Engine-agnostic: every connector that can have a
+ * WebGPU device hands a device *getter* here, so the gating, severity mapping,
+ * length-cap, and event shape live in exactly one place.
+ *
+ * Behavior:
+ * - **Opt-in gate.** No-ops (nothing scheduled, nothing emitted) unless
+ *   `ctx.config.captureGraphicsDiagnostics` is on. (Unlike `context_lost`, which is
+ *   always-on; device loss is the richer opt-in diagnostic.)
+ * - **Async device init.** A WebGPU backend builds its device asynchronously
+ *   (three's `renderer.init()` / first `renderAsync`, Babylon's `initAsync`), so
+ *   the device is frequently `undefined` at collector `start()` time. We therefore
+ *   take a *getter* and **poll** it (bounded by {@link WireGpuDeviceLostOptions})
+ *   until the device appears, rather than reading once and silently giving up.
+ * - **Severity.** `info` when `reason === "destroyed"` (an expected, app-requested
+ *   loss via `device.destroy()`); `fatal` otherwise (an unrequested loss —
+ *   rendering cannot continue).
+ * - **Marker.** Emits a single discrete incident (no `count`): device loss is rare
+ *   and decisive, so the high-fidelity marker is the right default here.
+ * - **Privacy.** The optional `message` is locally truncated to
+ *   {@link LIMITS.maxGraphicsDiagnosticMessageLength} and rides through `ctx.emit`,
+ *   which applies the client's `beforeSend` for deployer-owned redaction.
+ *
+ * Teardown is cooperative: pass an `isActive` predicate (typically `() => !stopped`).
+ * It is checked before each poll and again when `device.lost` resolves, so neither a
+ * pending poll nor a late device loss emits after the collector has stopped.
+ *
+ * @param ctx Collector context (config + `emit`).
+ * @param getDevice Returns the WebGPU device, or `undefined`/`null` while it is
+ *   still initializing or on WebGL (where it never appears — a clean no-op). Must
+ *   not throw; read the field defensively (optional chaining).
+ * @param isActive Returns `false` once the collector has been torn down.
+ * @param options Polling bounds (mainly for tests).
+ */
+export declare function wireGpuDeviceLost(ctx: CollectorContext, getDevice: () => GpuDeviceLostLike | undefined | null, isActive: () => boolean, options?: WireGpuDeviceLostOptions): void;
+/**
+ * Shared **rate-limited rollup** for the noisy `graphics_diagnostic` signals
+ * (ADR 0021 part 2 decision 4 / ADR 0012): a burst of incidents coalesces into one
+ * `count`-bearing event instead of flooding ingestion. Tracks `count` plus the first
+ * representative payload; `emit` composes the event from those. Used by both
+ * `wireGpuUncapturedError` and `wireGlErrorSampling` so the aggregation logic lives once.
+ */
+export interface DiagnosticRollup<T> {
+    /** Record one incident, capturing `first` on the very first record of a window. */
+    record(first: T): void;
+    /** Incidents accumulated in the current (un-flushed) window. */
+    readonly count: number;
+    /** Emit one aggregated event (if any) and reset the window. */
+    flush(): void;
+    /** Begin a bounded auto-flush interval. */
+    start(intervalMs: number): void;
+    /** Clear the interval and flush any remaining incidents. */
+    stop(): void;
+}
+export declare function createDiagnosticRollup<T>(emit: (count: number, first: T | undefined) => void): DiagnosticRollup<T>;
+/**
+ * Structural view of a WebGPU `GPUError` (the value carried on an
+ * `uncapturederror` event). Declared locally so the helper stays dependency-free.
+ * The subtype is detected by constructor name to avoid depending on `@webgpu/types`.
+ *
+ * @see https://www.w3.org/TR/webgpu/#gpuerror
+ */
+export interface GpuErrorLike {
+    /** Human-readable detail. Length-capped before it rides on a rollup. */
+    message?: string;
+    /** Set on the concrete error class; used to detect out-of-memory vs validation. */
+    constructor?: {
+        name?: string;
+    };
+}
+/** Structural view of the one WebGPU `uncapturederror` event field we read. */
+interface GpuUncapturedErrorEventLike {
+    error?: GpuErrorLike;
+}
+/**
+ * The subset of `EventTarget` we use on a WebGPU device. Declared structurally so
+ * connectors keep their engine a peer dependency and stay version-tolerant.
+ */
+export interface GpuDeviceErrorTargetLike {
+    addEventListener?: (type: "uncapturederror", listener: (e: GpuUncapturedErrorEventLike) => void) => void;
+    removeEventListener?: (type: "uncapturederror", listener: (e: GpuUncapturedErrorEventLike) => void) => void;
+}
+/** Tuning for the rate-limited `uncapturederror` rollup. */
+export interface WireGpuUncapturedErrorOptions extends WireGpuDeviceLostOptions {
+    /**
+     * How often, in ms, to flush an accumulated rollup mid-session. Defaults to
+     * 30s. A flush also runs unconditionally at teardown. Set bursts coalesce into
+     * one event per interval, so an error storm cannot flood ingestion.
+     */
+    flushIntervalMs?: number;
+}
+/**
+ * Wire WebGPU `uncapturederror` into a **rate-limited per-session rollup**
+ * (ADR 0021 part 2, decision 4 / ADR 0012). This is the highest-volume diagnostic,
+ * so the default — and only — emission is aggregated: a burst of errors becomes a
+ * single `graphics_diagnostic` carrying `count: N` plus the first message, never N
+ * discrete events. Shared and engine-agnostic so every connector (Babylon, three,
+ * …) hands a device *getter* here and the gating, subtype mapping, length-cap,
+ * aggregation, and flush cadence live in exactly one place.
+ *
+ * Behavior:
+ * - **Opt-in gate.** No-ops unless `ctx.config.captureGraphicsDiagnostics` is on.
+ * - **Async device init.** Polls the getter (bounded, same as {@link wireGpuDeviceLost})
+ *   until the WebGPU device appears, so a backend that builds its device async
+ *   (three `renderer.init()`/`renderAsync`, Babylon `initAsync`) isn't missed.
+ * - **Subtype.** `GPUOutOfMemoryError` → `out-of-memory` (`severity: error`);
+ *   anything else → `validation` (`severity: warning`). The most severe category
+ *   seen wins for the rollup; the first message is kept.
+ * - **Rollup.** Accumulates `count` + first `message` and flushes one event on a
+ *   bounded interval and again at teardown; emits nothing if no error occurred.
+ * - **Privacy.** `message` is truncated to {@link LIMITS.maxGraphicsDiagnosticMessageLength}
+ *   and rides through `ctx.emit` (so `beforeSend` applies); raw shader source is excluded.
+ *
+ * @returns A teardown function that removes the listener, clears the timer, and
+ *   flushes any pending rollup. Connectors call it from `stop()`/dispose.
+ * @param getDevice Returns the WebGPU device, or `undefined`/`null` while it is
+ *   still initializing or on WebGL (a clean no-op). Must not throw.
+ * @param isActive Returns `false` once the collector is torn down — nothing emits after.
+ */
+export declare function wireGpuUncapturedError(ctx: CollectorContext, getDevice: () => GpuDeviceErrorTargetLike | undefined | null, isActive: () => boolean, options?: WireGpuUncapturedErrorOptions): () => void;
+/** Backends a shader/getError diagnostic can be tagged with. */
+type ShaderBackend = "webgl" | "webgl2" | "webgpu";
+/** Tuning for shader-compile capture (mainly for tests). */
+export interface ShaderDiagnosticsOptions {
+    /** Max shader-compile diagnostics emitted per session (storm guard). Default 25. */
+    maxIncidents?: number;
+}
+/**
+ * Build a `graphics_diagnostic` for a shader compile/link **failure**. Pure and
+ * redaction-aware: the engine info log is the message (length-capped); raw shader
+ * `source` is appended **only** when the deployer opted in via `captureShaderSource`
+ * (ADR 0021 part 2 — source is application IP). Either way the result is capped to
+ * the schema limit and still rides through `beforeSend`.
+ */
+export declare function buildShaderCompileDiagnostic(input: {
+    infoLog?: string;
+    source?: string;
+    backend?: ShaderBackend;
+    captureShaderSource: boolean;
+}): {
+    type: "graphics_diagnostic";
+    severity: "error";
+    category: "shader-compile";
+    backend?: ShaderBackend;
+    message?: string;
+};
+/** Structural view of the WebGL context fields we read for shader diagnostics. */
+export interface WebGlShaderContextLike {
+    COMPILE_STATUS: number;
+    LINK_STATUS: number;
+    compileShader(shader: object): void;
+    linkProgram(program: object): void;
+    getShaderParameter(shader: object, pname: number): unknown;
+    getProgramParameter(program: object, pname: number): unknown;
+    getShaderInfoLog(shader: object): string | null;
+    getProgramInfoLog(program: object): string | null;
+    getShaderSource?(shader: object): string | null;
+}
+/**
+ * Capture WebGL shader compile and program link **failures** as
+ * `graphics_diagnostic` (`category: shader-compile`). Wraps the context's
+ * `compileShader`/`linkProgram`; on a failed status it reads the matching info log
+ * (and, when `captureShaderSource` is on, the shader source) and emits one capped,
+ * redactable diagnostic. Bounded per session so a build loop cannot flood ingestion.
+ *
+ * Opt-in: no-ops unless `ctx.config.captureGraphicsDiagnostics`. Returns a detach
+ * fn that restores the original methods.
+ */
+export declare function wireGlShaderDiagnostics(ctx: CollectorContext, gl: WebGlShaderContextLike, isActive: () => boolean, options?: ShaderDiagnosticsOptions): () => void;
+/** Structural view of the WebGPU device + module fields we read for shader info. */
+export interface WebGpuShaderDeviceLike {
+    createShaderModule(descriptor: {
+        code?: string;
+    }): WebGpuShaderModuleLike;
+}
+interface WebGpuShaderModuleLike {
+    getCompilationInfo?: () => Promise<{
+        messages?: ReadonlyArray<{
+            type?: string;
+            message?: string;
+        }>;
+    }>;
+    compilationInfo?: () => Promise<{
+        messages?: ReadonlyArray<{
+            type?: string;
+            message?: string;
+        }>;
+    }>;
+}
+/**
+ * Capture WebGPU shader-module compile errors as `graphics_diagnostic`
+ * (`category: shader-compile`). Wraps `device.createShaderModule` and inspects the
+ * module's async `compilationInfo()` for `error` messages. Source (`descriptor.code`)
+ * is included only when `captureShaderSource` is on. Opt-in + bounded; returns detach.
+ */
+export declare function wireGpuShaderDiagnostics(ctx: CollectorContext, device: WebGpuShaderDeviceLike, isActive: () => boolean, options?: ShaderDiagnosticsOptions): () => void;
+/** Tuning for opportunistic `gl.getError()` sampling. */
+export interface GlErrorSamplingOptions {
+    /** Sampling interval in ms. Default 5000. NEVER per-frame (ADR forbids a sync stall). */
+    intervalMs?: number;
+}
+/** Structural view of the one method we poll: `gl.getError()`. */
+export interface WebGlErrorContextLike {
+    getError(): number;
+}
+/**
+ * Opportunistically **sample** `gl.getError()` and emit a rate-limited rollup
+ * `graphics_diagnostic` (`category: validation`, ADR 0021 part 2). Runs on a low-rate
+ * timer — never per-frame, since `getError()` forces a sync GPU stall (ADR forbids it).
+ * Non-`NO_ERROR` results are aggregated into a single `count`ed event flushed on the
+ * next tick (and on teardown), so a storm cannot flood ingestion. WebGPU has no
+ * `getError`, so passing nothing makes this a clean no-op.
+ *
+ * Opt-in: no-ops unless `captureGraphicsDiagnostics`. Returns a detach fn that flushes
+ * any pending rollup and clears the timer.
+ */
+export declare function wireGlErrorSampling(ctx: CollectorContext, gl: WebGlErrorContextLike, isActive: () => boolean, options?: GlErrorSamplingOptions): () => void;
+/**
+ * The result a connector's context-creation probe hands to
+ * {@link wireContextCreationFailure}. Connectors read their engine/renderer
+ * structurally (to keep the engine a peer dependency) and reduce it to this small,
+ * engine-agnostic shape.
+ */
+export interface ContextCreationProbe {
+    /**
+     * `true` when the engine could not obtain a usable GL/WebGPU context or adapter
+     * (e.g. `getContext()` / `requestAdapter()` returned null, or no backend is
+     * usable). `false` for a healthy context — the common case, a clean no-op.
+     */
+    failed: boolean;
+    /** The API that failed, when determinable; omit/`unknown` when it can't be told. */
+    backend?: GraphicsApi;
+    /** Optional engine/driver detail. Length-capped before emit. */
+    message?: string;
+}
+/**
+ * Emit a one-shot context-creation failure as a `graphics_diagnostic`
+ * (ADR 0021 part 2, `category: "context-loss"`, `severity: "fatal"`) when a
+ * connector cannot obtain a rendering context/adapter at init. Engine-agnostic:
+ * every connector reduces its backend-specific check to a {@link ContextCreationProbe}
+ * so the gating, length-cap, and event shape live in exactly one place.
+ *
+ * Behavior:
+ * - **Opt-in gate.** No-ops unless `ctx.config.captureGraphicsDiagnostics` is on
+ *   (mirroring {@link wireGpuDeviceLost}; `context_lost` runtime loss stays
+ *   always-on, this *creation* case is the richer opt-in diagnostic).
+ * - **Discrete marker.** Emits a single incident with no `count`: a creation
+ *   failure is rare and decisive, so the high-fidelity marker is the right default.
+ * - **Backend.** `unknown` when the connector can't determine which API failed
+ *   (no context means little to introspect).
+ * - **Ordering.** Connectors call this at `start()`. The client sets `started`
+ *   before running collectors, so the marker queues right after `session_start`
+ *   and is flushed by the normal cadence even though no transport round-trip has
+ *   happened yet.
+ * - **Privacy.** Any `message` is truncated to
+ *   {@link LIMITS.maxGraphicsDiagnosticMessageLength} and rides `ctx.emit`, which
+ *   applies the client's `beforeSend` for deployer-owned redaction.
+ *
+ * @param ctx Collector context (config + `emit`).
+ * @param probe The connector's context-creation result. Must not throw; read the
+ *   engine defensively (optional chaining) and pass `{ failed: false }` on doubt.
+ */
+export declare function wireContextCreationFailure(ctx: CollectorContext, probe: ContextCreationProbe): void;
+export {};
+//# sourceMappingURL=graphicsDiagnostics.d.ts.map

package/dist/graphicsDiagnostics.d.ts.map

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