@uwrl/qc-utils 0.0.18 → 0.0.19

package/dist/utils/plotting/__tests__/calibration.spec.d.ts

@@ -1,16 +0,0 @@
-/**
- * Unit tests for the public surface of `calibration.ts`.
- *
- * The module imports `value-threshold.worker?worker&inline` eagerly, which
- * Vite transforms in the app build but not in Vitest + happy-dom — so we
- * substitute the same `MockValueThresholdWorker` used by
- * `observation-record.spec.ts` to give `runBenchmarks()` a working worker
- * constructor. The mock round-trips via `queueMicrotask`, which is enough
- * for `ensureCalibration()` to complete synchronously-ish in tests.
- *
- * Module state (`activeProfile`, `lastBenchmarkDetail`, `listeners`,
- * `localStorage`) lives at import scope, so every test begins with a
- * `clearCalibration()` and a `localStorage.clear()` to avoid cross-
- * pollination.
- */
-export {};

package/dist/utils/plotting/__tests__/mock.d.ts

@@ -1,4 +0,0 @@
-export declare const mockDatastream: {
-    phenomenon_time: string[];
-    result: number[];
-};

package/dist/utils/plotting/__tests__/observation-record-paths.spec.d.ts

@@ -1,21 +0,0 @@
-/**
- * Coverage-focused tests for `observation-record.ts` that exercise
- * paths the baseline spec skips:
- *
- *   1. **Worker fan-out paths** — every `_operation` routes through
- *      `shouldUseWorker()` and falls back to an inline core for small
- *      inputs. The existing `observation-record.spec.ts` uses tiny
- *      datasets, so only the inline branches run. Here we mock
- *      `../calibration` so callers can flip `forceWorker = true` and
- *      drive the worker branches without needing multi-MB fixtures.
- *   2. **Bulk assignment ops** — `ASSIGN_VALUES_BULK` and
- *      `ASSIGN_DATETIMES_BULK` aren't touched by the baseline spec.
- *   3. **Undo / redo** — `undo()` / `redo()` have their own state
- *      machines that aren't driven by the `dispatch()` tests.
- *   4. **DATETIME_RANGE, SELECTION pop** — the remaining filter ops.
- *
- * Mocks are hoisted via `vi.mock`; the real calibration module is
- * wrapped so non-mocked helpers (getCalibration, etc.) still work if
- * anything reaches for them.
- */
-export {};

package/dist/utils/plotting/__tests__/observation-record.spec.d.ts

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

package/dist/utils/plotting/__tests__/operation-cores.spec.d.ts

@@ -1,12 +0,0 @@
-/**
- * Direct unit tests for the pure kernels in `operation-cores.ts`. These
- * functions are the shared source of truth for every `*.worker.ts` with an
- * inline equivalent, so once they pass here the worker wrappers only need a
- * thin "message in / message out" check (see `workers.spec.ts`).
- *
- * Cores are deliberately framework-free and accept plain typed arrays, so
- * these tests build buffers from raw `Float32Array` / `Float64Array` rather
- * than `SharedArrayBuffer`. Semantics are identical and happy-dom doesn't
- * require the cross-origin-isolation headers SAB would.
- */
-export {};

package/dist/utils/plotting/__tests__/workerMocks.d.ts

@@ -1,119 +0,0 @@
-/**
- * In-process mock implementations of every worker used by `ObservationRecord`.
- *
- * The real workers are loaded via Vite's `?worker&inline` query, which is not
- * available in Vitest + happy-dom. Each mock here re-implements the logic of
- * the matching `*.worker.ts` file and runs synchronously via `queueMicrotask`,
- * which is enough to exercise every code path in `observation-record.ts`
- * end-to-end. The handler is scheduled via microtask so the caller has a chance
- * to assign `onmessage` before the response is dispatched (matching the real
- * Worker API contract).
- */
-export declare const MockDeleteDataWorker: {
-    new (): {
-        onmessage: ((event: {
-            data: any;
-        }) => void) | null;
-        postMessage(data: any): void;
-        terminate(): void;
-    };
-};
-export declare const MockAddDataWorker: {
-    new (): {
-        onmessage: ((event: {
-            data: any;
-        }) => void) | null;
-        postMessage(data: any): void;
-        terminate(): void;
-    };
-};
-export declare const MockChangeValuesWorker: {
-    new (): {
-        onmessage: ((event: {
-            data: any;
-        }) => void) | null;
-        postMessage(data: any): void;
-        terminate(): void;
-    };
-};
-export declare const MockInterpolateWorker: {
-    new (): {
-        onmessage: ((event: {
-            data: any;
-        }) => void) | null;
-        postMessage(data: any): void;
-        terminate(): void;
-    };
-};
-export declare const MockDriftCorrectionWorker: {
-    new (): {
-        onmessage: ((event: {
-            data: any;
-        }) => void) | null;
-        postMessage(data: any): void;
-        terminate(): void;
-    };
-};
-export declare const MockShiftDatetimesWorker: {
-    new (): {
-        onmessage: ((event: {
-            data: any;
-        }) => void) | null;
-        postMessage(data: any): void;
-        terminate(): void;
-    };
-};
-export declare const MockFillGapsWorker: {
-    new (): {
-        onmessage: ((event: {
-            data: any;
-        }) => void) | null;
-        postMessage(data: any): void;
-        terminate(): void;
-    };
-};
-export declare const MockFindGapsWorker: {
-    new (): {
-        onmessage: ((event: {
-            data: any;
-        }) => void) | null;
-        postMessage(data: any): void;
-        terminate(): void;
-    };
-};
-export declare const MockPersistenceWorker: {
-    new (): {
-        onmessage: ((event: {
-            data: any;
-        }) => void) | null;
-        postMessage(data: any): void;
-        terminate(): void;
-    };
-};
-export declare const MockChangeWorker: {
-    new (): {
-        onmessage: ((event: {
-            data: any;
-        }) => void) | null;
-        postMessage(data: any): void;
-        terminate(): void;
-    };
-};
-export declare const MockRateOfChangeWorker: {
-    new (): {
-        onmessage: ((event: {
-            data: any;
-        }) => void) | null;
-        postMessage(data: any): void;
-        terminate(): void;
-    };
-};
-export declare const MockValueThresholdWorker: {
-    new (): {
-        onmessage: ((event: {
-            data: any;
-        }) => void) | null;
-        postMessage(data: any): void;
-        terminate(): void;
-    };
-};

package/dist/utils/plotting/__tests__/workers.spec.d.ts

@@ -1,18 +0,0 @@
-/**
- * Wiring smoke tests for every `*.worker.ts` module.
- *
- * The algorithmic behaviour of each kernel is covered in
- * `operation-cores.spec.ts`, so these tests only verify the worker
- * handler is installed and forwards its payload to its core — i.e. the
- * thin shell is plumbed correctly. Two workers still carry inline
- * logic that has no core counterpart (`drift-correction.worker.ts` and
- * `shift-datetimes.worker.ts`), so we keep behavioural assertions for
- * those.
- *
- * Each worker file registers its handler via `self.onmessage = ...` at
- * module evaluation time. We import each module once, capture its
- * handler, and invoke it synchronously with `self.postMessage`
- * redirected to a local capture buffer. `self` resolves to the global
- * `Window` under happy-dom.
- */
-export {};

package/dist/utils/plotting/add-data.worker.d.ts

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

package/dist/utils/plotting/calibration.d.ts

@@ -1,99 +0,0 @@
-import { EnumEditOperations, EnumFilterOperations } from '../../types';
-/**
- * Device-specific primitives measured during the benchmark. Everything
- * is in consistent units:
- *   - `spawnOverheadMs` — wall-clock ms for one postMessage roundtrip
- *     including worker construction and termination,
- *   - `inlineThroughput` / `workerThroughput` — elements scanned per
- *     millisecond on a reference O(n) kernel (value-threshold).
- */
-export interface DeviceProfile {
-    spawnOverheadMs: number;
-    inlineThroughput: number;
-    workerThroughput: number;
-    hwConcurrency: number;
-    measuredAt: number;
-    userAgent: string;
-}
-export interface BenchmarkDetail extends DeviceProfile {
-    sharedArrayBufferAvailable: boolean;
-    samples: {
-        spawnRoundtripMs: number[];
-        inlineScanMs: number[];
-        workerScanMs: number[];
-    };
-}
-/** Subscribers notified after every successful recalibration. */
-type CalibrationListener = (profile: DeviceProfile) => void;
-/**
- * Per-operation algorithm descriptor. `weight` is the kernel's relative
- * cost per element compared to the reference value-threshold scan
- * (weight 1). `mode`:
- *   - `always-inline`: never worth the worker hop (O(log n), pure
- *     bookkeeping, or already single-shot loops),
- *   - `always-worker`: escape hatch for kernels that genuinely
- *     need thread-level parallelism (none in the current catalog),
- *   - `calibrated`: dispatch decides per-call using the estimator.
- */
-type OperationMode = 'always-inline' | 'always-worker' | 'calibrated';
-export interface DispatchSignals {
-    /** Total dataset length in points (source.x.length). */
-    datasetSize: number;
-    /** Indices involved when the op is selection-bound; 0 for full-scan. */
-    selectionSize?: number;
-    /** Override the measured workers count (defaults to hwConcurrency). */
-    parallelism?: number;
-}
-export interface DispatchDecision {
-    useWorker: boolean;
-    predictedInlineMs: number;
-    predictedWorkerMs: number;
-    /** Human-readable explanation (e.g. "inline faster at N=200"). */
-    reason: string;
-}
-/**
- * Core dispatch decision. Returns `useWorker: false` when the
- * predicted inline runtime beats the worker runtime (spawn overhead
- * plus in-loop work divided across workers). Callers should short-
- * circuit to the inline path when `useWorker` is false.
- */
-export declare function shouldUseWorker(op: EnumEditOperations | EnumFilterOperations, signals: DispatchSignals): DispatchDecision;
-/** Subscribe for post-benchmark updates (UI badge, etc.). */
-export declare function onCalibrationChange(listener: CalibrationListener): () => void;
-/** Read the active profile without triggering a benchmark. */
-export declare function getCalibration(): DeviceProfile;
-/** Detail snapshot for the dev popover; `null` until a benchmark runs. */
-export declare function getLastBenchmarkDetail(): BenchmarkDetail | null;
-/** Operation table for UI display (README + dev popover). */
-export declare function getOperationTable(): ReadonlyArray<{
-    op: EnumEditOperations | EnumFilterOperations;
-    mode: OperationMode;
-    weight: number;
-    rationale: string;
-}>;
-/** Clear cached calibration — mostly for tests / debugging. */
-export declare function clearCalibration(): void;
-/**
- * Kick off a benchmark when:
- *   - no profile exists yet, or
- *   - `force` is set (user clicked Recalibrate), or
- *   - the cached measurement is older than `STALE_AFTER_MS`.
- * Returns the active profile immediately; use `onCalibrationChange`
- * or the resolved `Promise<BenchmarkDetail>` to observe the result.
- */
-export declare function ensureCalibration(opts?: {
-    force?: boolean;
-}): Promise<DeviceProfile>;
-/**
- * Run the three microbenchmarks: worker spawn roundtrip, inline
- * scan throughput, worker scan throughput. Each is sampled three
- * times; we take the median to shake out noise. All numbers are in
- * elements-per-millisecond or milliseconds.
- *
- * Uses the VALUE_THRESHOLD kernel as the reference scan because it
- * already has both an inline core and a worker; per-op weights in
- * `OPERATION_TABLE` are normalised to this baseline so a single
- * throughput measurement covers all `calibrated` ops.
- */
-export declare function runBenchmarks(): Promise<BenchmarkDetail>;
-export {};

package/dist/utils/plotting/change-values.worker.d.ts

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

package/dist/utils/plotting/change.worker.d.ts

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

package/dist/utils/plotting/delete-data.worker.d.ts

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

package/dist/utils/plotting/drift-correction.worker.d.ts

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

package/dist/utils/plotting/fill-gaps.worker.d.ts

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

package/dist/utils/plotting/find-gaps.worker.d.ts

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

package/dist/utils/plotting/interpolate.worker.d.ts

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

package/dist/utils/plotting/observation-record.d.ts

@@ -1,281 +0,0 @@
-import { EnumEditOperations, EnumFilterOperations, HistoryItem } from "../../types";
-/**
- * This number should approximate the number of observations that a dataset could increase by during a session.
- * The lower this number, the less memory the entire app uses.
- * Note that when a dataset number of data points increases by more than `INCREASE_AMOUNT`,
- * the `_growBuffer()` method will allocate a new buffer, and the data will be copied into it.
- */
-export declare const INCREASE_AMOUNT: number;
-export declare class ObservationRecord {
-    /** The generated dataset to be used for plotting */
-    dataset: {
-        dimensions: string[];
-        source: {
-            x: Float64Array<SharedArrayBuffer>;
-            y: Float32Array<SharedArrayBuffer>;
-        };
-    };
-    history: HistoryItem[];
-    /**
-     * Items popped off `history` by `undo()`, in undo order (top of stack
-     * at the end). `redo()` re-dispatches the top. A fresh `dispatchAction`
-     * / `dispatchFilter` call clears the stack — Word-style behavior where
-     * a new edit invalidates the redo chain.
-     */
-    redoStack: HistoryItem[];
-    /**
-     * True while `undo()` / `redo()` is replaying a captured history entry.
-     * Suppresses the redo-stack clearing that otherwise fires on every new
-     * dispatch, so the stack survives the internal replay.
-     */
-    private _isReplaying;
-    /**
-     * Set by each operation handler (or any of its subroutines) to record
-     * whether a worker was actually spawned during this dispatch. Sticky-
-     * upgrade semantics: the wrapper resets it to `"inline"` before the
-     * handler runs, and any code that spawns a worker flips it to
-     * `"worker"`. Once flipped it stays flipped for the rest of the
-     * dispatch — so an op whose top-level decision is "inline" but whose
-     * sub-op (e.g. `_shift` → `_deleteDataPoints`) still spawns workers
-     * will honestly show `"worker"` on its history entry.
-     */
-    private _pendingExecutionMode;
-    loadingTime: number | null;
-    isLoading: boolean;
-    rawData: {
-        datetimes: Float64Array<ArrayBuffer> | number[];
-        dataValues: Float32Array<ArrayBuffer> | number[];
-    };
-    constructor(dataArrays: {
-        datetimes: Float64Array<ArrayBuffer> | number[];
-        dataValues: Float32Array<ArrayBuffer> | number[];
-    });
-    loadData(dataArrays: {
-        datetimes: Float64Array<ArrayBuffer> | number[];
-        dataValues: Float32Array<ArrayBuffer> | number[];
-    }): Promise<void>;
-    get dataX(): Float64Array<SharedArrayBuffer>;
-    get dataY(): Float32Array<SharedArrayBuffer>;
-    /**
-     * Resizes the typed array
-     * @param length The total number of elements that the view will contain
-     */
-    private _resizeTo;
-    /**
-     * Buffer size is always in increments of `INCREASE_AMOUNT`.
-     * Grows the buffer by `INCREASE_AMOUNT` in bytes if the current data doesn't fit
-     * @param newLength The total number of elements that the view will contain
-     */
-    private _growBuffer;
-    /**
-     * Reloads the dataset with the raw data
-     */
-    reload(): Promise<void>;
-    /**
-     * @param index
-     * @returns
-     */
-    reloadHistory(index: number): Promise<number[]>;
-    /**
-     * Remove a history item
-     * @param index
-     */
-    removeHistoryItem(index: number): Promise<number[]>;
-    /**
-     * Undo the most recent history entry. Pushes it onto `redoStack` so a
-     * subsequent `redo()` can re-apply it, then reloads from the raw
-     * dataset and replays the remaining history in order.
-     */
-    undo(): Promise<number[]>;
-    /**
-     * Re-apply the most recently undone entry from `redoStack`. The replay
-     * runs through `dispatch`, which pushes a fresh history entry for it;
-     * `_isReplaying` guards the redo stack from being wiped during the
-     * dispatch.
-     */
-    redo(): Promise<number[]>;
-    get beginTime(): Date | null;
-    get endTime(): Date | null;
-    /** Dispatch an operation and log its signature in hisotry */
-    dispatchAction(action: EnumEditOperations, ...args: any): Promise<number[]>;
-    dispatch(actions: EnumEditOperations | EnumFilterOperations | [EnumEditOperations | EnumFilterOperations, ...any][], ...args: any): Promise<number[]>;
-    /** Filter operations do not transform the data and return a selection */
-    dispatchFilter(action: EnumFilterOperations, ...args: any): Promise<number[]>;
-    /**
-     * @param index An array containing the list of index of values to perform the operations on.
-     * @param operator The operator that will be applied
-     * @param value The value to use in the operation
-     * @returns an array of index values to keep selected in the plot
-     */
-    /**
-     * Multi-threaded apply of an arithmetic operator to Y at the previously-filtered selection.
-     *  1. Selection is read from the previous history entry (the last entry is this operation itself).
-     *  2. Selection indexes are sharded into disjoint chunks; workers write in place to shared Y.
-     *  3. Writes are conflict-free because the selection carries distinct indexes.
-     */
-    private _changeValues;
-    /**
-     * Apply an arithmetic operator to Y in-place on the main thread. Thin
-     * wrapper around {@link changeValuesCore} kept so `_assignValuesBulk`
-     * and callers outside this module can use the same routine the
-     * CHANGE_VALUES fast path does.
-     */
-    private _applyOperatorInPlace;
-    /**
-     * One-shot assignment of distinct Y-values at the indices logged by the
-     * previous SELECTION filter entry. Args: `(values: number[])`, where
-     * `values[i]` is written to `dataY[selection[i]]`. Runs as a single
-     * tight loop on the main thread — no workers, no per-row dispatch
-     * ceremony. Intended for table-driven edits.
-     *
-     * Expected dispatch order (matches CHANGE_VALUES):
-     *   [[SELECTION, indices], [ASSIGN_VALUES_BULK, values]]
-     * The SELECTION entry carries the indices for history, so this op does
-     * not log them again.
-     */
-    private _assignValuesBulk;
-    /**
-     * One-shot assignment of distinct datetimes (epoch-ms) at the indices
-     * logged by the previous SELECTION filter entry. Internally: compute
-     * the replacement (x, y) pairs, do a single delete + single add — so
-     * the reindex-and-sort step runs once regardless of how many rows changed.
-     *
-     * Expected dispatch order (matches SHIFT_DATETIMES pattern):
-     *   [[SELECTION, indices], [ASSIGN_DATETIMES_BULK, datetimes]]
-     */
-    private _assignDatetimesBulk;
-    /**
-     * Multi-threaded linear interpolation over the selected indexes.
-     *  1. Main thread partitions the selected indexes into consecutive groups and computes each group's lower/upper anchors.
-     *  2. Groups are sharded across workers (disjoint by construction, so in-place writes are safe).
-     *  3. Each worker writes interpolated Y values directly into the shared Y buffer — no output copy needed since only a subset of Y changes.
-     */
-    private _interpolate;
-    /** Interpolate existing values in the data source */
-    /**
-     * Shifts the selected indexes by specified amount of units. Elements are reinserted according to their datetime.
-     * @param index The index of the elements to shift
-     * @param amount Number of {@link TimeUnit}
-     * @param unit {@link TimeUnit}
-     * @returns
-     */
-    private _shift;
-    /**
-     * Multi-threaded version of {@link _fillGaps}.
-     *  1. The main thread scans once for gaps and computes the number of fill points per gap.
-     *  2. The original array is split into equal segments; each gap is assigned to the segment containing its left index.
-     *  3. Cumulative fill counts before each segment give each worker's output startTarget, ensuring no overlap.
-     *  4. Each worker copies its segment to the output buffer and inserts its gap fills inline.
-     */
-    private _fillGaps;
-    /**
-     Deletes data points from a large array using worker threads.
-      1. The main thread divides the original array into equal parts to distribute work among workers.
-      2. For each segment, binary search locates the indexes to delete (deleteSegment), ensuring efficient lookups.
-      3. The cumulative deletions before each segment help compute the starting index (startTarget) for each worker's output, ensuring no overlap.
-      4. Each worker processes its segment linearly, skipping deletions and copying kept elements to their computed positions.
-      * @param deleteIndices
-     */
-    private _deleteDataPoints;
-    /**
-     *
-     * @param start The start index
-     * @param end The end index
-     * @param value The drift amount
-     */
-    /**
-     * Multi-threaded drift correction over one or more [start, end, value] ranges.
-     *  1. Main thread reads each range's anchors (startDatetime, extent) once and chunks the range.
-     *  2. All chunks across all ranges are flattened into jobs and distributed round-robin across a fixed pool of workers.
-     *  3. Each worker applies y_n = y_0 + value * ((x_i - startDatetime) / extent) in place on its jobs.
-     *  4. Batching all ranges into a single call yields a single history entry.
-     */
-    private _driftCorrection;
-    /** Traverses the index array and returns groups of consecutive values.
-     * i.e.: `[0, 1, 3, 4, 6] => [[0, 1], [3, 4], [6]]`
-     * Assumes the input array is sorted.
-     * @param index: the index array (sorted)
-     */
-    private _getConsecutiveGroups;
-    /**
-     * Adds data points using worker threads.
-     *  1. Main thread sorts insertions by datetime and computes each insertion's target index via binary search on the original X.
-     *  2. The original array is split into equal chunks; each insertion is assigned to the chunk containing its target index.
-     *  3. `firstIns` per chunk doubles as the prefix sum of insertions placed before the chunk, giving each worker its outStart in the output buffer without overlap.
-     *  4. Each worker linearly merges its original slice with its insertion slice (both already sorted by datetime) into the output buffer. Originals win on datetime ties, matching the original `findLastLessOrEqual` semantics.
-     */
-    private _addDataPoints;
-    /**
-     * Filter by applying a set of logical operations
-     * @param appliedFilters
-     * @returns an array of index values to select in the plot
-     */
-    /**
-     * Filter by applying a set of logical operations, using worker threads.
-     *  1. Main thread encodes filters as numeric opcodes + thresholds (cheaper than string compares in the hot loop).
-     *  2. Workers scan disjoint chunks of Y; an index is selected if ANY filter matches (short-circuit).
-     *  3. Results from each chunk are concatenated in order to preserve ascending indexes.
-     *
-     * Opcodes: 0=LT, 1=LTE, 2=GT, 3=GTE, 4=E.
-     */
-    private _valueThreshold;
-    /**
-     *
-     * @param comparator
-     * @param value
-     * @returns
-     */
-    /**
-     * Find points where the relative rate `(curr - prev) / |prev|` satisfies the comparator, using worker threads.
-     *  1. Main thread partitions scan range [1, dataY.length) into chunks; `Y[i-1]` is safely read from the shared buffer across chunk boundaries.
-     *  2. Each worker runs a hoisted branch matching the comparator and returns matching indexes in ascending order.
-     *  3. Main thread concatenates results in chunk order, preserving ascending order.
-     */
-    private _rateOfChange;
-    /**
-     * Select all points whose datetime falls inside `[from, to]` (inclusive).
-     * `dataX` is sorted ascending, so binary search bounds the range in
-     * O(log n) — no workers required. Pass `undefined` for either bound to
-     * leave that side unconstrained; omitting both selects the full series.
-     */
-    private _datetimeRange;
-    /**
-     * @param index
-     * @returns
-     */
-    private _selection;
-    /**
-     *
-     * @param comparator
-     * @param value
-     * @returns
-     */
-    /**
-     * Find points where the change from the previous value satisfies the comparator, using worker threads.
-     *  1. Main thread partitions scan range [1, dataY.length) into chunks (each chunk's first index safely reads Y[i-1] from the shared buffer).
-     *  2. Each worker runs a hoisted branch matching the comparator and returns matching indexes in ascending order.
-     *  3. Main thread concatenates results in chunk order, preserving ascending order.
-     */
-    private _change;
-    /**
-     * Find gaps in the data using worker threads.
-     *  1. Main thread slices the scan range [start, end] into equal chunks with a 1-index overlap so adjacent workers observe the boundary delta correctly.
-     *  2. Each worker scans its chunk and returns a flat list of [leftIdx, rightIdx] pairs for gaps whose delta exceeds the threshold.
-     *  3. Main thread collects all pairs and dedups via Set — identical return shape to the original implementation.
-     * @param value The time value
-     * @param unit The time unit (TimeUnit)
-     * @param range If specified, the gaps will be found only within the range
-     */
-    private _findGaps;
-    /**
-     * Find points where the values are the same at least `times` in a row, using worker threads.
-     *  1. Main thread splits [start, end) into chunks and each worker emits its maximal runs of equal Y values as flat (startIndex, length, value) triplets.
-     *  2. Main thread stitches runs that cross chunk boundaries (same value, adjacent indexes).
-     *  3. Every run whose stitched length is >= `times` contributes all of its indexes to the selection.
-     *
-     * Matches the Python reference implementation in `edit_service.py::persistence` — every member of a qualifying run is selected (including the run's first index).
-     * @param times The minimum run length to qualify
-     * @param range If specified, the points will be found only within the range
-     */
-    private _persistence;
-}