edfcore 0.1.0

package/dist/header/fields.js

@@ -0,0 +1,363 @@
+/**
+ * The ten fixed header fields.
+ *
+ * Layer 2. Sole owner of the 256-byte fixed header: where each field lives, what its bytes say
+ * verbatim, and which diagnostic a field that fails its grammar deserves. It owns no ORDER —
+ * `header/parse.ts` decides that and calls the functions here one field at a time, because the
+ * fixed header has to be read in dependency order rather than in file order (the signal count
+ * has to be trusted before the header-size field is worth reading at all).
+ *
+ * Raw first, always: a numeric field that failed to parse is exactly the case where the caller
+ * needs the bytes as written, so every field is exposed as text before it is interpreted.
+ */
+import { hasNonPrintableAscii } from '../bytes/latin1.js';
+import { parseEdfInteger, parseEdfNumber } from '../bytes/numbers.js';
+import { readAsciiField, sliceBytes } from '../bytes/view.js';
+import { EDF_MAX_SIGNAL_COUNT, HEADER_FIELDS, TICKS_PER_SECOND } from '../constants.js';
+import { fatalError } from '../diagnostics/collector.js';
+const CHAR_NUL = 0x00;
+const CHAR_SPACE = 0x20;
+/** Enough bytes to recognise the problem in a message without pasting an 80-byte field. */
+const RAW_EVIDENCE_MAX_BYTES = 16;
+/** 10^7 is far below 2^53, so this conversion is exact. */
+const TICKS_PER_SECOND_FLOAT = Number(TICKS_PER_SECOND);
+const FIELD_DESCRIPTIONS = {
+    version: 'version of this data format',
+    patientId: 'local patient identification',
+    recordingId: 'local recording identification',
+    startDate: 'startdate of the recording',
+    startTime: 'starttime of the recording',
+    headerByteLength: 'number of bytes in the header record',
+    reserved: 'reserved field',
+    recordCount: 'number of data records',
+    recordDuration: 'duration of a data record in seconds',
+    signalCount: 'number of signals',
+};
+/**
+ * The text fields whose bytes are checked against the spec's printable-ASCII alphabet.
+ *
+ * `version` is excluded because BDF's is 0xFF followed by `'BIOSEMI'` by definition. The numeric
+ * fields are excluded because a byte outside the alphabet there fails the grammar instead, which
+ * is a stronger statement than "unusual bytes".
+ */
+const ASCII_CHECKED_FIELDS = [
+    'patientId',
+    'recordingId',
+    'startDate',
+    'startTime',
+    'reserved',
+];
+/** `'EDF specification, header record bytes 236-243'`. */
+export function fixedFieldSpecReference(field) {
+    const { offset, length } = HEADER_FIELDS[field];
+    return `EDF specification, header record bytes ${offset}-${offset + length - 1}`;
+}
+/** `'number of data records (8 bytes at offset 236)'`. */
+export function describeFixedField(field) {
+    const { offset, length } = HEADER_FIELDS[field];
+    return `${FIELD_DESCRIPTIONS[field]} (${length} bytes at offset ${offset})`;
+}
+/** Every fixed field as the text it holds, padding included and nothing interpreted. */
+export function readRawHeaderFields(headerBytes) {
+    const read = (field) => readAsciiField(headerBytes, HEADER_FIELDS[field].offset, HEADER_FIELDS[field].length);
+    return {
+        version: read('version'),
+        patientId: read('patientId'),
+        recordingId: read('recordingId'),
+        startDate: read('startDate'),
+        startTime: read('startTime'),
+        headerByteLength: read('headerByteLength'),
+        reserved: read('reserved'),
+        recordCount: read('recordCount'),
+        recordDuration: read('recordDuration'),
+        signalCount: read('signalCount'),
+    };
+}
+function isPadding(code) {
+    return code === CHAR_SPACE || code === CHAR_NUL;
+}
+/**
+ * The bounds of a field's content inside its own bytes, stripping the same padding
+ * `trimEdfField` does.
+ *
+ * Padding is excluded on purpose: `NON_ASCII_HEADER_FIELD` is about what the field SAYS, and a
+ * writer that pads with NUL instead of space has produced the same value. That deviation is
+ * already reported for numeric fields, as `NUMERIC_FIELD_NOT_LEFT_JUSTIFIED`.
+ */
+function contentBounds(raw) {
+    let start = 0;
+    let end = raw.length;
+    while (end > start && isPadding(raw.charCodeAt(end - 1)))
+        end--;
+    while (start < end && isPadding(raw.charCodeAt(start)))
+        start++;
+    return { start, end };
+}
+function hexBytes(bytes) {
+    const shown = bytes.subarray(0, RAW_EVIDENCE_MAX_BYTES);
+    const parts = [];
+    for (const byte of shown)
+        parts.push(`0x${byte.toString(16).padStart(2, '0')}`);
+    return parts.join(' ') + (bytes.length > shown.length ? ' ...' : '');
+}
+/**
+ * Report `NON_ASCII_HEADER_FIELD` for every fixed text field carrying a byte outside ASCII
+ * 32..126.
+ *
+ * A warning, never more: the field still decodes truthfully, because edfcore reads header text
+ * as ISO-8859-1 — real equipment writes accented patient names and a bare 0xB5 for micro.
+ */
+export function reportNonAsciiHeaderFields(headerBytes, sink) {
+    for (const field of ASCII_CHECKED_FIELDS) {
+        const { offset, length } = HEADER_FIELDS[field];
+        const raw = readAsciiField(headerBytes, offset, length);
+        const { start, end } = contentBounds(raw);
+        const content = sliceBytes(headerBytes, offset + start, end - start);
+        if (!hasNonPrintableAscii(content))
+            continue;
+        sink.report({
+            code: 'NON_ASCII_HEADER_FIELD',
+            message: `${describeFixedField(field)} is ${JSON.stringify(raw)} and carries bytes outside ` +
+                `printable ASCII 32..126: ${hexBytes(content)}. The EDF specification restricts header ` +
+                'text to ASCII 32..126. Next: nothing is lost — edfcore decodes header text as ' +
+                'ISO-8859-1 (never TextDecoder, whose "latin1" label decodes 0x80 differently in Node ' +
+                'and in a browser), so read the field as Latin-1 rather than as UTF-8.',
+            field,
+            byteOffset: offset,
+            byteLength: length,
+            rawBytes: content,
+            raw,
+            expected: 'ASCII 32..126',
+            actual: hexBytes(content),
+            specReference: fixedFieldSpecReference(field),
+        });
+    }
+}
+function contextInit(context, raw) {
+    return {
+        field: context.field,
+        byteOffset: context.byteOffset,
+        byteLength: context.byteLength,
+        raw,
+        expected: context.expected,
+        specReference: context.specReference,
+        ...(context.signalIndex === undefined ? {} : { signalIndex: context.signalIndex }),
+    };
+}
+/**
+ * `'0,5'` is a half and `'1,024'` is one thousand and twenty-four, and nothing in the bytes says
+ * which was meant — so this is fatal with no opt-in, at every call site.
+ */
+function commaError(parse, context) {
+    return fatalError({
+        code: 'COMMA_DECIMAL_SEPARATOR',
+        message: `${context.description} is ${JSON.stringify(parse.raw)}, which uses a comma as the ` +
+            'decimal separator. "0,5" (a half) and "1,024" (one thousand and twenty-four) are ' +
+            'indistinguishable, and substituting "." in the second silently turns 1024 into 1.024, ' +
+            `so edfcore refuses to guess. ${context.specReference}: the field is an ASCII number ` +
+            'with "." as the decimal separator. Next: rewrite the field in the source file — the ' +
+            'docs carry a preprocessing recipe — because no reading of these bytes is safe.',
+        ...contextInit(context, parse.raw),
+        actual: parse.raw,
+    });
+}
+function invalidError(parse, context) {
+    const blank = parse.problem === 'empty' ? ' (blank)' : '';
+    return fatalError({
+        code: 'NUMERIC_FIELD_INVALID',
+        message: `${context.description} is ${JSON.stringify(parse.raw)}${blank}, which is not ` +
+            `${context.expected}. ${context.specReference}. Next: ${context.nextStep}.`,
+        ...contextInit(context, parse.raw),
+        actual: parse.raw,
+    });
+}
+/**
+ * The value is trustworthy, the layout is not: leading padding means the writer right-justified
+ * the field, and a NUL in the padding means it used the wrong pad byte.
+ */
+function reportLayout(parse, context, sink) {
+    if (parse.problem !== 'not-left-justified')
+        return;
+    sink.report({
+        code: 'NUMERIC_FIELD_NOT_LEFT_JUSTIFIED',
+        message: `${context.description} is ${JSON.stringify(parse.raw)}: the value ${parse.value} was ` +
+            'read from it, but the field is right-justified or NUL-padded, where EDF requires the ' +
+            `digits to start at the first byte and the rest of the field to be spaces. ` +
+            `${context.specReference}. Next: nothing to do — the value is used as read, and ` +
+            'header.raw keeps the bytes as written.',
+        ...contextInit(context, parse.raw),
+        actual: parse.raw,
+    });
+}
+/**
+ * The value of a field that edfcore cannot proceed without.
+ *
+ * A comma decimal or a failed grammar throws: these fields decide where bytes are and what they
+ * mean, so a wrong reading would be worse than no reading.
+ */
+export function requireNumericField(parse, context, sink) {
+    if (parse.problem === 'comma-decimal')
+        throw commaError(parse, context);
+    if (!parse.ok)
+        throw invalidError(parse, context);
+    reportLayout(parse, context, sink);
+    return parse.value;
+}
+/**
+ * The value of a field edfcore can survive without, or `NaN` when it could not be read.
+ *
+ * Only for the two fields with an authoritative alternative source — the declared header size,
+ * which always loses to the computed one, and the record count, which is recoverable from the
+ * source length. The caller reports what it did instead; a comma decimal is still fatal.
+ */
+export function readNumericField(parse, context, sink) {
+    if (parse.problem === 'comma-decimal')
+        throw commaError(parse, context);
+    if (!parse.ok)
+        return Number.NaN;
+    reportLayout(parse, context, sink);
+    return parse.value;
+}
+function fixedContext(field, expected, nextStep) {
+    const { offset, length } = HEADER_FIELDS[field];
+    return {
+        field,
+        description: describeFixedField(field),
+        byteOffset: offset,
+        byteLength: length,
+        expected,
+        specReference: fixedFieldSpecReference(field),
+        nextStep,
+    };
+}
+/**
+ * The signal count at offset 252, validated to 1..9999.
+ *
+ * Fatal on anything else, including a comma, and deliberately reported as
+ * `SIGNAL_COUNT_INVALID` rather than as the generic numeric codes: every per-signal field
+ * address is `256 + ns * blockOffset + i * width`, so an unusable ns makes every byte after the
+ * fixed header unlocatable. It is validated before any ns-sized allocation for the same reason.
+ */
+export function parseSignalCount(raw, sink) {
+    const context = fixedContext('signalCount', 'a whole number of signals in 1..9999', 'inspect the first 256 bytes in a hex viewer; nothing after them can be located without ' +
+        'this field');
+    const parse = parseEdfInteger(raw);
+    if (parse.ok && parse.value >= 1 && parse.value <= EDF_MAX_SIGNAL_COUNT) {
+        reportLayout(parse, context, sink);
+        return parse.value;
+    }
+    throw fatalError({
+        code: 'SIGNAL_COUNT_INVALID',
+        message: `${context.description} is ${JSON.stringify(raw)}, which is not ${context.expected}. ` +
+            'Every per-signal field address is 256 + ns * blockOffset + i * width and the whole ' +
+            `header is 256 * (ns + 1) bytes, so an unusable ns leaves no byte after the fixed ` +
+            `header locatable. ${context.specReference}. Next: ${context.nextStep}.`,
+        ...contextInit(context, raw),
+        actual: raw,
+    });
+}
+/**
+ * The declared header size at offset 184, checked against the computed `256 * (ns + 1)`.
+ *
+ * The computed value ALWAYS wins, which is what makes this a warning rather than a fatal
+ * numeric field: a value edfcore never uses cannot make it read the wrong bytes. An unreadable
+ * field is reported the same way and returned as `NaN`, so `header.declaredHeaderByteLength`
+ * never claims a size the file did not state.
+ */
+export function checkDeclaredHeaderByteLength(raw, computedHeaderByteLength, sink) {
+    const context = fixedContext('headerByteLength', 'a whole number of bytes equal to 256 * (number of signals + 1)', 'nothing to do — edfcore uses the computed size');
+    const declared = readNumericField(parseEdfInteger(raw), context, sink);
+    if (declared === computedHeaderByteLength)
+        return declared;
+    sink.report({
+        code: 'HEADER_SIZE_MISMATCH',
+        message: `${context.description} is ${JSON.stringify(raw)}, but the header of a file with this ` +
+            `many signals is exactly ${computedHeaderByteLength} bytes (256 * (ns + 1)). ` +
+            `${context.specReference}. Next: the computed size wins, so the first data record is ` +
+            `read at byte ${computedHeaderByteLength}; header.declaredHeaderByteLength keeps what ` +
+            'the file claimed.',
+        ...contextInit(context, raw),
+        expected: String(computedHeaderByteLength),
+        actual: Number.isNaN(declared) ? raw : String(declared),
+    });
+    return declared;
+}
+/**
+ * The record duration at offset 244, in seconds.
+ *
+ * May legitimately be 0 — an EDF+ file whose records carry only annotations does exactly that —
+ * and `ZERO_RECORD_DURATION` says so without refusing the file. A NEGATIVE duration is refused:
+ * it is not a tolerable oddity but a value that would make every record onset, sample time and
+ * sample rate derived from it run backwards. So is a POSITIVE duration that no 100 ns tick count
+ * can express, in either direction — see the comment on that check.
+ */
+export function parseRecordDuration(raw, sink) {
+    const context = fixedContext('recordDuration', 'a number of seconds, written in ASCII digits with "." as the decimal separator, such as ' +
+        '"1", "0.1" or "30"', 'header.raw.recordDuration keeps the bytes as written; every sample time in the file is a ' +
+        'multiple of this value, and edfcore will not assume one second');
+    const seconds = requireNumericField(parseEdfNumber(raw), context, sink);
+    if (seconds < 0) {
+        throw fatalError({
+            code: 'NUMERIC_FIELD_INVALID',
+            message: `${context.description} is ${JSON.stringify(raw)}, i.e. ${seconds} seconds. A data ` +
+                'record cannot last a negative time, and every record onset, sample time and sample ' +
+                `rate derived from it would run backwards. ${context.specReference}. Next: ` +
+                `${context.nextStep}.`,
+            ...contextInit(context, raw),
+            expected: 'a duration of 0 seconds or more',
+            actual: String(seconds),
+        });
+    }
+    // edfcore measures time in exact 100 ns ticks, so a POSITIVE duration that no tick count can
+    // express is not a duration it can honour, and the two failures look nothing alike from the
+    // outside. Too large and `seconds * 10^7` overflows float64 before it can become a bigint, which
+    // surfaced as a bare `RangeError` about BigInt() — an error about a number, thrown at a caller
+    // who passed the right arguments, for a defect that is entirely the file's. Too small and it
+    // rounds to zero ticks while `recordDurationSeconds` keeps claiming a positive length, which
+    // leaves `recordDurationTicks` at 0 next to a non-zero `recordDurationSeconds` and makes every
+    // `sampleRateHz` in the file Infinity. Zero itself stays legal and is reported just below.
+    const ticks = seconds * TICKS_PER_SECOND_FLOAT;
+    if (seconds > 0 && (!Number.isFinite(ticks) || Math.round(ticks) === 0)) {
+        throw fatalError({
+            code: 'NUMERIC_FIELD_INVALID',
+            message: `${context.description} is ${JSON.stringify(raw)}, i.e. ${seconds} seconds, which is ` +
+                (Number.isFinite(ticks)
+                    ? 'shorter than the 100 ns tick edfcore measures time in, so every data record would ' +
+                        'occupy no time at all while the field claims otherwise'
+                    : 'so large that its length in 100 ns ticks is not a number at all') +
+                `. ${context.specReference}. Next: ${context.nextStep}.`,
+            ...contextInit(context, raw),
+            expected: 'a duration of 0 seconds, or of at least 100 ns',
+            actual: String(seconds),
+        });
+    }
+    if (seconds === 0) {
+        sink.report({
+            code: 'ZERO_RECORD_DURATION',
+            message: `${context.description} is ${JSON.stringify(raw)}. Zero is legal — EDF+ uses it for a ` +
+                'recording whose data records carry annotations and nothing else — but it makes every ' +
+                'sample rate undefined, because samplesPerRecord / 0 is not a rate. EDF+ additional ' +
+                'specification 1. Next: signal.sampleRateHz is undefined for every signal in this ' +
+                'file; index samples by signal.samplesPerRecord and never divide by ' +
+                'header.recordDurationSeconds.',
+            ...contextInit(context, raw),
+            expected: 'a positive number of seconds, or 0 for an annotations-only recording',
+            actual: '0',
+            specReference: 'EDF+ additional specification 1 (annotations-only recordings)',
+        });
+    }
+    return seconds;
+}
+/**
+ * The declared record count at offset 236, verbatim.
+ *
+ * `-1` is the sanctioned "the writer never closed the file" value and is returned as `-1`; an
+ * unreadable field is returned as `NaN`. Both mean the same thing to the caller — the count has
+ * to come from the source length instead — and `header/parse.ts` reports which happened, since
+ * only it knows the source length that resolves it.
+ */
+export function parseDeclaredRecordCount(raw, sink) {
+    const context = fixedContext('recordCount', 'a whole number of data records, or -1 when the writer did not know it', 'the count is recovered from the source length instead');
+    return readNumericField(parseEdfInteger(raw), context, sink);
+}
+//# sourceMappingURL=fields.js.map

package/dist/header/fields.js.map

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

package/dist/header/identification.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The two EDF+ identification grammars.
+ *
+ * Layer 2. Sole owner of the subfield structure of the 80-byte local patient identification
+ * (offset 8) and the 80-byte local recording identification (offset 88).
+ *
+ * Three rules run through both:
+ *
+ * - `'X'` means unknown in ANY subfield and becomes `undefined`, never the string `'X'`.
+ * - The raw text is ALWAYS preserved, whatever the grammar says, and subfields beyond the ones
+ *   the spec names go to `extraSubfields` — EDF+ says the field must *start with* its
+ *   subfields, so trailing extras are legal and are not a non-conformance.
+ * - Underscores are exposed verbatim. EDF+ says a space inside a subfield must be replaced by
+ *   another character and suggests an underscore, but it mandates neither the character nor a
+ *   way back: `'Mac_Donald'` and a genuine underscore are indistinguishable, so substituting
+ *   here would corrupt one to display the other. `raw` and the subfields both keep what the
+ *   file wrote.
+ *
+ * Plain EDF puts free text in these fields, which is normal and not a defect. The diagnostic
+ * therefore fires only when the file carries an EDF+/BDF+ marker; `conformant` is set honestly
+ * either way.
+ */
+import type { DiagnosticSink } from '../diagnostics/collector.js';
+import type { EdfPatientId, EdfRecordingId } from '../types.js';
+export interface IdentificationOptions {
+    /**
+     * The reserved field carries an EDF+/BDF+ marker, so the subfield grammar is required rather
+     * than merely conventional. Only then is a deviation worth a diagnostic.
+     */
+    readonly edfPlus: boolean;
+}
+/**
+ * The local patient identification: code, sex, birthdate, name, then anything else the writer
+ * appended.
+ *
+ * `raw` on the result is the text exactly as it was passed in, padding included.
+ */
+export declare function parsePatientId(raw: string, options: IdentificationOptions, sink: DiagnosticSink): EdfPatientId;
+/**
+ * The local recording identification: the literal `Startdate`, the start date, and the
+ * investigation, technician and equipment codes.
+ *
+ * This is the only field in an EDF file that can carry a four-digit year, which is what makes
+ * it the authority `dates.ts` prefers and the only way past 2084.
+ */
+export declare function parseRecordingId(raw: string, options: IdentificationOptions, sink: DiagnosticSink): EdfRecordingId;
+//# sourceMappingURL=identification.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"identification.d.ts","sourceRoot":"","sources":["../../src/header/identification.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,KAAK,EAAmB,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAejF,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAoCD;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,qBAAqB,EAC9B,IAAI,EAAE,cAAc,GACnB,YAAY,CA0Cd;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,qBAAqB,EAC9B,IAAI,EAAE,cAAc,GACnB,cAAc,CA+ChB"}

package/dist/header/identification.js

@@ -0,0 +1,156 @@
+/**
+ * The two EDF+ identification grammars.
+ *
+ * Layer 2. Sole owner of the subfield structure of the 80-byte local patient identification
+ * (offset 8) and the 80-byte local recording identification (offset 88).
+ *
+ * Three rules run through both:
+ *
+ * - `'X'` means unknown in ANY subfield and becomes `undefined`, never the string `'X'`.
+ * - The raw text is ALWAYS preserved, whatever the grammar says, and subfields beyond the ones
+ *   the spec names go to `extraSubfields` — EDF+ says the field must *start with* its
+ *   subfields, so trailing extras are legal and are not a non-conformance.
+ * - Underscores are exposed verbatim. EDF+ says a space inside a subfield must be replaced by
+ *   another character and suggests an underscore, but it mandates neither the character nor a
+ *   way back: `'Mac_Donald'` and a genuine underscore are indistinguishable, so substituting
+ *   here would corrupt one to display the other. `raw` and the subfields both keep what the
+ *   file wrote.
+ *
+ * Plain EDF puts free text in these fields, which is normal and not a defect. The diagnostic
+ * therefore fires only when the file carries an EDF+/BDF+ marker; `conformant` is set honestly
+ * either way.
+ */
+import { trimEdfField } from '../bytes/latin1.js';
+import { HEADER_FIELDS } from '../constants.js';
+import { parseSubfieldDate } from './dates.js';
+/** The EDF+ placeholder for an unknown subfield, in every position. */
+const UNKNOWN_SUBFIELD = 'X';
+const RECORDING_ID_PREFIX = 'Startdate';
+const PATIENT_SUBFIELD_COUNT = 4;
+const RECORDING_SUBFIELD_COUNT = 5;
+const PATIENT_GRAMMAR = 'code sex(F|M) birthdate(dd-MMM-yyyy) name';
+const RECORDING_GRAMMAR = 'Startdate startdate(dd-MMM-yyyy) investigationCode technicianCode equipmentCode';
+/** Subfields are separated by spaces and may not contain one. Runs are tolerated. */
+function splitSubfields(raw) {
+    const text = trimEdfField(raw);
+    if (text.length === 0)
+        return [];
+    return text.split(/\s+/).filter((part) => part.length > 0);
+}
+/** `'X'` is the spec's "unknown", and an absent subfield is unknown too. */
+function subfieldValue(subfields, index) {
+    const value = subfields[index];
+    if (value === undefined || value === UNKNOWN_SUBFIELD)
+        return undefined;
+    return value;
+}
+function parseSex(subfield) {
+    if (subfield === 'F' || subfield === 'M')
+        return subfield;
+    return undefined;
+}
+/**
+ * A subfield date, or `undefined` for `'X'`/absent/unparseable.
+ *
+ * `conformant` is false when the text is present but is not exactly `dd-MMM-yyyy` with an
+ * uppercase English month — the date is still exposed when it can be read at all.
+ */
+function parseIdentificationDate(subfield) {
+    if (subfield === undefined)
+        return { date: undefined, conformant: true };
+    const parsed = parseSubfieldDate(subfield);
+    return { date: parsed.date, conformant: parsed.conformant };
+}
+/**
+ * The local patient identification: code, sex, birthdate, name, then anything else the writer
+ * appended.
+ *
+ * `raw` on the result is the text exactly as it was passed in, padding included.
+ */
+export function parsePatientId(raw, options, sink) {
+    const subfields = splitSubfields(raw);
+    const sexText = subfields[1];
+    const sex = parseSex(sexText);
+    const birth = parseIdentificationDate(subfieldValue(subfields, 2));
+    const sexConformant = sexText === undefined ? false : sex !== undefined || sexText === UNKNOWN_SUBFIELD;
+    const conformant = subfields.length >= PATIENT_SUBFIELD_COUNT && sexConformant && birth.conformant;
+    if (!conformant && options.edfPlus) {
+        const offset = HEADER_FIELDS.patientId.offset;
+        sink.report({
+            code: 'PATIENT_ID_NONCONFORMANT',
+            message: `local patient identification (80 bytes at offset ${offset}) is ` +
+                `${JSON.stringify(trimEdfField(raw))}, which does not follow the EDF+ grammar ` +
+                `"${PATIENT_GRAMMAR}": four space-separated subfields, sex written F or M, ` +
+                'birthdate written dd-MMM-yyyy such as 02-AUG-1951, X for anything unknown, and no ' +
+                `space inside a subfield. Found ${subfields.length} subfield(s). EDF+ additional ` +
+                'specification 3. Next: header.patient.raw keeps the text verbatim and every subfield edfcore ' +
+                'could read is still exposed; the rest are undefined.',
+            field: 'patientId',
+            byteOffset: offset,
+            byteLength: HEADER_FIELDS.patientId.length,
+            raw,
+            expected: PATIENT_GRAMMAR,
+            actual: trimEdfField(raw),
+            specReference: 'EDF+ additional specification 3 (local patient identification)',
+        });
+    }
+    return {
+        raw,
+        conformant,
+        code: subfieldValue(subfields, 0),
+        sex,
+        birthDate: birth.date,
+        name: subfieldValue(subfields, 3),
+        extraSubfields: Object.freeze(subfields.slice(PATIENT_SUBFIELD_COUNT)),
+    };
+}
+/**
+ * The local recording identification: the literal `Startdate`, the start date, and the
+ * investigation, technician and equipment codes.
+ *
+ * This is the only field in an EDF file that can carry a four-digit year, which is what makes
+ * it the authority `dates.ts` prefers and the only way past 2084.
+ */
+export function parseRecordingId(raw, options, sink) {
+    const subfields = splitSubfields(raw);
+    const prefix = subfields[0];
+    const startDate = parseIdentificationDate(subfieldValue(subfields, 1));
+    // Case-insensitive acceptance, non-conformance noted: the spec spells it 'Startdate'.
+    const prefixPresent = prefix !== undefined && prefix.toUpperCase() === RECORDING_ID_PREFIX.toUpperCase();
+    const prefixConformant = prefix === RECORDING_ID_PREFIX;
+    const conformant = subfields.length >= RECORDING_SUBFIELD_COUNT && prefixConformant && startDate.conformant;
+    if (!conformant && options.edfPlus) {
+        const offset = HEADER_FIELDS.recordingId.offset;
+        sink.report({
+            code: 'RECORDING_ID_NONCONFORMANT',
+            message: `local recording identification (80 bytes at offset ${offset}) is ` +
+                `${JSON.stringify(trimEdfField(raw))}, which does not follow the EDF+ grammar ` +
+                `"${RECORDING_GRAMMAR}": five space-separated subfields starting with the literal ` +
+                'text Startdate, then the start date written dd-MMM-yyyy such as 02-AUG-1951, then ' +
+                'the investigation, technician and equipment codes, with X for anything unknown. ' +
+                `Found ${subfields.length} subfield(s). EDF+ additional specification 4. Next: ` +
+                'header.recording.raw keeps the text verbatim; a Startdate that could not be read ' +
+                'leaves startTime.recordingIdDate undefined, so the two-digit header year is all ' +
+                'that remains.',
+            field: 'recordingId',
+            byteOffset: offset,
+            byteLength: HEADER_FIELDS.recordingId.length,
+            raw,
+            expected: RECORDING_GRAMMAR,
+            actual: trimEdfField(raw),
+            specReference: 'EDF+ additional specification 4 (local recording identification)',
+        });
+    }
+    return {
+        raw,
+        conformant,
+        // A date sitting behind a missing or misspelt 'Startdate' keyword is not a Startdate; the
+        // subfield is only meaningful in the position the grammar gives it.
+        startDate: prefixPresent ? startDate.date : undefined,
+        investigationCode: subfieldValue(subfields, 2),
+        technicianCode: subfieldValue(subfields, 3),
+        equipmentCode: subfieldValue(subfields, 4),
+        extraSubfields: Object.freeze(subfields.slice(RECORDING_SUBFIELD_COUNT)),
+    };
+}
+//# sourceMappingURL=identification.js.map

package/dist/header/identification.js.map

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

package/dist/header/lookup.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Finding a signal by name.
+ *
+ * Layer 2. Two functions and a predicate, and the reason they exist rather than being left to
+ * the caller: deleting name lookup does not delete `signals.find(s => s.label === label)`, which
+ * silently returns the first of a duplicate pair. CHB-MIT ships `'T8-P8'` twice, and picking one
+ * of them by accident is how the wrong channel ends up in a paper.
+ *
+ * Matching is exact on the TRIMMED label and is case-sensitive. Nothing else is normalised: EDF
+ * labels are electrode names, `'Fp1'` and `'FP1'` are written by different systems, and edfcore
+ * has no montage vocabulary to decide they are the same thing.
+ */
+import type { EdfHeader, EdfSignal } from '../types.js';
+/**
+ * True for the two reserved annotation labels, matched on the trimmed text and case-sensitively.
+ *
+ * Both are accepted for either family: the label identifies the channel's ROLE, and a BDF+ file
+ * written by an EDF+ library carries `'EDF Annotations'` — refusing to recognise it there would
+ * expose a text channel as if it held samples.
+ */
+export declare function isAnnotationLabel(label: string): boolean;
+/** Every signal with this label, in signal order. Empty when none matches. */
+export declare function findSignals(header: EdfHeader, label: string): readonly EdfSignal[];
+/**
+ * One signal, by index or by label.
+ *
+ * A numeric selector indexes `header.signals` directly. A label that matches nothing throws
+ * `EdfChannelNotFoundError` carrying every available label; a label that matches more than one
+ * signal throws `EdfAmbiguousChannelError` carrying the indices, because there is no answer
+ * edfcore could return that would not be a guess.
+ */
+export declare function getSignal(header: EdfHeader, selector: number | string): EdfSignal;
+//# sourceMappingURL=lookup.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lookup.d.ts","sourceRoot":"","sources":["../../src/header/lookup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAGxD;AAED,8EAA8E;AAC9E,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,SAAS,EAAE,CAGlF;AAMD;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAgCjF"}