edfcore 0.1.0

package/dist/header/scale.js

@@ -0,0 +1,154 @@
+/**
+ * Digital-to-physical scale, and the decision to refuse one.
+ *
+ * Layer 2. Sole owner of `EdfScale` construction and of the four conditions under which a
+ * signal gets `scale: undefined` instead of a fabricated gain.
+ *
+ * The expression is EDFlib's, verbatim:
+ *
+ *     bitValue = (physicalMaximum - physicalMinimum) / (digitalMaximum - digitalMinimum)
+ *     offset   = physicalMaximum / bitValue - digitalMaximum
+ *     physical = bitValue * (offset + digital)
+ *
+ * The textbook `physicalMinimum + (digital - digitalMinimum) * gain` form is numerically
+ * *better* and is deliberately not used: it shifts up to ~45% of samples by one ULP on
+ * asymmetric ranges, which would forfeit float64 bit-parity with pyEDFlib for a divergence ten
+ * orders of magnitude below the quantisation floor. Do not "simplify" this.
+ *
+ * `physicalMinimum > physicalMaximum` is legal — it is how a negative amplifier gain is
+ * written — and produces a negative `bitValue`. The two are never swapped: a silent polarity
+ * flip is a clinically wrong result that looks perfectly normal.
+ */
+import { trimEdfField } from '../bytes/latin1.js';
+/** EDF+ 'edffloat': a channel whose values are log-compressed, so the linear map is wrong. */
+const LOG_TRANSFORMED_DIMENSION = 'Filtered';
+/** U+00B5 MICRO SIGN, U+03BC GREEK SMALL LETTER MU. A raw 0xB5 header byte decodes to the
+ *  former through Latin-1, so both spellings and the byte are covered. */
+const MICRO_SIGNS = /[µμ]/g;
+const MICRO_REPLACEMENT = 'u';
+const RANGE_SPEC_REFERENCE = 'EDF+ additional specification 5';
+/**
+ * Collapse the encodings of micro to `'u'` so units can be compared.
+ *
+ * For comparison ONLY: `signal.physicalDimension` stays exactly as the file wrote it. Nothing
+ * else is touched — case is meaningful (`mV` is not `MV`), and edfcore does not normalise units
+ * to SI volts.
+ */
+export function normaliseUnit(physicalDimension) {
+    return trimEdfField(physicalDimension).replace(MICRO_SIGNS, MICRO_REPLACEMENT);
+}
+function isLogTransformed(physicalDimension) {
+    return trimEdfField(physicalDimension) === LOG_TRANSFORMED_DIMENSION;
+}
+/** A diagnostic init with the fields that are only known when the caller supplied context. */
+function scaleDiagnostic(input, code, message, field, expected, actual, specReference) {
+    const byteOffset = input.byteOffsets?.[field];
+    const raw = input.raw?.[field];
+    return {
+        code,
+        message,
+        field,
+        signalIndex: input.signalIndex,
+        expected,
+        actual,
+        specReference,
+        ...(byteOffset === undefined ? {} : { byteOffset }),
+        ...(raw === undefined ? {} : { raw }),
+    };
+}
+function describe(input) {
+    return `signal ${input.signalIndex} ${JSON.stringify(input.label)}`;
+}
+/** `'"0       " at byte offset 3400'`, or the value alone when the caller gave no context. */
+function quoteField(input, field) {
+    const raw = input.raw?.[field];
+    const byteOffset = input.byteOffsets?.[field];
+    const rawText = raw === undefined ? '' : `raw ${JSON.stringify(raw)}`;
+    const offsetText = byteOffset === undefined ? '' : `at byte offset ${byteOffset}`;
+    const parts = [rawText, offsetText].filter((part) => part.length > 0);
+    return parts.length === 0 ? '' : ` (${parts.join(' ')})`;
+}
+/**
+ * The scale for one signal, or `undefined` when edfcore refuses to invent one.
+ *
+ * The refusals are checked in this fixed order: degenerate digital range, degenerate physical
+ * range, inverted digital range, log-transformed channel, and finally a derived gain that is not
+ * a usable float64 number. Each is deferred-fatal — `decodeDigital` keeps working on the signal
+ * and `toPhysical` throws `EdfScalingError`.
+ *
+ * A non-finite input returns `undefined` without a diagnostic: the only way to get here with
+ * one is a numeric field that failed its grammar, which the caller has already reported
+ * against the field itself.
+ */
+export function buildScale(input, sink) {
+    const { physicalMinimum, physicalMaximum, digitalMinimum, digitalMaximum } = input;
+    if (!Number.isFinite(physicalMinimum) ||
+        !Number.isFinite(physicalMaximum) ||
+        !Number.isFinite(digitalMinimum) ||
+        !Number.isFinite(digitalMaximum)) {
+        return undefined;
+    }
+    if (digitalMaximum === digitalMinimum) {
+        sink.report(scaleDiagnostic(input, 'DEGENERATE_DIGITAL_RANGE', `${describe(input)} declares digitalMinimum == digitalMaximum == ${digitalMinimum}, ` +
+            'so physical scale is undefined (division by zero)' +
+            `${quoteField(input, 'digitalMinimum')}. ${RANGE_SPEC_REFERENCE}: "Digital maximum ` +
+            'must be larger than Digital minimum". Next: decodeDigital() still works on this ' +
+            'signal; edfcore will not invent a gain.', 'digitalMinimum', 'digitalMaximum > digitalMinimum', `${digitalMinimum} == ${digitalMaximum}`, RANGE_SPEC_REFERENCE));
+        return undefined;
+    }
+    if (physicalMaximum === physicalMinimum) {
+        sink.report(scaleDiagnostic(input, 'DEGENERATE_PHYSICAL_RANGE', `${describe(input)} declares physicalMinimum == physicalMaximum == ` +
+            `${physicalMinimum}, so every digital value would map to the same physical value` +
+            `${quoteField(input, 'physicalMinimum')}. ${RANGE_SPEC_REFERENCE}: "Physical ` +
+            'maximum must differ from Physical minimum". Next: decodeDigital() still works on ' +
+            'this signal; edfcore will not invent a gain.', 'physicalMinimum', 'physicalMaximum != physicalMinimum', `${physicalMinimum} == ${physicalMaximum}`, RANGE_SPEC_REFERENCE));
+        return undefined;
+    }
+    if (digitalMinimum > digitalMaximum) {
+        sink.report(scaleDiagnostic(input, 'INVERTED_DIGITAL_RANGE', `${describe(input)} declares digitalMinimum ${digitalMinimum} greater than ` +
+            `digitalMaximum ${digitalMaximum}${quoteField(input, 'digitalMinimum')}. ` +
+            `${RANGE_SPEC_REFERENCE}: "Digital maximum must be larger than Digital minimum". ` +
+            'Unlike an inverted physical range this has no sanctioned meaning, so edfcore will ' +
+            'not guess whether the fields were swapped or the samples inverted. Next: ' +
+            'decodeDigital() still works on this signal.', 'digitalMinimum', 'digitalMaximum > digitalMinimum', `${digitalMinimum} > ${digitalMaximum}`, RANGE_SPEC_REFERENCE));
+        return undefined;
+    }
+    if (isLogTransformed(input.physicalDimension)) {
+        sink.report(scaleDiagnostic(input, 'LOG_TRANSFORMED_CHANNEL', `${describe(input)} has physical dimension exactly "${LOG_TRANSFORMED_DIMENSION}"` +
+            `${quoteField(input, 'physicalDimension')}, which marks a logarithmically ` +
+            'transformed channel (EDF specification edffloat.html): its samples are ' +
+            'log-compressed, so the linear digital-to-physical map would be wrong by orders of ' +
+            'magnitude. Next: decodeDigital() still works on this signal; edfcore detects the ' +
+            'transform and refuses it rather than applying an inverse it cannot verify.', 'physicalDimension', 'a linear physical dimension', LOG_TRANSFORMED_DIMENSION, 'EDF specification edffloat.html'));
+        return undefined;
+    }
+    if (physicalMinimum > physicalMaximum) {
+        sink.report(scaleDiagnostic(input, 'INVERTED_PHYSICAL_RANGE', `${describe(input)} declares physicalMinimum ${physicalMinimum} greater than ` +
+            `physicalMaximum ${physicalMaximum}${quoteField(input, 'physicalMinimum')}. This ` +
+            'is legal and encodes a negative amplifier gain (EDF FAQ Q6), so bitValue comes ' +
+            'out negative. Next: nothing to do — edfcore never swaps the two, because a silent ' +
+            'polarity flip is a clinically wrong result that looks normal.', 'physicalMinimum', 'physicalMinimum < physicalMaximum, or a deliberate negative gain', `${physicalMinimum} > ${physicalMaximum}`, 'EDF FAQ Q6 (negative amplifier gain)'));
+    }
+    // EDFlib's exact expression. See the module comment before changing either line.
+    const bitValue = (physicalMaximum - physicalMinimum) / (digitalMaximum - digitalMinimum);
+    const offset = physicalMaximum / bitValue - digitalMaximum;
+    // The four INPUTS being finite does not make the DERIVED pair finite. An 8-byte field may write
+    // an exponent, so a physical range can underflow against the digital range (`0`..`5E-324` over
+    // -1..1 gives bitValue 0 and offset Infinity) or overflow it (`-9.9E307`..`9.9E307` gives
+    // bitValue Infinity). Either way `bitValue * (offset + digital)` is NaN or +/-Infinity for every
+    // sample in the channel, which is a fabricated gain by another name — so the scale is refused
+    // exactly as the degenerate cases above are, and `decodeDigital` keeps working.
+    if (bitValue === 0 || !Number.isFinite(bitValue) || !Number.isFinite(offset)) {
+        sink.report(scaleDiagnostic(input, 'DEGENERATE_PHYSICAL_RANGE', `${describe(input)} declares the physical range ${physicalMinimum}..${physicalMaximum} ` +
+            `over the digital range ${digitalMinimum}..${digitalMaximum}` +
+            `${quoteField(input, 'physicalMaximum')}, and the gain those imply is not a usable ` +
+            `float64 number: bitValue is ${bitValue} and offset is ${offset}, so ` +
+            'bitValue * (offset + digital) is NaN or infinite for every sample. ' +
+            `${RANGE_SPEC_REFERENCE}. Next: decodeDigital() still works on this signal; edfcore ` +
+            'will not invent a gain, and a physical range this far outside float64 is a corrupt ' +
+            'field rather than a calibration.', 'physicalMaximum', 'a physical range that defines a finite, non-zero gain', `bitValue ${bitValue}, offset ${offset}`, RANGE_SPEC_REFERENCE));
+        return undefined;
+    }
+    return { bitValue, offset };
+}
+//# sourceMappingURL=scale.js.map

package/dist/header/scale.js.map

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

package/dist/header/signals.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The per-signal header, and where each signal's bytes live inside a data record.
+ *
+ * Layer 2. Sole owner of `recordByteOffset` arithmetic.
+ *
+ * The per-signal header is FIELD-MAJOR: all `ns` labels, then all `ns` transducer types, and so
+ * on for ten fields, `ns * 256` bytes in total. It is NOT one 256-byte struct per signal, and
+ * reading it as one is the single most common EDF bug — it happens to produce plausible output
+ * for a one-signal file, which is exactly how it survives a first test.
+ *
+ *     address(field, i) = 256 + ns * SIGNAL_FIELD_BLOCK_OFFSETS[field] + i * WIDTHS[field]
+ *
+ * Inside a data record the signals are stored back to back in signal order, each contributing
+ * `samplesPerRecord * bytesPerSample` bytes. Both numbers come from this file and nowhere else.
+ */
+import { SIGNAL_FIELD_WIDTHS } from '../constants.js';
+import { type DiagnosticSink } from '../diagnostics/collector.js';
+import type { EdfSignal } from '../types.js';
+import type { EdfVariantInfo } from './variant.js';
+/** The ten per-signal fields, in file order. */
+export type SignalFieldName = keyof typeof SIGNAL_FIELD_WIDTHS;
+/**
+ * Everything about one signal that does not depend on the resolved record count.
+ *
+ * The record count is resolved AFTER the per-signal blocks — recovering it needs the record
+ * size, which needs `samplesPerRecord` — so `sampleCount` is the one field that cannot be filled
+ * in here. `buildSignals` adds it once the count is known.
+ */
+export type SignalDraft = Omit<EdfSignal, 'sampleCount'>;
+export interface SignalHeaderInput {
+    /** At least `256 * (signalCount + 1)` bytes; the caller has already refused anything less. */
+    readonly headerBytes: Uint8Array;
+    readonly signalCount: number;
+    readonly variant: EdfVariantInfo;
+    /** May be 0, in which case no signal gets a sample rate. Never divided by. */
+    readonly recordDurationSeconds: number;
+}
+export interface ParsedSignalHeaders {
+    readonly signals: readonly SignalDraft[];
+    /** `bytesPerSample * SUM(samplesPerRecord)`. May be 0; the caller decides that is fatal. */
+    readonly recordByteLength: number;
+    readonly dataSignalIndices: readonly number[];
+    readonly annotationSignalIndices: readonly number[];
+}
+/**
+ * The byte offset of one per-signal field, for one signal.
+ *
+ * Plain arithmetic on plain numbers: a 512-signal header is 131 KB, and nothing here is ever
+ * near 2^31, but the same expression is what every offset in the file is built on and `|0` has
+ * no business anywhere in it.
+ */
+export declare function signalFieldOffset(field: SignalFieldName, signalCount: number, signalIndex: number): number;
+/**
+ * Parse the whole per-signal header.
+ *
+ * Check order within one signal is fixed and deliberate: samples per record (the offsets depend
+ * on it), then the digital range, then the physical range, then the range checks, then the
+ * annotation-signal conformance, then the scale. Cross-signal checks — duplicate labels, then a
+ * missing EDF+ marker — run once at the end, when every label is known.
+ */
+export declare function parseSignalHeaders(input: SignalHeaderInput, sink: DiagnosticSink): ParsedSignalHeaders;
+/** The drafts, completed with the sample count the resolved record count implies. */
+export declare function buildSignals(drafts: readonly SignalDraft[], recordCount: number): readonly EdfSignal[];
+//# sourceMappingURL=signals.d.ts.map

package/dist/header/signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signals.d.ts","sourceRoot":"","sources":["../../src/header/signals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH,OAAO,EAGL,mBAAmB,EACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,KAAK,cAAc,EAAc,MAAM,6BAA6B,CAAC;AAC9E,OAAO,KAAK,EAAgC,SAAS,EAAE,MAAM,aAAa,CAAC;AAI3E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,gDAAgD;AAChD,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,mBAAmB,CAAC;AAE/D;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,IAAI,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;AAEzD,MAAM,WAAW,iBAAiB;IAChC,8FAA8F;IAC9F,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC;IACjC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IACjC,8EAA8E;IAC9E,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;CACxC;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IACzC,4FAA4F;IAC5F,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9C,QAAQ,CAAC,uBAAuB,EAAE,SAAS,MAAM,EAAE,CAAC;CACrD;AAqBD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,eAAe,EACtB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,MAAM,CAMR;AAsRD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,iBAAiB,EACxB,IAAI,EAAE,cAAc,GACnB,mBAAmB,CA0JrB;AAED,qFAAqF;AACrF,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,WAAW,EAAE,EAC9B,WAAW,EAAE,MAAM,GAClB,SAAS,SAAS,EAAE,CAItB"}

package/dist/header/signals.js

@@ -0,0 +1,374 @@
+/**
+ * The per-signal header, and where each signal's bytes live inside a data record.
+ *
+ * Layer 2. Sole owner of `recordByteOffset` arithmetic.
+ *
+ * The per-signal header is FIELD-MAJOR: all `ns` labels, then all `ns` transducer types, and so
+ * on for ten fields, `ns * 256` bytes in total. It is NOT one 256-byte struct per signal, and
+ * reading it as one is the single most common EDF bug — it happens to produce plausible output
+ * for a one-signal file, which is exactly how it survives a first test.
+ *
+ *     address(field, i) = 256 + ns * SIGNAL_FIELD_BLOCK_OFFSETS[field] + i * WIDTHS[field]
+ *
+ * Inside a data record the signals are stored back to back in signal order, each contributing
+ * `samplesPerRecord * bytesPerSample` bytes. Both numbers come from this file and nowhere else.
+ */
+import { trimEdfField } from '../bytes/latin1.js';
+import { parseEdfInteger, parseEdfNumber } from '../bytes/numbers.js';
+import { readAsciiField } from '../bytes/view.js';
+import { EDF_HEADER_BLOCK_BYTES, SIGNAL_FIELD_BLOCK_OFFSETS, SIGNAL_FIELD_WIDTHS, } from '../constants.js';
+import { fatalError } from '../diagnostics/collector.js';
+import { requireNumericField } from './fields.js';
+import { isAnnotationLabel } from './lookup.js';
+import { buildScale, normaliseUnit } from './scale.js';
+const SIGNAL_SPEC_REFERENCE = 'EDF specification, header record, per-signal fields (field-major, ns * 256 bytes from ' +
+    'byte 256)';
+const DIGITAL_RANGE_SPEC_REFERENCE = 'EDF+ additional specification 5';
+const ANNOTATION_SPEC_REFERENCE = 'EDF+ specification 2.2.4 (the "EDF Annotations" signal)';
+const FIELD_DESCRIPTIONS = {
+    label: 'label',
+    transducerType: 'transducer type',
+    physicalDimension: 'physical dimension',
+    physicalMinimum: 'physical minimum',
+    physicalMaximum: 'physical maximum',
+    digitalMinimum: 'digital minimum',
+    digitalMaximum: 'digital maximum',
+    prefiltering: 'prefiltering',
+    samplesPerRecord: 'number of samples in each data record',
+    reserved: 'reserved field',
+};
+/**
+ * The byte offset of one per-signal field, for one signal.
+ *
+ * Plain arithmetic on plain numbers: a 512-signal header is 131 KB, and nothing here is ever
+ * near 2^31, but the same expression is what every offset in the file is built on and `|0` has
+ * no business anywhere in it.
+ */
+export function signalFieldOffset(field, signalCount, signalIndex) {
+    return (EDF_HEADER_BLOCK_BYTES +
+        signalCount * SIGNAL_FIELD_BLOCK_OFFSETS[field] +
+        signalIndex * SIGNAL_FIELD_WIDTHS[field]);
+}
+function readSignalField(input, field, signalIndex) {
+    return readAsciiField(input.headerBytes, signalFieldOffset(field, input.signalCount, signalIndex), SIGNAL_FIELD_WIDTHS[field]);
+}
+function readRawSignalFields(input, signalIndex) {
+    return {
+        label: readSignalField(input, 'label', signalIndex),
+        transducerType: readSignalField(input, 'transducerType', signalIndex),
+        physicalDimension: readSignalField(input, 'physicalDimension', signalIndex),
+        physicalMinimum: readSignalField(input, 'physicalMinimum', signalIndex),
+        physicalMaximum: readSignalField(input, 'physicalMaximum', signalIndex),
+        digitalMinimum: readSignalField(input, 'digitalMinimum', signalIndex),
+        digitalMaximum: readSignalField(input, 'digitalMaximum', signalIndex),
+        prefiltering: readSignalField(input, 'prefiltering', signalIndex),
+        samplesPerRecord: readSignalField(input, 'samplesPerRecord', signalIndex),
+        reserved: readSignalField(input, 'reserved', signalIndex),
+    };
+}
+function scaleFieldOffsets(input, signalIndex) {
+    const ns = input.signalCount;
+    return {
+        physicalDimension: signalFieldOffset('physicalDimension', ns, signalIndex),
+        physicalMinimum: signalFieldOffset('physicalMinimum', ns, signalIndex),
+        physicalMaximum: signalFieldOffset('physicalMaximum', ns, signalIndex),
+        digitalMinimum: signalFieldOffset('digitalMinimum', ns, signalIndex),
+        digitalMaximum: signalFieldOffset('digitalMaximum', ns, signalIndex),
+    };
+}
+function numericContext(input, field, signalIndex, expected, nextStep, specReference) {
+    const byteOffset = signalFieldOffset(field, input.signalCount, signalIndex);
+    const byteLength = SIGNAL_FIELD_WIDTHS[field];
+    return {
+        field,
+        description: `${FIELD_DESCRIPTIONS[field]} of signal ${signalIndex} (${byteLength} bytes at offset ` +
+            `${byteOffset})`,
+        byteOffset,
+        byteLength,
+        expected,
+        specReference,
+        nextStep,
+        signalIndex,
+    };
+}
+/**
+ * `samplesPerRecord` for one signal: the field every byte offset in the data section is built
+ * from, so it is fatal in every way it can fail except one.
+ *
+ * Zero is the exception. It is a warning: a signal contributing no samples is a writer's mistake
+ * rather than an unreadable file, every other signal still has an exact offset, and refusing the
+ * file would refuse the readable channels with it.
+ */
+function parseSamplesPerRecord(input, raw, signalIndex, sink) {
+    const context = numericContext(input, 'samplesPerRecord', signalIndex, 'a whole number of samples, written in ASCII digits', 'every byte offset inside a data record is a running sum of this field over the signals ' +
+        'before it, so no sample in the file can be located while it is unreadable', SIGNAL_SPEC_REFERENCE);
+    const samplesPerRecord = requireNumericField(parseEdfInteger(raw), context, sink);
+    if (samplesPerRecord < 0) {
+        throw fatalError({
+            code: 'NUMERIC_FIELD_INVALID',
+            message: `${context.description} is ${JSON.stringify(raw)}, i.e. ${samplesPerRecord} samples. A ` +
+                'signal cannot contribute a negative number of bytes to a data record, and the ' +
+                `offsets of every later signal are a running sum of this field. ${context.specReference}. ` +
+                `Next: ${context.nextStep}.`,
+            field: context.field,
+            byteOffset: context.byteOffset,
+            byteLength: context.byteLength,
+            raw,
+            expected: '0 or more samples',
+            actual: String(samplesPerRecord),
+            signalIndex,
+            specReference: context.specReference,
+        });
+    }
+    if (samplesPerRecord === 0) {
+        sink.report({
+            code: 'ZERO_SAMPLES_PER_RECORD',
+            message: `${context.description} is ${JSON.stringify(raw)}: this signal contributes no bytes to ` +
+                `a data record and therefore carries no samples at all. ${context.specReference}: a ` +
+                'signal is present in every data record. Next: the signal is still exposed, with ' +
+                'sampleCount 0 and a zero-length block; decoding it returns an empty array, and the ' +
+                'other signals are unaffected because their offsets skip it exactly.',
+            field: context.field,
+            byteOffset: context.byteOffset,
+            byteLength: context.byteLength,
+            raw,
+            expected: '1 or more samples',
+            actual: '0',
+            signalIndex,
+            specReference: SIGNAL_SPEC_REFERENCE,
+        });
+    }
+    return samplesPerRecord;
+}
+/**
+ * The declared digital range against what the sample width can represent: 16-bit two's
+ * complement for EDF, 24-bit for BDF.
+ *
+ * A warning, not an error. The declaration is what scaling uses, and a range wider than the
+ * format means the writer's scale is inconsistent with its own samples — but the samples still
+ * decode, and edfcore reports the mismatch rather than choosing a range for it.
+ */
+function checkDigitalRangeFitsFormat(input, signalIndex, digitalMinimum, digitalMaximum, raw, sink) {
+    const low = input.variant.digitalMinimumLimit;
+    const high = input.variant.digitalMaximumLimit;
+    const outside = [digitalMinimum, digitalMaximum].some((value) => value < low || value > high);
+    if (!outside)
+        return;
+    const byteOffset = signalFieldOffset('digitalMinimum', input.signalCount, signalIndex);
+    sink.report({
+        code: 'DIGITAL_RANGE_EXCEEDS_FORMAT',
+        message: `signal ${signalIndex} declares the digital range ${digitalMinimum}..${digitalMaximum} ` +
+            `(raw ${JSON.stringify(raw.digitalMinimum)} and ` +
+            `${JSON.stringify(raw.digitalMaximum)} at byte offsets ${byteOffset} and ` +
+            `${signalFieldOffset('digitalMaximum', input.signalCount, signalIndex)}), but a ` +
+            `${input.variant.family} sample is ${input.variant.bytesPerSample * 8}-bit two's ` +
+            `complement and can only hold ${low}..${high}. ${DIGITAL_RANGE_SPEC_REFERENCE}. Next: ` +
+            'the declared range is used for scaling exactly as written — edfcore never clamps — so ' +
+            'expect physical values that extrapolate beyond the declared physical range.',
+        field: 'digitalMinimum',
+        byteOffset,
+        byteLength: SIGNAL_FIELD_WIDTHS.digitalMinimum,
+        raw: raw.digitalMinimum,
+        expected: `${low}..${high}`,
+        actual: `${digitalMinimum}..${digitalMaximum}`,
+        signalIndex,
+        specReference: DIGITAL_RANGE_SPEC_REFERENCE,
+    });
+}
+/**
+ * The EDF+ requirements on an annotation signal's own header block.
+ *
+ * Reported and then ignored: a non-conformant annotation header says nothing about whether the
+ * TALs inside the channel are readable, and they usually are. The digital range is checked
+ * against the exact values the dialect prescribes, not against the representable range.
+ */
+function checkAnnotationSignalHeader(input, signalIndex, raw, digitalMinimum, digitalMaximum, sink) {
+    const expectedMinimum = input.variant.digitalMinimumLimit;
+    const expectedMaximum = input.variant.digitalMaximumLimit;
+    const defects = [];
+    if (digitalMinimum !== expectedMinimum) {
+        defects.push(`digital minimum ${JSON.stringify(raw.digitalMinimum)} instead of ${expectedMinimum}`);
+    }
+    if (digitalMaximum !== expectedMaximum) {
+        defects.push(`digital maximum ${JSON.stringify(raw.digitalMaximum)} instead of ${expectedMaximum}`);
+    }
+    if (trimEdfField(raw.transducerType).length > 0) {
+        defects.push(`a non-blank transducer type ${JSON.stringify(trimEdfField(raw.transducerType))}`);
+    }
+    if (trimEdfField(raw.prefiltering).length > 0) {
+        defects.push(`a non-blank prefiltering field ${JSON.stringify(trimEdfField(raw.prefiltering))}`);
+    }
+    if (defects.length === 0)
+        return;
+    sink.report({
+        code: 'ANNOTATION_SIGNAL_HEADER_NONCONFORMANT',
+        message: `annotation signal ${signalIndex} (label ${JSON.stringify(trimEdfField(raw.label))}) has ` +
+            `${defects.join(', ')}. ${ANNOTATION_SPEC_REFERENCE}: the annotations signal must ` +
+            `declare digital minimum ${expectedMinimum} and digital maximum ${expectedMaximum}, and ` +
+            'leave transducer type and prefiltering blank, because the channel carries text rather ' +
+            'than measurements. Next: the annotations are read anyway — the header block of an ' +
+            'annotation signal only sizes its region, and that comes from samplesPerRecord.',
+        field: 'label',
+        byteOffset: signalFieldOffset('label', input.signalCount, signalIndex),
+        byteLength: SIGNAL_FIELD_WIDTHS.label,
+        raw: raw.label,
+        expected: `digital range ${expectedMinimum}..${expectedMaximum}, blank transducer and prefiltering`,
+        actual: defects.join(', '),
+        signalIndex,
+        specReference: ANNOTATION_SPEC_REFERENCE,
+    });
+}
+/**
+ * One diagnostic per duplicated label, naming every signal that carries it.
+ *
+ * Annotation signals are excluded, and that is not a leniency: EDF+ allows several annotation
+ * channels and requires every one of them to be labelled `'EDF Annotations'`, so warning about
+ * them would report a defect against a conformant file — and under `strict` it would refuse one.
+ * `getSignal(header, 'EDF Annotations')` still throws on a file with two of them; the way to
+ * address those channels is `header.annotationSignalIndices`.
+ */
+function checkDuplicateLabels(input, drafts, sink) {
+    const byLabel = new Map();
+    for (const draft of drafts) {
+        if (draft.kind === 'annotations')
+            continue;
+        const indices = byLabel.get(draft.label);
+        if (indices === undefined)
+            byLabel.set(draft.label, [draft.index]);
+        else
+            indices.push(draft.index);
+    }
+    for (const [label, indices] of byLabel) {
+        const collision = indices[1];
+        if (collision === undefined)
+            continue;
+        sink.report({
+            code: 'DUPLICATE_SIGNAL_LABEL',
+            message: `signals ${indices.join(', ')} all carry the label ${JSON.stringify(label)}. A label ` +
+                'identifies a channel, so a repeated one leaves no way to name these signals apart. ' +
+                `${SIGNAL_SPEC_REFERENCE}. Next: getSignal(header, ${JSON.stringify(label)}) throws ` +
+                'EdfAmbiguousChannelError listing these indices rather than silently returning the ' +
+                'first; use findSignals() to see them all, or select by index.',
+            field: 'label',
+            byteOffset: signalFieldOffset('label', input.signalCount, collision),
+            byteLength: SIGNAL_FIELD_WIDTHS.label,
+            raw: label,
+            expected: 'a label unique within the file',
+            actual: `${indices.length} signals labelled ${JSON.stringify(label)}`,
+            signalIndex: collision,
+            specReference: SIGNAL_SPEC_REFERENCE,
+        });
+    }
+}
+/**
+ * Parse the whole per-signal header.
+ *
+ * Check order within one signal is fixed and deliberate: samples per record (the offsets depend
+ * on it), then the digital range, then the physical range, then the range checks, then the
+ * annotation-signal conformance, then the scale. Cross-signal checks — duplicate labels, then a
+ * missing EDF+ marker — run once at the end, when every label is known.
+ */
+export function parseSignalHeaders(input, sink) {
+    const drafts = [];
+    const dataSignalIndices = [];
+    const annotationSignalIndices = [];
+    let recordByteOffset = 0;
+    for (let index = 0; index < input.signalCount; index++) {
+        const raw = readRawSignalFields(input, index);
+        const label = trimEdfField(raw.label);
+        const kind = isAnnotationLabel(label) ? 'annotations' : 'data';
+        const samplesPerRecord = parseSamplesPerRecord(input, raw.samplesPerRecord, index, sink);
+        const digitalMinimum = requireNumericField(parseEdfInteger(raw.digitalMinimum), numericContext(input, 'digitalMinimum', index, 'a whole number, written in ASCII digits', 'the digital range defines the scale of this signal, and edfcore will not read a ' +
+            'physical value off a range it cannot read', DIGITAL_RANGE_SPEC_REFERENCE), sink);
+        const digitalMaximum = requireNumericField(parseEdfInteger(raw.digitalMaximum), numericContext(input, 'digitalMaximum', index, 'a whole number, written in ASCII digits', 'the digital range defines the scale of this signal, and edfcore will not read a ' +
+            'physical value off a range it cannot read', DIGITAL_RANGE_SPEC_REFERENCE), sink);
+        const physicalMinimum = requireNumericField(parseEdfNumber(raw.physicalMinimum), numericContext(input, 'physicalMinimum', index, 'a number, written in ASCII digits with "." as the decimal separator', 'the physical range defines the scale of this signal, and edfcore will not invent a ' +
+            'gain for a range it cannot read', SIGNAL_SPEC_REFERENCE), sink);
+        const physicalMaximum = requireNumericField(parseEdfNumber(raw.physicalMaximum), numericContext(input, 'physicalMaximum', index, 'a number, written in ASCII digits with "." as the decimal separator', 'the physical range defines the scale of this signal, and edfcore will not invent a ' +
+            'gain for a range it cannot read', SIGNAL_SPEC_REFERENCE), sink);
+        checkDigitalRangeFitsFormat(input, index, digitalMinimum, digitalMaximum, raw, sink);
+        let scale;
+        if (kind === 'annotations') {
+            checkAnnotationSignalHeader(input, index, raw, digitalMinimum, digitalMaximum, sink);
+            // No scale is built for an annotation channel, and that is not a refusal: its bytes are
+            // TAL text, so there is no measurement to scale. Running the degenerate-range checks over
+            // it would report a defect about a number nobody may use.
+            annotationSignalIndices.push(index);
+        }
+        else {
+            scale = buildScale({
+                signalIndex: index,
+                label,
+                physicalDimension: raw.physicalDimension,
+                physicalMinimum,
+                physicalMaximum,
+                digitalMinimum,
+                digitalMaximum,
+                raw,
+                byteOffsets: scaleFieldOffsets(input, index),
+            }, sink);
+            dataSignalIndices.push(index);
+        }
+        const recordByteLength = samplesPerRecord * input.variant.bytesPerSample;
+        drafts.push({
+            index,
+            kind,
+            label,
+            transducerType: trimEdfField(raw.transducerType),
+            prefiltering: trimEdfField(raw.prefiltering),
+            physicalDimension: trimEdfField(raw.physicalDimension),
+            unit: normaliseUnit(raw.physicalDimension),
+            physicalMinimum,
+            physicalMaximum,
+            digitalMinimum,
+            digitalMaximum,
+            samplesPerRecord,
+            // Undefined exactly when the record duration is 0, which is legal. Dividing by it there
+            // would produce Infinity and label it a sample rate.
+            sampleRateHz: input.recordDurationSeconds === 0
+                ? undefined
+                : samplesPerRecord / input.recordDurationSeconds,
+            scale,
+            recordByteOffset,
+            recordByteLength,
+            raw,
+        });
+        recordByteOffset += recordByteLength;
+    }
+    checkDuplicateLabels(input, drafts, sink);
+    const firstAnnotation = annotationSignalIndices[0];
+    if (firstAnnotation !== undefined && !input.variant.isPlus) {
+        const first = firstAnnotation;
+        const label = drafts[first]?.label ?? input.variant.annotationsLabel;
+        sink.report({
+            code: 'MISSING_EDFPLUS_MARKER',
+            message: `signal ${first} is labelled ${JSON.stringify(label)} but the reserved field of the ` +
+                'fixed header carries no EDF+/BDF+ marker, so the file claims to be plain ' +
+                `${input.variant.family} while carrying an EDF+ annotations channel. EDF+ ` +
+                'specification 2.1.1: an EDF+ file states "EDF+C" or "EDF+D" in the reserved field. ' +
+                'Next: the annotations are parsed anyway, and the channel is never exposed as an ' +
+                'ordinary signal — it is in header.annotationSignalIndices, not in ' +
+                'header.dataSignalIndices — because decoding TAL text as samples produces numbers that ' +
+                'look like a signal.',
+            field: 'reserved',
+            byteOffset: signalFieldOffset('label', input.signalCount, first),
+            byteLength: SIGNAL_FIELD_WIDTHS.label,
+            raw: label,
+            expected: '"EDF+C" or "EDF+D" in the reserved field at offset 192',
+            actual: 'no EDF+/BDF+ marker',
+            signalIndex: first,
+            specReference: 'EDF+ specification 2.1.1 (the EDF+ header)',
+        });
+    }
+    return {
+        signals: Object.freeze(drafts),
+        recordByteLength: recordByteOffset,
+        dataSignalIndices: Object.freeze(dataSignalIndices),
+        annotationSignalIndices: Object.freeze(annotationSignalIndices),
+    };
+}
+/** The drafts, completed with the sample count the resolved record count implies. */
+export function buildSignals(drafts, recordCount) {
+    return Object.freeze(drafts.map((draft) => ({ ...draft, sampleCount: draft.samplesPerRecord * recordCount })));
+}
+//# sourceMappingURL=signals.js.map

package/dist/header/signals.js.map

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