@kymoscope/sdk 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,32 @@
+/**
+ * Colours of a gauge by value: one colour ('solid'), a gradient through colour
+ * stops ('gradient': each stop's colour exactly at its value, blended between),
+ * or zones ('zones': each stop's colour from its value up to the next stop's;
+ * below the first, the first). Stop values are in the channel's units.
+ */
+export type GaugeColorMode = 'solid' | 'gradient' | 'zones';
+export interface GaugeColorStop {
+    at: number;
+    color: string;
+}
+/** A run of the scale (fractions 0..1) and its colour. */
+export interface ColorInterval {
+    f0: number;
+    f1: number;
+    color: string;
+}
+/** The colour at a value. */
+export declare function colorAt(mode: GaugeColorMode | undefined, stops: GaugeColorStop[] | undefined, solid: string, v: number): string;
+/**
+ * The scale [min, max] as coloured runs: zones exactly at their limits, a
+ * gradient in `steps` short runs.
+ */
+export declare function colorIntervals(mode: GaugeColorMode | undefined, stops: GaugeColorStop[] | undefined, solid: string, min: number, max: number, steps?: number): ColorInterval[];
+export type GaugePreset = 'green-red' | 'red-green' | 'traffic';
+/** Ready-made stops over a scale: green to red (higher is worse), red to green, or green · amber · red zones. */
+export declare function presetStops(p: GaugePreset, min: number, max: number): {
+    mode: GaugeColorMode;
+    stops: GaugeColorStop[];
+};
+/** A CSS background previewing the colours across the stops' own range. */
+export declare function colorsCss(mode: GaugeColorMode | undefined, stops: GaugeColorStop[] | undefined, solid: string): string;

package/dist/types/lib/importers/arrowSink.d.ts

@@ -0,0 +1,35 @@
+import { Table, type Vector } from 'apache-arrow';
+import type { Chunk } from './combine';
+/** The part of a DuckDB connection the sink uses. */
+export interface ArrowConnection {
+    insertArrowTable(table: Table, options: {
+        name: string;
+        create?: boolean;
+    }): Promise<void>;
+}
+/**
+ * A Float64 vector over `v` without copying it. NaN becomes null: DuckDB sorts
+ * NaN above every number, so max() (axis bounds, the resolution pyramid) would
+ * return NaN, while nulls are skipped like the empty cells of a CSV.
+ */
+export declare function f64Vector(v: Float64Array): Vector;
+/** DuckDB's row group size: an insert of fewer rows costs about as much as a whole group. */
+export declare const ROW_GROUP = 122880;
+/**
+ * Combined chunks into a DuckDB table as Arrow record batches (the out-of-core
+ * path). Chunks wait until a row group's worth is buffered, then go in one
+ * insert (one record batch each, no copy): an MF4 chunk is 8k rows, and 50
+ * one-chunk inserts took 2 s for 400k rows (row-group inserts: 0.6 s).
+ */
+export declare class ArrowSink {
+    #private;
+    rows: number;
+    constructor(conn: ArrowConnection, table: string, columns: {
+        name: string;
+        text: boolean;
+    }[], rowsPerInsert?: number);
+    /** Buffers the chunk; inserts once a row group's worth is waiting. */
+    append(chunk: Chunk): Promise<void>;
+    /** Inserts the buffered rows (call once after the last chunk). */
+    flush(): Promise<void>;
+}

package/dist/types/lib/importers/blobReader.d.ts

@@ -0,0 +1,22 @@
+/** Sequential data window: large enough to amortise each slice, small enough to never hold the file. */
+export declare const WINDOW: number;
+/**
+ * Reads a File/Blob in pieces, never whole. `read` serves scattered header
+ * reads through 1 MiB cached pages (MF4 and TDMS metadata is spread over the
+ * file); `slice` and `windows` read data uncached. Returned bytes are views:
+ * do not write to them.
+ */
+export declare class BlobReader {
+    #private;
+    readonly size: number;
+    /** Bytes read from the blob so far (progress). */
+    bytesRead: number;
+    constructor(blob: Blob);
+    read(offset: number, length: number): Promise<Uint8Array>;
+    /** Exactly [offset, offset + length), clipped to the file, uncached. */
+    slice(offset: number, length: number): Promise<Uint8Array>;
+    windows(offset: number, length: number, size?: number): AsyncGenerator<{
+        offset: number;
+        bytes: Uint8Array;
+    }>;
+}

package/dist/types/lib/importers/bytes.d.ts

@@ -0,0 +1,11 @@
+/** Header helpers. Decoders read DataViews directly; nothing here runs per sample. */
+export declare const view: (b: Uint8Array) => DataView;
+/** Unsigned 64-bit integer as a Number (exact below 2^53, which counts and offsets are). */
+export declare function u64(v: DataView, o: number, le?: boolean): number;
+export declare function i64(v: DataView, o: number, le?: boolean): number;
+/** Text up to the first NUL. */
+export declare function cstr(b: Uint8Array, latin1?: boolean): string;
+export declare const ascii: (b: Uint8Array) => string;
+export declare const utf8: (b: Uint8Array) => string;
+/** `b` starts with `s` (one byte per character code, so '\xFF' works). */
+export declare function startsWith(b: Uint8Array, s: string, at?: number): boolean;

package/dist/types/lib/importers/combine.d.ts

@@ -0,0 +1,30 @@
+import type { Batch, ColumnValues, PlanChannel, PlanGroup } from './types';
+/** A combined chunk: column 0 is Time, then every selected channel in selection order. */
+export interface Chunk {
+    length: number;
+    columns: ColumnValues[];
+}
+/** One group's batches, in time order. */
+export interface Feed {
+    pull(): Promise<Batch | null>;
+}
+export declare function iterFeed(it: AsyncIterable<Batch>): Feed;
+/**
+ * Per-group feeds over one stream that interleaves groups (EDF records, XDF
+ * chunks, unsorted MF4): batches of the other groups wait in a queue. Bounded
+ * because such formats interleave their groups in time. `positions` maps a
+ * plan group to its feed.
+ */
+export declare function demux(it: AsyncIterator<Batch>, positions: Map<number, number>): Feed[];
+/** Timestamps of a batch: its own, or made from the group's rate or sample index. */
+export declare function batchTime(b: Batch, g: PlanGroup): Float64Array;
+/**
+ * Groups onto one time base, streaming: the fastest regular group (most
+ * samples) plus every irregular group (their union) are the time base; the
+ * others hold their last value (zero-order hold). A chunk covers the rows up to
+ * H, the earliest last-buffered time of the time-base groups, so memory stays
+ * at about one batch per group whatever the file size. Returns the row count.
+ */
+export declare function combineGroups(groups: PlanGroup[], channels: PlanChannel[][], feeds: Feed[], emit: (chunk: Chunk) => void | Promise<void>, signal?: AbortSignal, 
+/** `emit` copies a chunk before it returns (the memory sink): numeric output columns are reused. */
+reuse?: boolean): Promise<number>;

package/dist/types/lib/importers/comtrade/format.d.ts

@@ -0,0 +1,2 @@
+import type { FormatInfo } from '../formats';
+export declare const COMTRADE_FORMAT: FormatInfo;

package/dist/types/lib/importers/comtrade/importer.d.ts

@@ -0,0 +1,25 @@
+import { type Importer } from '../types';
+interface Analog {
+    name: string;
+    unit: string;
+    a: number;
+    b: number;
+}
+interface Cfg {
+    station: string;
+    rev: number;
+    analog: Analog[];
+    digital: string[];
+    rates: [number, number][];
+    start: string | null;
+    trigger: string | null;
+    startSec: number;
+    triggerSec: number;
+    ft: string;
+    timemult: number;
+    /** Seconds per DAT timestamp unit: µs, or ns when the CFG times have nanoseconds. */
+    timebase: number;
+}
+export declare function parseCfg(text: string): Cfg;
+export declare const comtradeImporter: Importer;
+export {};

package/dist/types/lib/importers/dbc.d.ts

@@ -0,0 +1,45 @@
+export interface DbcSignal {
+    name: string;
+    /** DBC start bit: the LSB for Intel (little endian), the MSB for Motorola (big endian). */
+    start: number;
+    length: number;
+    littleEndian: boolean;
+    signed: boolean;
+    factor: number;
+    offset: number;
+    unit: string;
+    /** 'switch': the multiplexer; a number: present only when the multiplexer has that value. */
+    mux: 'switch' | number | null;
+    /** IEEE float signals (SIG_VALTYPE_ 1 = 32, 2 = 64); 0 = integer. */
+    float: 0 | 32 | 64;
+    /** Value table (VAL_): raw value → text. */
+    values: Map<number, string> | null;
+}
+export interface DbcMessage {
+    id: number;
+    extended: boolean;
+    name: string;
+    size: number;
+    signals: DbcSignal[];
+}
+/** Messages by key: the id, plus 0x80000000 for extended (29-bit) ids. */
+export type Dbc = Map<number, DbcMessage>;
+export declare const messageKey: (id: number, extended: boolean) => number;
+/** Messages, signals (scaling, signedness, byte order, basic multiplexing), value tables and float types of a DBC. */
+export declare function parseDbc(text: string): Dbc;
+export type SignalReader = (d: Uint8Array, o: number) => number;
+/**
+ * A reader of a signal's raw (unscaled) value in a frame's bytes at `o`, its
+ * bit layout worked out once (decoders call it per frame). Bytes past the
+ * frame read as 0.
+ */
+export declare function signalReader(s: DbcSignal): SignalReader;
+/** Values of `n` frames, raw x `f` + `o`: frame k's bytes start at `at[idx[k]]` in `d`. */
+export type SignalColumn = (d: Uint8Array, at: Int32Array, idx: Int32Array, n: number, out: Float64Array, f: number, o: number) => void;
+/**
+ * A signal's raw values over many frames at once: one loop per bit layout (the
+ * common up-to-32-bit Intel and Motorola fields inline), the reader otherwise.
+ */
+export declare function signalColumn(s: DbcSignal): SignalColumn;
+/** The raw (unscaled) value of a signal in a frame's bytes at `o`. Bytes past the frame read as 0. */
+export declare function rawValue(s: DbcSignal, d: Uint8Array, o: number): number;

package/dist/types/lib/importers/edf/format.d.ts

@@ -0,0 +1,2 @@
+import type { FormatInfo } from '../formats';
+export declare const EDF_FORMAT: FormatInfo;

package/dist/types/lib/importers/edf/importer.d.ts

@@ -0,0 +1,7 @@
+import type { Importer } from '../types';
+/** EDF+ TALs of one record's annotation bytes. The first one of a record keeps time (its onset, no text). */
+export declare function parseTals(b: Uint8Array): {
+    onset: number;
+    texts: string[];
+}[];
+export declare const edfImporter: Importer;

package/dist/types/lib/importers/expr.d.ts

@@ -0,0 +1,10 @@
+type Fn = (x: number) => number;
+/**
+ * A conversion formula of X (MF4 algebraic conversions, MDF3 ASAM formulas) as
+ * a function: numbers, X (or X1, x), + - * / ^, parentheses and the functions
+ * above. Anything else gives null (the raw values are kept, with a note).
+ * Built as closures, never evaluated as code. Longer than MAX_FORMULA
+ * characters: null (its closures would nest too deep to evaluate).
+ */
+export declare function compileFormula(src: string): Fn | null;
+export {};

package/dist/types/lib/importers/formats.d.ts

@@ -0,0 +1,23 @@
+/**
+ * What the page needs to know about each binary format before any parser
+ * loads: names, extensions, companions and magic bytes. The parsers live in
+ * `importers.ts`, loaded by the import worker.
+ */
+export interface FormatInfo {
+    id: string;
+    label: string;
+    /** Lowercase, with the dot. A hint only: `sniff` decides. */
+    extensions: string[];
+    /** Files read with the main one: same base name, or (anyName) the only file of that kind in the drop. */
+    companions?: {
+        ext: string;
+        anyName?: boolean;
+    }[];
+    sniff(head: Uint8Array, name: string): boolean;
+}
+/** Bytes read from each file to recognise it. */
+export declare const HEAD_BYTES = 4096;
+/** Delimited text, read by the CSV path. */
+export declare const TEXT_EXTENSIONS: string[];
+/** Every binary format, in sniffing order (each format adds its entry). */
+export declare const FORMATS: FormatInfo[];

package/dist/types/lib/importers/hdf5/format.d.ts

@@ -0,0 +1,4 @@
+import type { FormatInfo } from '../formats';
+/** The HDF5 signature sits at 0 or after a user block (512, 1024, 2048 bytes). */
+export declare const hasHdf5Signature: (h: Uint8Array) => boolean;
+export declare const HDF5_FORMAT: FormatInfo;

package/dist/types/lib/importers/hdf5/h5.d.ts

@@ -0,0 +1,76 @@
+/** The part of h5wasm used here (h5wasm's own types ship with it; these keep the importers independent of how it is loaded). */
+export interface H5Attrs {
+    [name: string]: {
+        value: unknown;
+    };
+}
+export interface H5Dataset {
+    shape: number[] | null;
+    metadata: {
+        type: number;
+        size: number;
+        shape?: number[] | null;
+        chunks?: number[] | null;
+        signed?: boolean;
+        compound_type?: {
+            members: {
+                name: string;
+                type: number;
+            }[];
+        };
+    };
+    attrs: H5Attrs;
+    filters?: {
+        id: number;
+        name: string;
+    }[];
+    slice(ranges: number[][]): unknown;
+}
+export interface H5Group {
+    attrs: H5Attrs;
+    keys(): string[];
+    get(name: string): unknown;
+    create_reference?(): {
+        ref_data: Uint8Array;
+    };
+}
+export interface H5Handle {
+    root: H5Group;
+    close(): void;
+}
+export type H5Opener = (file: File) => Promise<H5Handle>;
+export declare const isGroup: (n: unknown) => n is H5Group;
+/** Objects a walk visits at most (links can make a file's tree far larger than the file). */
+export declare const MAX_OBJECTS = 100000;
+/**
+ * A walk of a file's groups that visits each group once (hard links can make a
+ * group its own descendant) and stops after MAX_OBJECTS objects. `enter`
+ * returns false for a group seen before; `count` false once the budget is spent.
+ */
+export declare function h5Walk(): {
+    enter(g: H5Group): boolean;
+    count(): boolean;
+    note(): string | null;
+};
+/** Elements × element size of a dataset; more than a file can hold (×1032 for compressed data) means fill values never written, or damage. */
+export declare function tooLarge(ds: H5Dataset, shape: number[], fileSize: number, compressed: boolean): boolean;
+export declare const isDataset: (n: unknown) => n is H5Dataset;
+/** Set by the import worker (h5wasm + WORKERFS) and by tests (h5wasm's Node build). */
+export declare function setH5Loader(load: () => Promise<H5Opener>): void;
+/**
+ * The file, opened once: plan and every read (and split re-reads) share the handle and its
+ * datasets, so per-dataset h5wasm calls (open, metadata) are paid once per import.
+ * ponytail: never closed (`close` is a no-op); the import worker is one per file and is
+ * terminated when the import ends. Close for real if a worker ever serves many files.
+ */
+/** Load h5wasm now (a failed load is tried again by the next call). */
+export declare function warmH5(): void;
+export declare function openH5(file: File): Promise<H5Handle>;
+/** A dataset by absolute path, one object per path (h5wasm caches its metadata on the object). */
+export declare function datasetAt(root: H5Group, path: string, found?: H5Dataset): H5Dataset;
+/** A dataset's slice as Float64Array (int64 via Number; a fresh Float64Array is used as is). */
+export declare function toF64(v: unknown): Float64Array;
+/** Seconds per unit for time datasets. */
+export declare const TIME_UNITS: Record<string, number>;
+export declare function attrText(attrs: H5Attrs, ...names: string[]): string;
+export declare function attrNumber(attrs: H5Attrs, ...names: string[]): number | null;

package/dist/types/lib/importers/hdf5/h5wasmModule.d.ts

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

package/dist/types/lib/importers/hdf5/importer.d.ts

@@ -0,0 +1,2 @@
+import type { Importer } from '../types';
+export declare const hdf5Importer: Importer;

package/dist/types/lib/importers/importer.worker.d.ts

@@ -0,0 +1,5 @@
+/** First message from the page: where h5wasm's module is (an absolute URL; see hdf5/h5wasmModule.ts). */
+export interface InitMessage {
+    type: 'init';
+    h5Url: string;
+}

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

@@ -0,0 +1,4 @@
+import type { Importer } from './types';
+/** Every importer by format id (the parsers): loaded by the import worker, and lazily without workers. */
+export declare const IMPORTERS: Record<string, Importer>;
+export declare function importerFor(id: string): Importer;

package/dist/types/lib/importers/limits.d.ts

@@ -0,0 +1,28 @@
+import type { ImportPlan } from './types';
+/**
+ * Bounds for files that may be damaged or hostile: every count, size and string
+ * that comes from a file is checked against these (O(1) checks) before it sizes
+ * an allocation or a loop.
+ */
+/** What the page shows when a reader fails in a way it did not foresee (RangeError, TypeError, a stuck worker). */
+export declare const DAMAGED = "This file couldn't be read (it may be damaged).";
+/** Deflate never inflates more than ~1032:1; a header claiming more is damaged. */
+export declare const MAX_INFLATE_RATIO = 1032;
+export declare const maxInflated: (compressed: number) => number;
+/** One inflated block or variable held at once (MF4 DZ, MAT miCOMPRESSED). */
+export declare const MAX_INFLATE: number;
+/** Values a group may buffer before the others catch up (one interleaving stream, a held group): ~1 GB. */
+export declare const MAX_PENDING_VALUES = 128000000;
+export declare const capText: (s: string, n: number) => string;
+/**
+ * The plan as the page may trust it: names, units, notes, meta and events
+ * length-capped; counts integers ≥ -1; rates finite and positive (a 'rate' time
+ * base that is not becomes the sample index, with a note); events at finite times.
+ */
+export declare function checkPlan(plan: ImportPlan): ImportPlan;
+/**
+ * An error as the page shows it: the readers' own messages (plain Errors,
+ * cancellation) as they are; anything else (RangeError, TypeError, a wasm trap,
+ * a stack overflow) means the file broke an assumption: damaged.
+ */
+export declare function friendlyError(e: unknown): Error;

package/dist/types/lib/importers/mat/format.d.ts

@@ -0,0 +1,2 @@
+import type { FormatInfo } from '../formats';
+export declare const MAT_FORMAT: FormatInfo;

package/dist/types/lib/importers/mat/group.d.ts

@@ -0,0 +1,19 @@
+import type { PlanGroup } from '../types';
+/** One plottable vector: a variable, a matrix column or row, a struct field. */
+export interface MatChannel {
+    name: string;
+    length: number;
+    read(s: number, e: number): Promise<Float64Array>;
+}
+export interface MatGroup {
+    name: string;
+    channels: MatChannel[];
+    time: MatChannel | null;
+    rate: number | null;
+    origin: number;
+}
+/** Channels → groups by length, each with its time channel (by name) or a lone rate scalar. */
+export declare function groupChannels(channels: MatChannel[], strings: Map<string, string>, scalars: Map<string, number>): MatGroup[];
+export declare function planGroups(groups: MatGroup[]): PlanGroup[];
+/** The earliest first time value: Time = seconds from it. */
+export declare function setOrigins(groups: MatGroup[]): Promise<void>;

package/dist/types/lib/importers/mat/importer.d.ts

@@ -0,0 +1,2 @@
+import { type Importer } from '../types';
+export declare const matImporter: Importer;

package/dist/types/lib/importers/mat/v5.d.ts

@@ -0,0 +1,24 @@
+import type { BlobReader } from '../blobReader';
+import type { MatChannel } from './group';
+/** Bytes of a variable: the file, or an inflated miCOMPRESSED element. */
+export interface Source {
+    readonly size: number;
+    read(offset: number, length: number): Promise<Uint8Array>;
+    release(): void;
+}
+export declare class ZlibSource implements Source {
+    #private;
+    keep: boolean;
+    readonly size: number;
+    constructor(io: BlobReader, at: number, len: number, inflated: Uint8Array);
+    read(o: number, n: number): Promise<Uint8Array<ArrayBufferLike>>;
+    release(): void;
+}
+export interface V5 {
+    channels: MatChannel[];
+    strings: Map<string, string>;
+    scalars: Map<string, number>;
+    notes: string[];
+    sources: ZlibSource[];
+}
+export declare function readV5(io: BlobReader): Promise<V5>;

package/dist/types/lib/importers/mat/v73.d.ts

@@ -0,0 +1,13 @@
+import { type H5Group } from '../hdf5/h5';
+import type { MatChannel } from './group';
+export interface V73 {
+    channels: MatChannel[];
+    strings: Map<string, string>;
+    scalars: Map<string, number>;
+    notes: string[];
+}
+/**
+ * Variables of a MAT 7.3 file. MATLAB is column-major, so an N×m variable is stored with HDF5 shape [m, N].
+ * `root` stays open for the import (see `openH5`), so the channels read through it later.
+ */
+export declare function readV73(root: H5Group, fileSize: number): V73;

package/dist/types/lib/importers/mdf/blocks3.d.ts

@@ -0,0 +1,3 @@
+import type { BlobReader } from '../blobReader';
+import type { FileModel } from './model';
+export declare function readMdf3(io: BlobReader, idBlock: Uint8Array, version: string): Promise<FileModel>;

package/dist/types/lib/importers/mdf/blocks4.d.ts

@@ -0,0 +1,7 @@
+import type { BlobReader } from '../blobReader';
+import type { FileModel } from './model';
+/** A DZ block inflated whole above this is refused (transposed) or streamed (plain). */
+export declare const MAX_DZ: number;
+/** The text of an MD (XML) block: its <TX>, else the XML without tags (linear: no backtracking on unclosed tags). */
+export declare function mdText(xml: string): string;
+export declare function readMdf4(io: BlobReader, version: string): Promise<FileModel>;

package/dist/types/lib/importers/mdf/bus.d.ts

@@ -0,0 +1,59 @@
+import type { BlobReader } from '../blobReader';
+import { type Dbc, type DbcSignal } from '../dbc';
+import type { Batch, ColumnValues, PlanGroup } from '../types';
+import { type ChannelModel, type FileModel, type GroupModel } from './model';
+/** The members of a CAN_DataFrame structure. */
+export interface FrameLayout {
+    id: ChannelModel;
+    ide: ChannelModel | null;
+    data: ChannelModel;
+}
+export declare function frameLayout(g: GroupModel): FrameLayout | null;
+/** One output group of a message: all its frames (`mux` null) or the frames with one multiplexer value. */
+export interface BusRoute {
+    key: number;
+    mux: number | null;
+    signals: DbcSignal[];
+    /** Plan channels: signal index, and whether it is the value-table text. */
+    channels: {
+        s: number;
+        text: boolean;
+    }[];
+}
+/** A route's frames decoded from one batch of records: their times and the route's channels (all, or the selected ones). */
+interface Chunk {
+    time: Float64Array;
+    cols: ColumnValues[];
+}
+export interface BusPlan {
+    dbc: Dbc;
+    /** Per bus model group: its layout. */
+    layouts: Map<number, FrameLayout>;
+    routes: {
+        model: number;
+        route: BusRoute;
+        group: PlanGroup;
+    }[];
+    notes: string[];
+    /** Every channel of a route, decoded while planning (one pass over the file); the first read of a route takes it over. */
+    cache: Map<BusRoute, Chunk[]>;
+}
+/**
+ * Bus groups → message groups, in one pass over the frames: it counts each
+ * message (and multiplexer value) and its time span, so the plan has exact
+ * counts and rates, and decodes every signal on the way (a read then takes the
+ * values over instead of decoding the file again). Messages that never occur
+ * are left out.
+ */
+export declare function planBus(io: BlobReader, model: FileModel, dbcFiles: File[], signal?: AbortSignal): Promise<BusPlan | null>;
+/**
+ * Batches of the selected message groups of one bus model group: the ones
+ * decoded while planning as they are, the rest decoded in one pass (a batch
+ * per group per batch of records, in frame order).
+ */
+export declare function busBatches(io: BlobReader, model: FileModel, k: number, bus: BusPlan, wanted: {
+    group: number;
+    route: BusRoute;
+    sel: number[];
+}[], signal?: AbortSignal): AsyncGenerator<Batch>;
+export {};

package/dist/types/lib/importers/mdf/conversion.d.ts

@@ -0,0 +1,48 @@
+/** A channel conversion, normalised from MF4 CC and MDF3 CC blocks. */
+export type Conv = {
+    k: 'id';
+} | {
+    k: 'lin';
+    a: number;
+    b: number;
+} | {
+    k: 'rat';
+    p: number[];
+} | {
+    k: 'poly';
+    p: number[];
+} | {
+    k: 'alg';
+    f: (x: number) => number;
+} | {
+    k: 'tab';
+    keys: Float64Array;
+    vals: Float64Array;
+    interp: boolean;
+} | {
+    k: 'rtv';
+    lo: Float64Array;
+    hi: Float64Array;
+    vals: Float64Array;
+    def: number;
+} | TextConv | {
+    k: 'unsupported';
+    what: string;
+};
+/** Value→text (lo = hi) and range→text; a nested numeric conversion shows its number as text. */
+export interface TextConv {
+    k: 'text';
+    ranges: {
+        lo: number;
+        hi: number;
+        to: string | Conv | null;
+    }[];
+    def: string | Conv | null;
+    /** Integer channels: ranges include their upper bound; floats: lo ≤ x < hi. */
+    int: boolean;
+}
+export declare const ID: Conv;
+/** A numeric conversion in place. */
+export declare function convertNumbers(c: Conv, v: Float64Array): void;
+/** Value→text / range→text: one string per value (NaN gives null). */
+export declare function convertText(c: TextConv, v: Float64Array): (string | null)[];

package/dist/types/lib/importers/mdf/decode.d.ts

@@ -0,0 +1,15 @@
+import type { ColumnValues } from '../types';
+import type { ChannelModel } from './model';
+/**
+ * One numeric channel of `n` records (`stride` bytes apart, the record data at
+ * `base`) into `out` from `at`. One loop per type, the type switch outside it;
+ * byte-aligned 8/16/32/64-bit fields read through the DataView directly.
+ */
+export declare function decodeNumeric(ch: ChannelModel, buf: Uint8Array, n: number, stride: number, base: number, out: Float64Array, at?: number): void;
+export declare const decoderFor: (encoding: string) => TextDecoder;
+/** Text up to the first NUL. */
+export declare function trimNul(s: string): string;
+/** A fixed-length string channel. */
+export declare function decodeStrings(ch: ChannelModel, buf: Uint8Array, n: number, stride: number, base: number): (string | null)[];
+/** Invalid samples (invalidation bit set, or the whole channel flagged invalid) become NaN / null. */
+export declare function applyInvalid(ch: ChannelModel, buf: Uint8Array, n: number, stride: number, invalBase: number, out: ColumnValues): void;

package/dist/types/lib/importers/mdf/format.d.ts

@@ -0,0 +1,2 @@
+import type { FormatInfo } from '../formats';
+export declare const MDF_FORMAT: FormatInfo;

package/dist/types/lib/importers/mdf/importer.d.ts

@@ -0,0 +1,19 @@
+import { type Importer } from '../types';
+import { type ChannelModel, type FileModel } from './model';
+import { type BusPlan, type BusRoute } from './bus';
+export interface MdfState {
+    model: FileModel;
+    /** Per plan group: its model group and either the model channels behind its plan channels, or its bus route. */
+    groups: ({
+        model: number;
+        channels: number[];
+        route?: undefined;
+    } | {
+        model: number;
+        channels?: undefined;
+        route: BusRoute;
+    })[];
+    bus: BusPlan | null;
+}
+export declare const isValueChannel: (c: ChannelModel) => boolean;
+export declare const mdfImporter: Importer;