@kymoscope/sdk 0.3.0 → 0.5.0

package/dist/types/lib/live/clockMap.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Data-stream time → wall time (Unix seconds), for syncing a camera with a data stream.
+ * Senders that stamp samples with Unix seconds (t > 1e9) need no map: "exact". Others
+ * get an estimate: the minimum over a sliding window of (arrival − last sample time of
+ * the message), i.e. the clock offset plus the smallest network delay seen: "approx".
+ */
+export type ClockQuality = 'exact' | 'approx' | 'none';
+export declare class ClockMap {
+    private samples;
+    private exact;
+    private windowS;
+    constructor(windowS?: number);
+    /** A data message arrived at wall time `arrival` (s) whose last sample has stream time `t`. */
+    observe(t: number, arrival: number): void;
+    quality(): ClockQuality;
+    /** Stream time → wall seconds; `offsetMs` is the user's manual correction. */
+    toWall(t: number, offsetMs?: number): number | null;
+    /** Wall seconds → stream time (to draw the "frame shown" marker on a chart). */
+    toStream(wall: number, offsetMs?: number): number | null;
+}

package/dist/types/lib/live/crypto.d.ts

@@ -15,6 +15,9 @@ export interface EncryptedEnvelope {
     iv: string;
     ciphertext: string;
 }
+/** An open stream's password (visibility 'open', spec 2026-10-31-stream-access-model): anyone watches with nothing
+ *  typed, so its key derives from this published text. Not end-to-end encrypted, by design. Same in Python and plugins. */
+export declare const OPEN_STREAM_PASSWORD = "kymoscope-open-stream-v1";
 /** Random 16-byte KDF salt, base64-encoded. Stored server-side; not secret. */
 export declare function generateSalt(): string;
 /** Derive an AES-256-GCM key from a passphrase + base64 salt via PBKDF2. */
@@ -117,6 +120,13 @@ export declare function deviceFingerprint(publicKey: string): Promise<string>;
 export declare const WORKBOOK_EXPORT_AAD = "kymoscope-workbook-export-v2";
 export declare const workbookBodyAad: (workbookId: string, version: number) => string;
 export declare const workbookKeyAad: (workbookId: string, projectId: string, epoch: number) => string;
+/** A collector's day-history key sealed under the project key (resource_keys 'history_key'). Python twin:
+ *  kymoscope.crypto.history_key_aad. */
+export declare const historyKeyAad: (keyId: string, projectId: string, epoch: number) => string;
+/** A project's config key (alert rules) sealed under the project key: resource_keys 'project_config', id = the project. */
+export declare const projectConfigKeyAad: (projectId: string, epoch: number) => string;
+/** An alert rule's kyr/1 body sealed under its project's config key: bound to the rule, its version and project. */
+export declare const alertRuleAad: (ruleId: string, version: number, projectId: string) => string;
 export declare const recoveryKeyAad: (orgId: string, deviceId: string) => string;
 /** The recovery attestation: SHA-256 of the recovery public key sealed under a project key (plan Decision 30). */
 export declare const recoveryAttestationAad: (orgId: string, projectId: string, epoch: number) => string;

package/dist/types/lib/live/publisher.d.ts

@@ -0,0 +1,168 @@
+/**
+ * A browser sender of Live Streams: the TypeScript port of the Python sender's protocol
+ * (packages/python/src/kymoscope/stream.py LiveStream + _RelayTransport, client.py). Generic over the
+ * message kind: the caller hands plaintext to send(kind, plaintext) and the publisher seals and publishes it.
+ *
+ * stream-token (`x-api-key`: the key's auth part) gives a `pt.` token; register and every heartbeat
+ * (stream-publisher) give the `pp.` ticket the relay's publish socket takes. A password stream's key
+ * derives from the API key's secret part, which never leaves this side, and goes to the owner's browsers
+ * sealed to each (device wraps). A key of an end-to-end encrypted project makes this sender a device of
+ * the project: nothing is published until a member's browser approves it, then a random stream key goes
+ * up sealed under the project key and messages carry the key id (epoch & 0xff).
+ *
+ * Persisted key material stays as non-extractable CryptoKeys: an e2ee stream key is kept with its
+ * project wrap ({iv, ct}, not secret), which a restart within the epoch uploads again instead of
+ * re-sealing raw bytes it no longer has.
+ */
+import { type SealedKey } from './crypto';
+/** What a sender keeps across restarts (per API key). Device and stream keys only count for `apiKeyId`. */
+export interface PublisherState {
+    apiKeyId: string | null;
+    streamId: string;
+    salt: string;
+    /** An e2ee project's sender device (non-extractable private key). */
+    device: {
+        privateKey: CryptoKey;
+        publicKey: string;
+    } | null;
+    /** An e2ee stream key, reused only within its epoch, with its project wrap. */
+    streamKey: {
+        epoch: number;
+        key: CryptoKey;
+        sealed: SealedKey;
+    } | null;
+}
+export interface PublisherDeps {
+    fetch: typeof fetch;
+    WebSocket: typeof WebSocket;
+    /** ms epoch */
+    now: () => number;
+    store: {
+        load(): Promise<PublisherState | null>;
+        save(s: PublisherState): Promise<void>;
+    };
+}
+export interface PublisherOptions {
+    supabaseUrl: string;
+    apiKey: string;
+    name: string;
+    kind: 'data' | 'camera';
+    /** Where the stream goes is the API key's: a project's key publishes into that project, a personal key a personal stream. */
+    visibility?: 'private' | 'public' | 'open';
+    /** The stream password viewers type (spec 2026-10-31-stream-access-model); default: the API key's secret. 'open'
+     *  streams take none: anyone watches them (a published password; not end-to-end encrypted). */
+    password?: string;
+    /** The caller's own data stream a camera belongs to (required for kind 'camera'); its placement comes from it. */
+    parentStreamId?: string;
+    /** A camera's low layer (360p, for small panels and camera walls): `layer: 'low'` with `lowOf`, its high camera's
+     *  stream id (same parent). Both or neither. */
+    layer?: 'low';
+    lowOf?: string;
+}
+export type PublisherStatus = {
+    phase: 'registering';
+} | {
+    phase: 'waiting_approval';
+} | {
+    phase: 'live';
+    viewers: number;
+} | {
+    phase: 'reconnecting';
+} | {
+    phase: 'refused';
+    code: string;
+    message: string;
+};
+export declare class LivePublisher {
+    private readonly opts;
+    private readonly deps;
+    private readonly auth;
+    private readonly secret;
+    /** What the stream key derives from: the stream password, the open streams' published one, or the API key's secret. */
+    private readonly password;
+    private token;
+    private ticket;
+    /** The current ticket says rec (the reply's `recording`); `authRec`: the one the open socket authenticated with. */
+    private ticketRec;
+    private authRec;
+    private relayUrl;
+    private apiKeyId;
+    private projectId;
+    private e2ee;
+    private sid;
+    private salt;
+    private key;
+    /** A password stream's raw key, for device wraps (derivable from the secret anyway). */
+    private raw;
+    private epoch;
+    private haveKey;
+    private sealed;
+    private device;
+    private senderDeviceId;
+    private deviceRetried;
+    private maxBytesPerSec;
+    private maxMessageBytes;
+    private ws;
+    private open;
+    private everOpen;
+    private connectedAt;
+    private authAt;
+    private delay;
+    private lastToken;
+    private viewerCount;
+    private busy;
+    private stopped;
+    private refusal;
+    private heartbeatTimer;
+    private pingTimer;
+    private retryTimer;
+    private readonly statusFns;
+    private readonly viewerFns;
+    private lastStatus;
+    constructor(opts: PublisherOptions, deps: PublisherDeps);
+    /** The registered stream id (null until start() registers). */
+    get streamId(): string | null;
+    /** The relay's viewer count (0 while disconnected). */
+    get viewers(): number;
+    /** Bytes/second the account negotiated (0: not limited) and the relay's message size limit. */
+    get limits(): {
+        maxBytesPerSec: number;
+        maxMessageBytes: number;
+    };
+    onStatus(fn: (s: PublisherStatus) => void): () => void;
+    onViewers(fn: (n: number) => void): () => void;
+    /** Mint, register (reusing a persisted stream id and salt), open the socket, heartbeat. Rejects when
+     *  registration fails; a 4xx (a refusal) also sets status `refused`. */
+    start(): Promise<void>;
+    /** Seal with the current stream key (the key id of its epoch when e2ee) and send; false if not sent
+     *  (no key yet, socket down, stopped). */
+    send(kind: number, plaintext: Uint8Array): Promise<boolean>;
+    /** Close the socket and stop the timers. The stream stays registered (never deleted here). */
+    stop(): void;
+    private post;
+    private mint;
+    private call;
+    private register;
+    private senderDevice;
+    /** Token refresh, then the heartbeat (each new ticket also refreshes the socket). 401/403 stop the
+     *  publisher (revoked key, plan, stale_epoch); anything else is retried on the next interval. */
+    private housekeeping;
+    /** Seal the stream key to the owner's browsers that lack it (password streams), at most 50 per call. */
+    private wrapFor;
+    /** The project key arrived: seal the stream key under it; a new epoch (rotation) gets a new stream key.
+     *  A key this device can't open re-registers once with a new device key. */
+    private applyProject;
+    private reregister;
+    private save;
+    private connect;
+    private disconnect;
+    /** Reconnect: at once after a stable connection, else after the backoff (1 s doubling to 10 s). */
+    private dropped;
+    /** Use `ticket` from now on; re-authenticate the open socket in-band when due, or at once when it
+     *  says rec and the socket's ticket didn't. */
+    private setTicket;
+    private setViewers;
+    private refuse;
+    private status;
+    private emit;
+}

package/dist/types/lib/live/types.d.ts

@@ -3,6 +3,8 @@ import type { EncryptedEnvelope } from './crypto';
 import type { LiveColumnsBlock, LiveMessage } from './buffer';
 import type { LiveDataSource } from '../data/liveDataSource';
 import type { Dataset } from '../parseDataset';
+import type { VideoTrack } from './videoTrack';
+import type { ClockMap } from './clockMap';
 /** What a viewer needs to join an encrypted relay stream (from the stream registry). */
 export interface LiveStreamDescriptor {
     id: string;
@@ -12,7 +14,7 @@ export interface LiveStreamDescriptor {
     /** Encrypted marker proving the password is right before any frame arrives. */
     key_check: EncryptedEnvelope;
     owner_name?: string;
-    visibility?: 'private' | 'public' | 'org' | 'project';
+    visibility?: 'private' | 'public' | 'org' | 'project' | 'open';
     org_name?: string | null;
     /** Null when the viewer can't see the project's name. */
     project_name?: string | null;
@@ -21,6 +23,12 @@ export interface LiveStreamDescriptor {
      * owner hosts). The engine's `getToken` is still asked for the credential.
      */
     relay_url?: string | null;
+    /** A camera stream carries encoded video (KIND_VIDEO), not samples. Default 'data'. */
+    kind?: 'data' | 'camera';
+    /** A camera's data stream (a camera is a channel of it); null/absent for data streams. */
+    parent_stream_id?: string | null;
+    /** A camera's low layer (360p, for small panels and walls): its high camera's id; null/absent otherwise. */
+    low_of_stream_id?: string | null;
 }
 /**
  * The keys of a stream in an end-to-end encrypted project: frames name their key id
@@ -57,15 +65,25 @@ export interface LiveConnection {
     id: string;
     name: string;
     ownerName: string;
-    visibility: 'private' | 'public' | 'org' | 'project';
+    visibility: 'private' | 'public' | 'org' | 'project' | 'open';
     orgName: string | null;
     projectName?: string | null;
+    kind: 'data' | 'camera';
+    /** A camera's data stream (LiveStreamDescriptor.parent_stream_id); null for data streams. */
+    parentId: string | null;
+    /** A camera's low layer: its high camera's id (LiveStreamDescriptor.low_of_stream_id); null otherwise. */
+    lowOf: string | null;
+    /** A camera's encoded video (the same instance for the connection's life); null for data. */
+    video: VideoTrack | null;
+    /** A data stream's time → wall time map (to sync cameras with it); null for cameras. */
+    clock: ClockMap | null;
     /** Slow (~1 Hz) snapshot for column discovery / count / non-multiband charts. */
     dataset: Dataset;
     /** Live decimation source read by the multiband chart every frame (no React). */
     source: LiveDataSource;
     rowCount: number;
-    status: 'connecting' | 'live' | 'stale' | 'error';
+    /** 'idle': a camera no panel shows (connected, not downloading). */
+    status: 'idle' | 'connecting' | 'live' | 'stale' | 'error';
     error: string | null;
     /** When a recording is running: its start time (ms since epoch). */
     recordingSince: number | null;

package/dist/types/lib/live/videoTrack.d.ts

@@ -0,0 +1,96 @@
+import type { VideoMessage } from './videoWire';
+/** One complete encoded access unit (H.264), never a decoded frame. */
+export interface EncodedUnit {
+    t: number;
+    seq: number;
+    key: boolean;
+    data: Uint8Array;
+    arrivedAt: number;
+}
+export interface VideoTrackInfo {
+    width: number;
+    height: number;
+    codec: string;
+    latestT: number | null;
+    lagMs: number | null;
+    units: number;
+    bytes: number;
+}
+/**
+ * A camera's video as the Camera panel plays it: a live camera connection's ring (kind 'live'), or a camera
+ * recorded with a cloud recording (kind 'recorded', RecordedVideoSource). Listed by engine.video.sources().
+ */
+export interface VideoSource {
+    /** The camera stream's id (the same for its live connection and its recordings). */
+    id: string;
+    name: string;
+    kind: 'live' | 'recorded';
+    /** The camera's data stream id; null when unknown. */
+    parentId: string | null;
+    /** Live: a camera's low layer names its high camera (the Camera panel picks the layer; pickers skip it). */
+    lowOf?: string | null;
+    /** Recorded: the parent data stream's name, for labels when that stream isn't connected. */
+    parentName?: string | null;
+    /** Recorded: the data recording it was recorded with (that dataset's info.meta.recordingId). */
+    recordingId?: string | null;
+    info(): VideoTrackInfo;
+    /** Earliest and latest capture times (Unix s), or null. */
+    range(): [number, number] | null;
+    /** Units to decode to show the frame at capture time `t` (Unix s): the last keyframe <= t through the last unit <= t. */
+    seekPlan(t: number): EncodedUnit[] | Promise<EncodedUnit[]>;
+    /** Live: the newest keyframe and everything after it. */
+    livePlan?(): EncodedUnit[];
+    /** Live: each new unit; returns an unsubscribe. */
+    onUnit?(fn: (u: EncodedUnit) => void): () => void;
+    /** Live: hold the video while it is shown; returns the release. */
+    acquire?(): () => void;
+    /** Recorded: resolves once the codec is known (info().codec). */
+    ready?(): Promise<void>;
+}
+/** A live camera connection's track as a VideoSource (the same object per track while id/name/parent stay). */
+export declare function liveVideoSource(c: {
+    id: string;
+    name: string;
+    parentId: string | null;
+    lowOf?: string | null;
+    video: VideoTrack;
+}): VideoSource;
+/** Per-camera ring of encoded units: reassembles fragments, bounds memory at GOP boundaries, plans decodes. */
+export declare class VideoTrack {
+    private ring;
+    private bytes;
+    private needKey;
+    private width;
+    private height;
+    private codec;
+    private pending;
+    private subs;
+    private holders;
+    private demand;
+    private maxBytes;
+    private now;
+    constructor(maxBytes?: number, now?: () => number);
+    /** Feed a decoded KIND_VIDEO message; returns the completed unit, or null while incomplete or discarded. */
+    push(m: VideoMessage): EncodedUnit | null;
+    /** Drop whole GOPs from the front while over budget; the only GOP is never dropped. */
+    private trim;
+    /** Units to decode to show the frame at wall time `t` (unix s): last keyframe <= t through last unit <= t. */
+    seekPlan(t: number): EncodedUnit[];
+    /** The newest keyframe and everything after it. */
+    livePlan(): EncodedUnit[];
+    /** Called with each completed unit added to the ring. Returns an unsubscribe. */
+    onUnit(fn: (u: EncodedUnit) => void): () => void;
+    /**
+     * Hold the video while it is shown (a Camera panel): the connection downloads only while
+     * someone holds it. Returns the release (calling it again does nothing).
+     */
+    acquire(): () => void;
+    /** The connection's hook: called with true when the first holder arrives, false when the last leaves. */
+    onDemandChange(fn: (wanted: boolean) => void): void;
+    info(): VideoTrackInfo;
+    /** Earliest and latest buffered capture times, or null. */
+    range(): [number, number] | null;
+    /** After a gap (e.g. a rejoin): drop the half-received unit and skip deltas until the next keyframe. The ring stays. */
+    resync(): void;
+    clear(): void;
+}

package/dist/types/lib/live/videoWire.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Plaintext of a KIND_VIDEO relay message: one H.264 access unit (Annex B), or one
+ * fragment of it, stamped with its capture time in Unix seconds. A keyframe's first
+ * fragment carries the codec string, so a viewer joining mid-stream configures its
+ * decoder from it (Annex B keyframes carry SPS/PPS). Byte-compatible with
+ * packages/python/src/kymoscope/wire.py (encode_video / decode_video).
+ */
+export declare const VIDEO_VERSION = 1;
+export declare const VIDEO_CODEC_H264 = 1;
+/** Fragments stay under the cloud relay's 1 MiB message limit with room for the header and seal. */
+export declare const VIDEO_MAX_FRAGMENT: number;
+export interface VideoMessage {
+    key: boolean;
+    last: boolean;
+    t: number;
+    seq: number;
+    fragIndex: number;
+    fragCount: number;
+    width: number;
+    height: number;
+    codec: string;
+    payload: Uint8Array;
+}
+export declare function encodeVideo(m: VideoMessage): Uint8Array;
+export declare function decodeVideo(b: Uint8Array): VideoMessage | null;
+/** One access unit as the plaintexts to seal, split to VIDEO_MAX_FRAGMENT. */
+export declare function fragmentVideo(au: {
+    key: boolean;
+    t: number;
+    seq: number;
+    width: number;
+    height: number;
+    codec: string;
+    data: Uint8Array;
+}): Uint8Array[];

package/dist/types/lib/live/wire.d.ts

@@ -6,6 +6,10 @@ export declare const KIND_COLUMNS = 3;
 export declare const KIND_BLOCK = 4;
 /** The channel table KIND_BLOCK messages refer to (see blockWire.ts). */
 export declare const KIND_BLOCK_SCHEMA = 5;
+/** One encoded video access unit or a fragment of one (see videoWire.ts). */
+export declare const KIND_VIDEO = 6;
+/** Each channel's last value and its time, against a KIND_BLOCK_SCHEMA (see blockWire.ts). */
+export declare const KIND_LAST_VALUES = 7;
 export declare const KEY_ID_FLAG = 128;
 export interface SealedMessage {
     kind: number;

package/dist/types/lib/panelChartSettings.d.ts

@@ -372,12 +372,24 @@ export interface GanttPanelChartSettings {
     gtEndCol: string;
     gtGroupCol: string;
 }
+export interface CameraPanelSettings {
+    kind: 'camera';
+    /** The camera stream's id; '' until chosen. Always the first of `cameras` (kept for settings saved before walls). */
+    cameraStreamId: string;
+    /** The cameras shown, in order (up to MAX_PANEL_CAMERAS): two or more make a wall. See panelCameras. */
+    cameras: string[];
+    /** The data stream this camera syncs with; '' = its own stream (the camera's parent) when connected, else the first live data stream. */
+    syncStreamId: string;
+    /** Manual correction, ms (−10000..10000). */
+    offsetMs: number;
+    fit: 'contain' | 'cover';
+}
 /** Settings every chart kind has besides its own. */
 export interface CommonPanelChartSettings {
     /** Marks drawn over the chart (text, brush, arrows, boxes, lines). */
     annotations?: ChartAnnotation[];
 }
-export type PanelChartSettings = CommonPanelChartSettings & (MultibandPanelChartSettings | XyPanelChartSettings | XyzPanelChartSettings | HistogramPanelChartSettings | PolarPanelChartSettings | SpectrumPanelChartSettings | BoxPlotPanelChartSettings | SpectrogramPanelChartSettings | HeatmapPanelChartSettings | ViolinPanelChartSettings | ConfusionPanelChartSettings | RocPanelChartSettings | LossCurvePanelChartSettings | ControlChartPanelChartSettings | ParallelCoordsPanelChartSettings | EmbeddingPanelChartSettings | FlameGraphPanelChartSettings | BarChartPanelChartSettings | RadarPanelChartSettings | AreaChartPanelChartSettings | CdfChartPanelChartSettings | BubbleChartPanelChartSettings | TreemapPanelChartSettings | SankeyPanelChartSettings | CalibrationPanelChartSettings | GaugePanelChartSettings | QQPlotPanelChartSettings | GanttPanelChartSettings);
+export type PanelChartSettings = CommonPanelChartSettings & (MultibandPanelChartSettings | XyPanelChartSettings | XyzPanelChartSettings | HistogramPanelChartSettings | PolarPanelChartSettings | SpectrumPanelChartSettings | BoxPlotPanelChartSettings | SpectrogramPanelChartSettings | HeatmapPanelChartSettings | ViolinPanelChartSettings | ConfusionPanelChartSettings | RocPanelChartSettings | LossCurvePanelChartSettings | ControlChartPanelChartSettings | ParallelCoordsPanelChartSettings | EmbeddingPanelChartSettings | FlameGraphPanelChartSettings | BarChartPanelChartSettings | RadarPanelChartSettings | AreaChartPanelChartSettings | CdfChartPanelChartSettings | BubbleChartPanelChartSettings | TreemapPanelChartSettings | SankeyPanelChartSettings | CalibrationPanelChartSettings | GaugePanelChartSettings | QQPlotPanelChartSettings | GanttPanelChartSettings | CameraPanelSettings);
 /** Parse optional axis range from min/max strings (same rules as App useMemo). */
 export declare function parseOptionalAxisRange(minStr: string, maxStr: string): [number, number] | undefined;
 /** Keep in sync with `savedLayout.ts` defaults. */
@@ -412,8 +424,35 @@ export declare function defaultGaugePanelSettings(): GaugePanelChartSettings;
 export declare function defaultCalibrationPanelSettings(): CalibrationPanelChartSettings;
 export declare function defaultQQPlotPanelSettings(): QQPlotPanelChartSettings;
 export declare function defaultGanttPanelSettings(): GanttPanelChartSettings;
+/** A camera in pickers: "Bench 3 · Camera 1" (its data stream's name: connected, or a recorded camera's parentName),
+ *  else the camera's own name. */
+export declare function cameraLabel(cam: {
+    name: string;
+    parentId?: string | null;
+    parentName?: string | null;
+}, live: readonly {
+    id: string;
+    name: string;
+}[]): string;
+export declare const defaultCameraPanelSettings: () => CameraPanelSettings;
+/** A Camera panel shows at most this many cameras (a 3x3 wall). */
+export declare const MAX_PANEL_CAMERAS = 9;
+/** The cameras a Camera panel shows: `cameras` while it starts with cameraStreamId, else just cameraStreamId
+ *  (a host that sets only cameraStreamId, as before walls, gets that one camera). */
+export declare function panelCameras(s: Pick<CameraPanelSettings, 'cameraStreamId' | 'cameras'>): string[];
 /** An alarm line from untrusted input, or null. */
 export declare function coerceAlarmLine(v: unknown): AlarmLine | null;
+/** What a linked line shows for its rule: the rule's threshold, and whether the rule is active now. */
+export interface LinkedRuleLine {
+    value: number;
+    active: boolean;
+}
+/**
+ * Lines linked to rules the runtime holds draw the rule's threshold and state (`linked`). Walks the four alarm
+ * places (multiband series, the simple kinds' alarm field, gauge rows, X-Y / X-Y-Z axes). Returns `s` itself when no
+ * line resolves, so memoised charts don't redraw.
+ */
+export declare function resolveLinkedAlarms(s: PanelChartSettings, rules: ReadonlyMap<string, LinkedRuleLine>): PanelChartSettings;
 /** The setting holding the alarm line of the chart kinds whose frame draws it. */
 export declare const CHART_ALARM_FIELDS: {
     readonly histogram: "histAlarm";

package/dist/types/lib/recordings/export.d.ts

@@ -15,6 +15,7 @@ export interface ExportOptions {
 export declare const EXPORT_TYPES: {
     readonly csv: "text/csv";
     readonly mf4: "application/octet-stream";
+    readonly parquet: "application/vnd.apache.parquet";
 };
 /**
  * A recording as a CSV or MF4 file, built in the browser from its encrypted chunks and handed to `write` piece by

package/dist/types/lib/recordings/videoSource.d.ts

@@ -0,0 +1,56 @@
+import { type MessageKey } from '../live/wire';
+import type { EncodedUnit, VideoSource, VideoTrackInfo } from '../live/videoTrack';
+export interface RecordedVideoSourceOptions {
+    /** The camera stream's id (what a Camera panel's cameraStreamId names). */
+    id: string;
+    name: string;
+    /** The camera's data stream id. */
+    parentId: string | null;
+    /** The data stream's name (labels "Stream · Camera" when that stream isn't connected). */
+    parentName?: string | null;
+    /** The data recording the camera was recorded with: the recording dataset's info.meta.recordingId. */
+    recordingId: string;
+    /** The camera recording's chunks: relay times (ms since epoch) of each one's first and last message. */
+    chunks: {
+        seq: number;
+        t0: number;
+        t1: number;
+    }[];
+    fetchChunk(seq: number): Promise<ArrayBuffer>;
+    /** The camera's key(s). */
+    open: MessageKey;
+    /** Decoded units kept, in bytes (default 256 MB); least recently used chunks go first. */
+    maxBytes?: number;
+}
+export declare class RecordedVideoSource implements VideoSource {
+    readonly kind: "recorded";
+    readonly id: string;
+    readonly name: string;
+    readonly parentId: string | null;
+    readonly parentName: string | null;
+    readonly recordingId: string;
+    private chunks;
+    private fetch;
+    private open;
+    private maxBytes;
+    /** By chunk index, least recently used first. */
+    private cache;
+    /** Settled entries: [bytes, units]. */
+    private sizes;
+    private bytes;
+    private width;
+    private height;
+    private codec;
+    private waiting;
+    constructor(o: RecordedVideoSourceOptions);
+    private parse;
+    private parsed;
+    private evict;
+    /** Chunk i's units in order, its last one finished from the next chunk; [] when it can't be downloaded. */
+    private units;
+    seekPlan(t: number): Promise<EncodedUnit[]>;
+    /** Resolves once the codec is known (the first keyframe of the first chunks), or they had none. */
+    ready(): Promise<void>;
+    info(): VideoTrackInfo;
+    range(): [number, number] | null;
+}

package/dist/types/lib/render/alertGlyph.d.ts

@@ -0,0 +1,7 @@
+/** A 10 px bell, drawn at the label end of an alarm line linked to an alert rule (canvas and SVG share the path). */
+export declare const ALERT_GLYPH_PATH = "M5 .8a3.1 3.1 0 0 0-3.1 3.1v2.3L.8 7.6h8.4L8.1 6.2V3.9A3.1 3.1 0 0 0 5 .8zM3.9 8.4a1.1 1.1 0 0 0 2.2 0z";
+export declare const ALERT_GLYPH_SIZE = 10;
+/** A linked line is dashed while its rule is active (spec §6.1.1); otherwise it keeps its own style. */
+export declare const ACTIVE_DASH: number[];
+/** Paint the bell with its top-left at (x, y). */
+export declare function drawAlertGlyph(ctx: CanvasRenderingContext2D, x: number, y: number, color: string): void;

package/dist/types/lib/render/glSeries.d.ts

@@ -4,7 +4,7 @@ export interface GpuSeriesStyle {
     bandBottom: number;
     scaleMin: number;
     scaleMax: number;
-    /** Median consecutive |Δx| of the column (0 if unknown): drives gap-splitting. */
+    /** Mean consecutive |Δx| of the column (0 if unknown): drives gap-splitting (see joinGapThresholdForColumn). */
     gapMedian: number;
     /** Line thickness in CSS px; defaults to the renderer's `lineWidth`. */
     width?: number;

package/dist/types/lib/segments/align.d.ts

@@ -0,0 +1,85 @@
+import { type CompareOp } from './rules';
+export type AlignAxis = {
+    kind: 'elapsed';
+    preroll_s?: number;
+} | {
+    kind: 'event';
+    channel: string;
+    op: CompareOp;
+    value: number;
+} | {
+    kind: 'cumulative';
+    channel: string;
+    integral?: boolean;
+} | {
+    kind: 'clock';
+    tz: string;
+};
+export interface AlignedSegment {
+    x: Float64Array;
+    t: Float64Array;
+    cols: Map<string, Float64Array>;
+}
+export interface ReferenceChannel {
+    mean: Float32Array;
+    sd: Float32Array;
+    min: Float32Array;
+    max: Float32Array;
+    n: Uint16Array;
+}
+export interface ReferenceCurve {
+    x: Float64Array;
+    channels: Map<string, ReferenceChannel>;
+}
+export interface Comparison {
+    /** Per sample of the segment: value − reference mean at its X (NaN where either is missing). */
+    delta: Map<string, Float64Array>;
+    /** Highest first: mean |delta| / σ (the grid point's σ with ≥ 2 sources, else the channel's spread over the grid). */
+    score: Array<{
+        channel: string;
+        z: number;
+    }>;
+    /** Runs out of band: from the first sample out to the first sample back in (or the last sample). */
+    deviations: Array<{
+        t0: number;
+        t1: number;
+        channels: string[];
+    }>;
+}
+export declare const MAX_GRID = 8000;
+/** ponytail: channels × grid points of one reference (2.4 MB raw); split references by channel group if a customer needs more. */
+export declare const MAX_BAND_CELLS = 131072;
+export declare function axisColumn(a: AlignAxis, units?: Record<string, string>): {
+    name: string;
+    unit: string;
+};
+export declare function localSeconds(t: number, tz: string): number;
+/** X of one segment's samples, fed in time order: history in one pass, live sample by sample. */
+export declare class AxisState {
+    #private;
+    readonly axis: AlignAxis;
+    constructor(axis: AlignAxis);
+    /** A segment starts at t0 (resets the state). */
+    begin(t0: number): void;
+    /** X at time t; `c` is the axis channel's value there (NaN when it has none). NaN when undefined (live: before an event). */
+    x(t: number, c: number): number;
+}
+/** A segment's samples (t and NaN-padded columns, e.g. wideDay of its pieces) on `axis`; `tstart` is its start. For
+ *  `event` the event is searched over the whole segment first, so samples before it get negative X. */
+export declare function alignSegment(t: Float64Array, cols: Map<string, Float64Array>, tstart: number, axis: AlignAxis): AlignedSegment;
+/** y(x) at the grid points: linear between finite neighbours; NaN outside the data or across a gap wider than 4× the
+ *  median step. Unsorted X (a noisy cumulative tag) is sorted first. */
+export declare function resample(x: Float64Array, y: ArrayLike<number>, grid: Float64Array): Float64Array;
+/** A grid array's value at x (linear; NaN outside the grid or next to a NaN). */
+export declare function gridAt(grid: Float64Array, a: ArrayLike<number>, x: number): number;
+/** The reference of `segs` on a uniform grid of `points` over their X range (one segment: σ 0, n 1). */
+export declare function buildReference(segs: AlignedSegment[], channels: string[], points: number): ReferenceCurve;
+/** A channel's band edges: mean ± k·σ, or min..max. */
+export declare function bandEdges(c: ReferenceChannel, k: number, band: 'sigma' | 'minmax'): {
+    lo: Float32Array;
+    hi: Float32Array;
+};
+export declare function compareToReference(seg: AlignedSegment, ref: ReferenceCurve, k: number, band?: 'sigma' | 'minmax', minS?: number): Comparison;
+/** A reference curve as bytes (plan Formats "Reference band", zlib). */
+export declare function encodeBand(ref: ReferenceCurve, channels: string[]): Uint8Array;
+export declare function decodeBand(bytes: Uint8Array, channels: string[]): ReferenceCurve;