waveform-analysis 0.1.48 → 0.1.51

package/dist/types/core/waveformPointSource.d.ts

@@ -0,0 +1,53 @@
+import type { SingleWaveformData, WaveformPoint, WaveformTypedValues } from '../types';
+export interface WaveformPointRange {
+    start: number;
+    end: number;
+}
+export interface WaveformPointMetrics {
+    xMinimum: number;
+    xMaximum: number;
+    yMinimum: number;
+    yMaximum: number;
+    hasErrorPoints: boolean;
+}
+export interface WorkerSamplingNumericDataset {
+    kind: 'typed';
+    x: Float64Array;
+    y: WaveformTypedValues;
+}
+export interface WorkerSamplingSampleDataset {
+    kind: 'samples';
+    values: WaveformTypedValues;
+    sampleRate: number;
+    startTime: number;
+    /** Present only when invalid input samples created gaps in the original time sequence. */
+    sourceIndexes?: Uint32Array;
+}
+export interface WorkerSamplingPointDataset {
+    kind: 'points';
+    points: readonly WaveformPoint[];
+}
+export type WorkerSamplingDataset = WorkerSamplingNumericDataset | WorkerSamplingSampleDataset | WorkerSamplingPointDataset;
+/**
+ * Internal source abstraction. Compact inputs stay as numeric columns until a caller needs a
+ * specific point object for SVG, hover, or annotation work.
+ */
+export interface WaveformPointSource {
+    readonly length: number;
+    readonly isCompact: boolean;
+    pointAt(index: number): WaveformPoint | undefined;
+    pointsInRange(start?: number, end?: number): WaveformPoint[];
+    visibleRange(domain: [number, number]): WaveformPointRange;
+    nearestPoint(x: number): WaveformPoint | undefined;
+    metrics(includeErrors?: boolean): WaveformPointMetrics;
+    toWorkerDataset(): WorkerSamplingDataset;
+}
+export declare function createWaveformPointSource(data: SingleWaveformData, normalizeObjectData: (value: SingleWaveformData) => WaveformPoint[]): WaveformPointSource;
+export declare function pointSourceFromPoints(points: readonly WaveformPoint[]): WaveformPointSource;
+/**
+ * Keeps existing array-oriented component code compatible while constructing compact points only
+ * when an index is actually read. Native array methods use `has` before indexed reads, so both
+ * iteration and `slice` retain their normal semantics without eagerly allocating point objects.
+ */
+export declare function lazyPointArray(source: WaveformPointSource): WaveformPoint[];
+export declare function isWaveformPointSource(value: unknown): value is WaveformPointSource;

package/dist/types/core/workerSampling/index.d.ts

@@ -0,0 +1,5 @@
+export { javascriptSamplingBackend } from './javascriptBackend';
+export { MultiResolutionSamplingIndex, type MultiResolutionSamplingIndexOptions, } from './multiresolution';
+export { WorkerSamplingRepository, type WorkerSamplingRepositoryOptions } from './repository';
+export { SamplingOutputCache, type SamplingCacheMetrics, type SamplingOutputCacheOptions, } from './samplingCache';
+export { DEFAULT_WORKER_SAMPLING_AUTO_THRESHOLD, DEFAULT_WORKER_SAMPLING_MAX_POINTS_PER_PIXEL, isCurrentWorkerSamplingResponse, type DatasetResponse, type DisposeAllResponse, type FindNearestPointResponse, type SampleViewportResponse, type WorkerSamplingBackend, type WorkerSamplingBackendKind, type WorkerSamplingDatasetMetrics, type WorkerSamplingDiagnostics, type WorkerSamplingOutput, type WorkerSamplingRequest, type WorkerSamplingResponse, type WorkerSamplingSeriesRequest, type WorkerSamplingSeriesResponse, type WorkerSamplingStatus, } from './protocol';

package/dist/types/core/workerSampling/javascriptBackend.d.ts

@@ -0,0 +1,3 @@
+import type { WorkerSamplingBackend } from './protocol';
+/** The phase 3 fallback backend. A future WASM backend implements the same narrow interface. */
+export declare const javascriptSamplingBackend: WorkerSamplingBackend;

package/dist/types/core/workerSampling/multiresolution.d.ts

@@ -0,0 +1,29 @@
+import type { WaveformPoint } from '@/types';
+import type { WorkerSamplingOutput } from './protocol';
+export type IndexedSamplingStrategy = 'none' | 'peak' | 'lttb' | 'average' | 'min' | 'max' | 'minmax' | 'sum';
+export interface MultiResolutionSamplingIndexOptions {
+    /** Bounds one accessed dataset's lazily-built indexes; source points are not included. */
+    maxBytes?: number;
+}
+export declare class MultiResolutionSamplingIndex {
+    private readonly points;
+    private readonly extremaLayers;
+    private readonly sumLayers;
+    private indexBytes;
+    private readonly maxBytes;
+    constructor(points: readonly WaveformPoint[], options?: MultiResolutionSamplingIndexOptions);
+    get byteLength(): number;
+    dispose(): void;
+    sample(start: number, end: number, strategy: IndexedSamplingStrategy, requestedTarget: number): WorkerSamplingOutput | undefined;
+    private allIndexes;
+    private indexes;
+    private extrema;
+    private aggregate;
+    private queryExtrema;
+    private querySum;
+    private ensureExtrema;
+    private ensureSum;
+    private reserve;
+    private isMinimum;
+    private isMaximum;
+}

package/dist/types/core/workerSampling/protocol.d.ts

@@ -0,0 +1,153 @@
+import type { WaveformPoint, WaveformLineType, WaveformPointType, WaveformSamplingBackend, WaveformSamplingDiagnostics, WaveformSamplingMode, WaveformSamplingStrategy } from '@/types';
+import type { WorkerSamplingDataset } from '../waveformPointSource';
+export declare const DEFAULT_WORKER_SAMPLING_AUTO_THRESHOLD = 1000;
+export declare const DEFAULT_WORKER_SAMPLING_MAX_POINTS_PER_PIXEL = 4;
+export type WorkerSamplingBackendKind = WaveformSamplingBackend;
+export type WorkerSamplingStatus = 'ok' | 'stale-revision' | 'wasm-unavailable' | 'not-found';
+export interface WorkerSamplingDatasetMetrics {
+    inputPointCount: number;
+    validPointCount: number;
+    xDomain: [number, number] | null;
+    yDomain: [number, number] | null;
+    /** Current lazily-built multiresolution index allocation for this dataset. */
+    indexBytes?: number;
+}
+export interface WorkerSamplingSourceIndexes {
+    kind: 'source-indexes';
+    sourceIndexes: Uint32Array;
+}
+export interface WorkerSamplingAggregates {
+    kind: 'aggregates';
+    x: Float64Array;
+    y: Float64Array;
+}
+export type WorkerSamplingOutput = WorkerSamplingSourceIndexes | WorkerSamplingAggregates;
+export interface WorkerSamplingBackendRequest {
+    x: Float64Array;
+    y: Float64Array;
+    /** Empty for compact datasets; retained for custom legacy backend compatibility. */
+    points: readonly WaveformPoint[];
+    strategy: Exclude<WaveformSamplingStrategy, 'auto'>;
+    targetPointCount: number;
+}
+export interface WorkerSamplingBackend {
+    readonly kind: Extract<WorkerSamplingBackendKind, 'javascript' | 'wasm'>;
+    sample(request: WorkerSamplingBackendRequest): WorkerSamplingOutput;
+}
+export type WorkerSamplingDiagnostics = WaveformSamplingDiagnostics;
+export interface RegisterDatasetRequest {
+    type: 'register-dataset';
+    requestId: number;
+    datasetId: string;
+    revision: 0;
+    /** Legacy object points remain accepted for repository consumers. */
+    points?: readonly WaveformPoint[];
+    /** Compact numeric columns used by TypedArray chart inputs. */
+    dataset?: WorkerSamplingDataset;
+}
+export interface ReplaceDatasetRequest {
+    type: 'replace-dataset';
+    requestId: number;
+    datasetId: string;
+    revision: number;
+    points?: readonly WaveformPoint[];
+    dataset?: WorkerSamplingDataset;
+}
+export interface WorkerSamplingSeriesRequest {
+    seriesId: string;
+    datasetId: string;
+    revision: number;
+    xDomain: [number, number];
+    /** Optional main-thread hint; the Worker recomputes this from xDomain before sampling. */
+    visibleStartIndex?: number;
+    /** Exclusive visible-range endpoint. */
+    visibleEndIndex?: number;
+    plotWidth: number;
+    mode: WaveformSamplingMode;
+    autoThreshold?: number;
+    /** Interaction-only hysteresis. Omit previousSelectedMode after the interaction for exact bounds. */
+    autoHysteresis?: number;
+    previousSelectedMode?: 'raw' | 'sampled';
+    strategy: WaveformSamplingStrategy;
+    maxPointsPerPixel?: number;
+    rawPointLimit?: number;
+    wasmFailureFallback?: 'error' | 'javascript';
+    /** Rendering inputs that affect the cache key, even when only line geometry is overridden. */
+    lineType?: WaveformLineType;
+    pointType?: WaveformPointType;
+    errorBarVisible?: boolean;
+    pointMinSpacing?: number;
+    errorBarMinSpacing?: number;
+}
+export interface SampleViewportRequest {
+    type: 'sample-viewport';
+    requestId: number;
+    series: readonly WorkerSamplingSeriesRequest[];
+}
+export interface FindNearestPointRequest {
+    type: 'find-nearest-point';
+    requestId: number;
+    datasetId: string;
+    revision: number;
+    x: number;
+}
+export interface GetDatasetMetricsRequest {
+    type: 'get-dataset-metrics';
+    requestId: number;
+    datasetId: string;
+    revision: number;
+}
+export interface DisposeDatasetRequest {
+    type: 'dispose-dataset';
+    requestId: number;
+    datasetId: string;
+    revision: number;
+}
+export interface DisposeAllRequest {
+    type: 'dispose-all';
+    requestId: number;
+}
+export type WorkerSamplingRequest = RegisterDatasetRequest | ReplaceDatasetRequest | SampleViewportRequest | FindNearestPointRequest | GetDatasetMetricsRequest | DisposeDatasetRequest | DisposeAllRequest;
+export interface DatasetResponse {
+    type: 'dataset-response';
+    requestId: number;
+    datasetId: string;
+    revision: number;
+    status: WorkerSamplingStatus;
+    metrics?: WorkerSamplingDatasetMetrics;
+}
+export interface WorkerSamplingSeriesResponse {
+    seriesId: string;
+    datasetId: string;
+    revision: number;
+    status: WorkerSamplingStatus;
+    output?: WorkerSamplingOutput;
+    diagnostics: WorkerSamplingDiagnostics;
+}
+export interface SampleViewportResponse {
+    type: 'sample-viewport-response';
+    requestId: number;
+    results: readonly WorkerSamplingSeriesResponse[];
+    /** Set by the worker when WASM initialization failed and a fallback was selected. */
+    workerError?: string;
+}
+export interface FindNearestPointResponse {
+    type: 'find-nearest-point-response';
+    requestId: number;
+    datasetId: string;
+    revision: number;
+    status: WorkerSamplingStatus;
+    point?: WaveformPoint;
+}
+export interface DisposeAllResponse {
+    type: 'dispose-all-response';
+    requestId: number;
+    disposedDatasetIds: readonly string[];
+}
+export type WorkerSamplingResponse = DatasetResponse | SampleViewportResponse | FindNearestPointResponse | DisposeAllResponse;
+export interface WorkerSamplingResponseExpectation {
+    requestId: number;
+    revisions: Readonly<Record<string, number>>;
+}
+/** Rejects responses from an earlier request or an earlier data revision before UI state is updated. */
+export declare function isCurrentWorkerSamplingResponse(response: WorkerSamplingResponse, expectation: WorkerSamplingResponseExpectation): boolean;

package/dist/types/core/workerSampling/repository.d.ts

@@ -0,0 +1,36 @@
+import { type WorkerSamplingBackend, type WorkerSamplingRequest, type WorkerSamplingResponse } from './protocol';
+import { type SamplingCacheMetrics } from './samplingCache';
+export interface WorkerSamplingResourceMetrics {
+    datasetCount: number;
+    indexBytes: number;
+    cache: SamplingCacheMetrics;
+}
+export interface WorkerSamplingRepositoryOptions {
+    javascriptBackend?: WorkerSamplingBackend;
+    wasmBackend?: WorkerSamplingBackend;
+    indexMaxBytes?: number;
+    cacheMaxEntries?: number;
+    cacheMaxBytes?: number;
+}
+export declare class WorkerSamplingRepository {
+    private readonly datasets;
+    private readonly javascriptBackend;
+    private readonly cache;
+    private readonly indexMaxBytes;
+    private wasmBackend;
+    constructor(options?: WorkerSamplingRepositoryOptions);
+    get resourceMetrics(): WorkerSamplingResourceMetrics;
+    /** Enables the numeric backend after the worker has initialized its WASM module. */
+    setWasmBackend(backend: WorkerSamplingBackend | undefined): void;
+    handle(request: WorkerSamplingRequest): WorkerSamplingResponse;
+    private register;
+    private replace;
+    private sample;
+    private sampleSeries;
+    private sampleResponse;
+    private findNearest;
+    private metrics;
+    private dispose;
+    private disposeAll;
+    private datasetResponse;
+}

package/dist/types/core/workerSampling/repositoryDataset.d.ts

@@ -0,0 +1,29 @@
+import type { WaveformPoint } from '@/types';
+import type { WorkerSamplingDataset } from '../waveformPointSource';
+import type { WasmDatasetSamplingBackend } from '../wasmSampling';
+import { MultiResolutionSamplingIndex } from './multiresolution';
+import type { WorkerSamplingBackend, WorkerSamplingDatasetMetrics } from './protocol';
+export interface StoredDataset {
+    x?: Float64Array;
+    y: Float64Array;
+    sampleStartTime?: number;
+    sampleRate?: number;
+    sampleSourceIndexes?: Uint32Array;
+    points?: WaveformPoint[];
+    revision: number;
+    metrics: WorkerSamplingDatasetMetrics;
+    index?: MultiResolutionSamplingIndex;
+    wasmDatasetHandle?: number;
+    wasmIndexBytes?: number;
+}
+export declare function datasetLength(dataset: StoredDataset | undefined): number;
+export declare function datasetXAt(dataset: StoredDataset, index: number): number;
+export declare function datasetVisibleRange(dataset: StoredDataset, domain: [number, number]): {
+    start: number;
+    end: number;
+};
+export declare function datasetXRange(dataset: StoredDataset, start: number, end: number): Float64Array<ArrayBufferLike>;
+export declare function isWasmDatasetBackend(backend: WorkerSamplingBackend | undefined): backend is WasmDatasetSamplingBackend;
+export declare function createStoredDataset(input: readonly WaveformPoint[] | undefined, numeric: WorkerSamplingDataset | undefined, revision: number, indexMaxBytes: number | undefined): StoredDataset;
+export declare function registerWasmDataset(backend: WorkerSamplingBackend | undefined, dataset: StoredDataset, indexMaxBytes: number | undefined): void;
+export declare function disposeDatasetIndexes(backend: WorkerSamplingBackend | undefined, dataset: StoredDataset): void;

package/dist/types/core/workerSampling/repositorySupport.d.ts

@@ -0,0 +1,27 @@
+import type { WaveformPoint } from '@/types';
+import { type WorkerSamplingBackendKind, type WorkerSamplingDatasetMetrics, type WorkerSamplingDiagnostics, type WorkerSamplingOutput, type WorkerSamplingSeriesRequest, type WorkerSamplingStatus } from './protocol';
+export declare function copyFinitePoints(points: readonly WaveformPoint[]): WaveformPoint[];
+export declare function metricsFor(points: readonly WaveformPoint[], inputPointCount: number): WorkerSamplingDatasetMetrics;
+export declare function metricsForValues(x: Float64Array, y: Float32Array | Float64Array, inputPointCount?: number): WorkerSamplingDatasetMetrics;
+export declare function statusFor<T extends {
+    revision: number;
+}>(dataset: T | undefined, revision: number): WorkerSamplingStatus;
+export declare function selectedStrategy(strategy: WorkerSamplingSeriesRequest['strategy']): "none" | "peak" | "lttb" | "average" | "min" | "max" | "minmax" | "sum";
+export declare function targetPointCount(request: WorkerSamplingSeriesRequest): number;
+export declare function shouldUseRaw(request: WorkerSamplingSeriesRequest, visiblePointCount: number): boolean;
+export declare function visibleRange(points: readonly WaveformPoint[], domain: [number, number]): {
+    start: number;
+    end: number;
+};
+export declare function visibleValueRange(x: Float64Array, domain: [number, number]): {
+    start: number;
+    end: number;
+};
+export declare function nearestPoint(points: readonly WaveformPoint[], x: number): WaveformPoint | undefined;
+export declare function outputCount(output: WorkerSamplingOutput | undefined): number;
+export declare function outputWithGlobalIndexes(output: WorkerSamplingOutput, offset: number): WorkerSamplingOutput;
+export declare function cacheKey(request: WorkerSamplingSeriesRequest, range: {
+    start: number;
+    end: number;
+}, strategy: ReturnType<typeof selectedStrategy>, target: number, backend: WorkerSamplingBackendKind): string;
+export declare function diagnosticsFor(request: WorkerSamplingSeriesRequest, sourcePointCount: number, visiblePointCount: number, backend: WorkerSamplingBackendKind, selectedMode: 'raw' | 'sampled', durationMs: number, renderedPointCount: number, cacheHit: boolean): WorkerSamplingDiagnostics;

package/dist/types/core/workerSampling/samplingCache.d.ts

@@ -0,0 +1,24 @@
+import type { WorkerSamplingOutput } from './protocol';
+export interface SamplingCacheMetrics {
+    entries: number;
+    bytes: number;
+    maxEntries: number;
+    maxBytes: number;
+}
+export interface SamplingOutputCacheOptions {
+    maxEntries?: number;
+    maxBytes?: number;
+}
+/** A bounded LRU for immutable Worker sampling outputs. */
+export declare class SamplingOutputCache {
+    private readonly entries;
+    private bytes;
+    private readonly maxEntries;
+    private readonly maxBytes;
+    constructor(options?: SamplingOutputCacheOptions);
+    get metrics(): SamplingCacheMetrics;
+    get(key: string): WorkerSamplingOutput | undefined;
+    set(key: string, output: WorkerSamplingOutput): void;
+    deleteDataset(datasetId: string): void;
+    clear(): void;
+}

package/dist/types/core/workerSampling/workerRuntime.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -3,9 +3,9 @@
  * @packageDocumentation
  */
 export { default as WaveformChart } from './components/WaveformChart.vue';
-export type { WaveformPoint, WaveformDisplayMode, WaveformOverlayMode, WaveformInteractionMode, WaveformXDomainStrategy, WaveformZoomEndPayload, WaveformZoomResetPayload, WaveformAnnotationStyle, WaveformAnnotation, WaveformRenderingOptions, WaveformPlotMargin, WaveformTitleTextStyle, WaveformTitleOptions, WaveformLegendPosition, WaveformLegendOrientation, WaveformLegendOptions, WaveformFrameStyle, WaveformXAxisLabelKind, WaveformXAxisLabelFormatterContext, WaveformXAxisLabelFormatter, WaveformAxesOptions, WaveformZeroLineOptions, SingleWaveformData, WaveformLineType, WaveformLineStyle, WaveformPointType, WaveformErrorBarOptions, ResolvedWaveformErrorBarOptions, WaveformSeries, WaveformData, NormalizedWaveformSeries, } from './types';
+export type { WaveformPoint, WaveformDisplayMode, WaveformOverlayMode, WaveformInteractionMode, WaveformXDomainStrategy, WaveformZoomEndPayload, WaveformZoomResetPayload, WaveformAnnotationStyle, WaveformAnnotation, WaveformSamplingMode, WaveformSamplingStrategy, WaveformSamplingOptions, WaveformSamplingBackend, WaveformSamplingDiagnostics, WaveformSamplingError, WaveformRenderingOptions, WaveformPlotMargin, WaveformTitleTextStyle, WaveformTitleOptions, WaveformLegendPosition, WaveformLegendOrientation, WaveformLegendOptions, WaveformFrameStyle, WaveformXAxisLabelKind, WaveformXAxisLabelFormatterContext, WaveformXAxisLabelFormatter, WaveformAxesOptions, WaveformZeroLineOptions, SingleWaveformData, WaveformLineType, WaveformLineStyle, WaveformPointType, WaveformErrorBarOptions, ResolvedWaveformErrorBarOptions, WaveformTypedValues, TypedSampleData, TypedPointData, WaveformSeries, WaveformData, NormalizedWaveformSeries, } from './types';
 export type { WaveformGridOptions, WaveformGridLineOptions, WaveformGridTrackLines, } from './components/core/grid';
 export { normalizeWaveformData, normalizeWaveformSeries } from './core';
 export { paddedDomain, buildMinorTicks, displayTime, formatEndpointTime, formatAxisTime, formatTooltipTime, resolveTrackGeometry, clamp, type TimeUnit, type TrackGeometry, } from './utils';
-export { DEFAULT_WAVEFORM_RENDERING_OPTIONS, resolveWaveformRenderingOptions, selectRenderablePoints, type ResolvedWaveformRenderingOptions, } from './core';
+export { calculateWasmRange, findWasmVisibleRange, DEFAULT_WAVEFORM_RENDERING_OPTIONS, resolveWaveformRenderingOptions, selectRenderablePoints, type ResolvedWaveformRenderingOptions, type ResolvedWaveformSamplingOptions, type WasmRangeMetrics, initializeWasmSampling, sampleWaveformWasm, type WasmSamplingRequest, type WasmSamplingResult, type WasmSamplingStrategy, } from './core';
 export { parseWaveformAnnotations, serializeWaveformAnnotations } from './components/annotation';

package/dist/types/types/chart.d.ts

@@ -68,8 +68,64 @@ export interface WaveformAnnotation {
     style?: WaveformAnnotationStyle;
     createdAt?: string;
 }
+/** Selects the execution path used to obtain points for waveform rendering. */
+export type WaveformSamplingMode = 'auto' | 'wasm' | 'raw';
+/** Selects the point-reduction algorithm used by the sampling backend. */
+export type WaveformSamplingStrategy = 'auto' | 'none' | 'peak' | 'lttb' | 'average' | 'min' | 'max' | 'minmax' | 'sum';
+/** Controls how waveform points are selected for rendering. */
+export interface WaveformSamplingOptions {
+    /** Defaults to `auto`. */
+    mode?: WaveformSamplingMode;
+    /** Per-series visible-point threshold used by auto mode. Defaults to 1,000. */
+    autoThreshold?: number;
+    /** Interaction-only hysteresis around the automatic threshold. Defaults to 0. */
+    autoHysteresis?: number;
+    /** Defaults to the peak-preserving strategy. */
+    strategy?: WaveformSamplingStrategy;
+    /** Upper bound for rendered points per horizontal CSS pixel. */
+    maxPointsPerPixel?: number;
+    /** Visible-point count at which raw rendering should report a diagnostic. */
+    rawPointLimit?: number;
+    /** Controls whether a forced WASM failure may temporarily show JavaScript results. */
+    wasmFailureFallback?: 'error' | 'javascript';
+}
+/** The backend that produced a series' current SVG geometry. */
+export type WaveformSamplingBackend = 'raw' | 'javascript' | 'wasm' | 'unavailable';
+/** Read-only details emitted after a sampling request settles. */
+export interface WaveformSamplingDiagnostics {
+    seriesId: string;
+    /** Internal dataset identity, useful when correlating request logs. */
+    datasetId: string;
+    mode: WaveformSamplingMode;
+    selectedMode: 'raw' | 'sampled';
+    backend: WaveformSamplingBackend;
+    strategy: Exclude<WaveformSamplingStrategy, 'auto'>;
+    sourcePointCount: number;
+    visiblePointCount: number;
+    renderedPointCount: number;
+    durationMs: number;
+    cacheHit: boolean;
+    requestId: number;
+    revision: number;
+    rawPointLimitExceeded: boolean;
+    /** Cumulative sampling runs scheduled by this chart instance. */
+    scheduledRequestCount: number;
+    /** Cumulative intermediate runs replaced before they entered the Worker queue. */
+    coalescedRequestCount: number;
+    /** Maximum retained pending runs; bounded to one by the latest-wins scheduler. */
+    maxPendingRequestCount: number;
+}
+/** Describes a sampling backend failure without exposing an implementation-specific Error object. */
+export interface WaveformSamplingError {
+    message: string;
+    mode: WaveformSamplingMode;
+    fallback: 'javascript' | 'none';
+    seriesIds: string[];
+}
 /** Controls how many source points are included in the rendered SVG path. */
 export interface WaveformRenderingOptions {
+    /** Sampling execution and strategy configuration. Takes precedence over legacy fields. */
+    sampling?: WaveformSamplingOptions;
     /** Disable only when every source point must be rendered. */
     downsample?: boolean;
     /** Visible point count below which the complete range is rendered. */

package/dist/types/types/data.d.ts

@@ -16,8 +16,26 @@ export interface ResolvedWaveformErrorBarOptions {
     width: number;
     capWidth: number;
 }
+/** Numeric storage accepted by the compact waveform input formats. */
+export type WaveformTypedValues = Float32Array | Float64Array;
+/** Compact, evenly spaced samples. X is derived as `startTime + index / sampleRate`. */
+export interface TypedSampleData {
+    kind: 'typed-samples';
+    values: WaveformTypedValues;
+    sampleRate: number;
+    startTime?: number;
+}
+/** Compact points with explicit X coordinates. X uses Float64 precision by contract. */
+export interface TypedPointData {
+    kind: 'typed-points';
+    x: Float64Array;
+    y: WaveformTypedValues;
+    error?: WaveformTypedValues;
+    lowerError?: WaveformTypedValues;
+    upperError?: WaveformTypedValues;
+}
 /**
- * 单波形数据格式（采样点或显式坐标点）
+ * 单波形数据格式（对象数组或紧凑 TypedArray）
  */
 export type SingleWaveformData = {
     kind: 'samples';
@@ -27,7 +45,7 @@ export type SingleWaveformData = {
 } | {
     kind: 'points';
     points: WaveformPoint[];
-};
+} | TypedSampleData | TypedPointData;
 /**
  * 波形系列
  */

package/dist/types/types/index.d.ts

@@ -1,5 +1,5 @@
 /**
  * 类型定义统一导出
  */
-export type { WaveformPoint, WaveformDisplayMode, WaveformOverlayMode, WaveformInteractionMode, WaveformXDomainStrategy, WaveformZoomEndPayload, WaveformZoomResetPayload, WaveformAnnotationStyle, WaveformAnnotation, WaveformRenderingOptions, WaveformPlotMargin, WaveformTitleTextStyle, WaveformTitleOptions, WaveformLegendPosition, WaveformLegendOrientation, WaveformLegendOptions, WaveformFrameStyle, WaveformXAxisLabelKind, WaveformXAxisLabelFormatterContext, WaveformXAxisLabelFormatter, WaveformAxesOptions, WaveformZeroLineOptions, } from './chart';
-export type { SingleWaveformData, WaveformLineType, WaveformLineStyle, WaveformPointType, WaveformErrorBarOptions, ResolvedWaveformErrorBarOptions, WaveformSeries, WaveformData, NormalizedWaveformSeries, } from './data';
+export type { WaveformPoint, WaveformDisplayMode, WaveformOverlayMode, WaveformInteractionMode, WaveformXDomainStrategy, WaveformZoomEndPayload, WaveformZoomResetPayload, WaveformAnnotationStyle, WaveformAnnotation, WaveformSamplingMode, WaveformSamplingStrategy, WaveformSamplingOptions, WaveformSamplingBackend, WaveformSamplingDiagnostics, WaveformSamplingError, WaveformRenderingOptions, WaveformPlotMargin, WaveformTitleTextStyle, WaveformTitleOptions, WaveformLegendPosition, WaveformLegendOrientation, WaveformLegendOptions, WaveformFrameStyle, WaveformXAxisLabelKind, WaveformXAxisLabelFormatterContext, WaveformXAxisLabelFormatter, WaveformAxesOptions, WaveformZeroLineOptions, } from './chart';
+export type { SingleWaveformData, WaveformLineType, WaveformLineStyle, WaveformPointType, WaveformErrorBarOptions, ResolvedWaveformErrorBarOptions, WaveformTypedValues, TypedSampleData, TypedPointData, WaveformSeries, WaveformData, NormalizedWaveformSeries, } from './data';

package/dist/types/views/WasmSamplingDemo.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waveform-analysis",
-  "version": "0.1.48",
+  "version": "0.1.51",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/types/index.d.ts",
@@ -55,18 +55,19 @@
   "scripts": {
     "dev": "vite",
     "build": "pnpm typecheck && pnpm build:lib && pnpm build:types && pnpm build:demo",
+    "build:wasm": "wasm-pack build wasm --target web --release --out-dir pkg --locked",
     "build:lib": "vite build --config vite.lib.config.ts",
     "build:types": "node scripts/clean-types.mjs && vue-tsc -p tsconfig.lib.json",
     "build:demo": "vite build",
     "preview": "vite preview --outDir dist-demo",
-    "typecheck": "vue-tsc -b",
+    "typecheck": "pnpm build:wasm && vue-tsc -b",
     "check:file-length": "node scripts/check-file-length.mjs",
     "lint": "eslint . --max-warnings=0",
     "lint:oxlint": "oxlint . --deny-warnings",
     "lint:all": "pnpm lint:oxlint && pnpm lint",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
-    "test": "vitest run",
-    "test:coverage": "vitest run --coverage"
+    "test": "pnpm build:wasm && vitest run",
+    "test:coverage": "pnpm build:wasm && vitest run --coverage"
   }
 }

package/src/App.test.ts

@@ -210,12 +210,13 @@ describe('App workspace layout', { timeout: 20_000 }, () => {
       '正弦基波',
     ])
 
-    const triangleSeries = firstFrame.get('.waveform-chart__series[data-series-name="正弦基波"]')
-    expect(triangleSeries.find('.waveform-chart__line').exists()).toBe(false)
-    expect(triangleSeries.get('.waveform-chart__points').attributes('data-point-type')).toBe(
-      'triangle',
-    )
-    expect(triangleSeries.get('.waveform-chart__error-bar').attributes('stroke')).toBe('#0960bd')
+    const sineSeries = firstFrame.get('.waveform-chart__series[data-series-name="正弦基波"]')
+    expect(sineSeries.find('.waveform-chart__line').exists()).toBe(true)
+    expect(sineSeries.get('.waveform-chart__points').attributes('data-point-type')).toBe('circle')
+    expect(sineSeries.get('.waveform-chart__error-bar').attributes()).toMatchObject({
+      stroke: '#0960bd',
+      'stroke-width': '1.5',
+    })
 
     wrapper.unmount()
   })
@@ -318,7 +319,10 @@ describe('App workspace layout', { timeout: 20_000 }, () => {
 
     expect(colorPickers).toHaveLength(2)
     const initialFrames = wrapper.findAll('.waveform-chart__plot-frame')
-    expect(initialFrames.length > 1 && initialFrames.every((frame) => frame.attributes('stroke-width') === '2')).toBe(true)
+    expect(
+      initialFrames.length > 1 &&
+        initialFrames.every((frame) => frame.attributes('stroke-width') === '2'),
+    ).toBe(true)
 
     colorPickers[0].vm.$emit('update:pureColor', 'rgba(220, 38, 38, 0.8)')
     colorPickers[1].vm.$emit('update:pureColor', 'rgba(14, 165, 233, 0.25)')

package/src/App.vue

@@ -202,8 +202,8 @@ let zoomRequestSequence = 0
 function filterWaveformData(data: WaveformData, start: number, end: number): WaveformData {
   const lower = Math.min(start, end)
   const upper = Math.max(start, end)
-  if (data.kind === 'samples') return data
-  if (data.kind === 'points') {
+  if (data.kind !== 'series') {
+    if (data.kind !== 'points') return data
     return {
       kind: 'points',
       points: data.points.filter((point) => point.x >= lower && point.x <= upper),

package/src/DemoRouterApp.vue

@@ -5,6 +5,7 @@
       <nav class="demo-shell__nav" aria-label="示例导航">
         <RouterLink to="/">综合示例</RouterLink>
         <RouterLink to="/fixed-y-domain">固定振幅范围</RouterLink>
+        <RouterLink to="/wasm-sampling">WASM 采样</RouterLink>
       </nav>
     </header>
     <div class="demo-shell__content">

package/src/components/WaveformChart.css

@@ -1,3 +1,5 @@
+@import 'vue3-colorpicker/style.css';
+
 .waveform-chart {
   box-sizing: border-box;
   position: relative;

package/src/components/annotation/WaveformAnnotationEditor.css

@@ -8,8 +8,8 @@
 :global(.waveform-annotation-editor-root) {
   color: #344054;
   font-family:
-    -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial,
-    'Noto Sans', sans-serif;
+    -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, 'Noto Sans',
+    sans-serif;
   line-height: 1.5715;
   text-align: left;
   text-transform: none;

package/src/components/annotation/WaveformAnnotationEditor.vue

@@ -1,8 +1,6 @@
 <script setup lang="ts">
-import { computed, nextTick, ref, watch } from 'vue'
+import { computed, defineAsyncComponent, nextTick, ref, watch, type Component } from 'vue'
 import { InputNumber, Modal } from 'ant-design-vue'
-import { ColorPicker } from 'vue3-colorpicker'
-import 'vue3-colorpicker/style.css'
 
 import type { WaveformAnnotation } from '../../types'
 import { formatAnnotationTime, formatPlainNumber, type TimeUnit } from '../../utils'
@@ -10,6 +8,13 @@ import { ANNOTATION_MAX_TEXT_LENGTH, resolveAnnotationStyle } from './markup'
 import type { AnnotationSeriesCandidate, AnnotationSeriesInfo } from './types'
 import { useWaveformInstanceId } from '../../utils/waveformId'
 
+const ColorPicker = defineAsyncComponent(async (): Promise<Component> => {
+  if (typeof window === 'undefined') {
+    return { name: 'WaveformColorPickerSsrFallback', render: () => null }
+  }
+  return (await import('vue3-colorpicker')).ColorPicker
+})
+
 interface Props {
   annotation: WaveformAnnotation
   mode: 'add' | 'edit'
@@ -256,7 +261,6 @@ function handleSeriesChange(event: Event) {
           />
         </label>
       </fieldset>
-
     </div>
   </Modal>
 </template>