@clementine-solutions/jane-io 1.0.0 → 1.0.2

package/dist/core/pipeline/validate.js

@@ -0,0 +1,74 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Pipeline | Validate
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Evaluates the normalized value and emits rule‑driven
+ *                  correctness events.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { createEvent } from '../common';
+import { rootPath } from '../field-path';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Is Validation Factory                                                     *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Determines whether a fluent validator entry is a factory.
+ *
+ * Factories accept arbitrary parameters and return a ValidationRule,
+ * distinguishing them from fixed‑signature fluent validators.
+ */
+export function isValidationFactory(fn) {
+    // A factory returns a ValidationRule when called with ANY args
+    return typeof fn === 'function' && fn.length !== 2;
+}
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Is Fluent Validator                                                       *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Determines whether a fluent validator entry is a direct validation rule.
+ *
+ * Fluent validators always expose a two‑argument signature—value and path—
+ * making them distinguishable from parameterized factories.
+ */
+export function isFluentValidator(fn) {
+    return typeof fn === 'function' && fn.length === 2;
+}
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Validation Event                                                          *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Creates a validation‑stage event.
+ *
+ * Wraps createEvent with the 'validate' phase tag, producing correctness‑
+ * focused messages emitted during rule evaluation.
+ */
+export const validationEvent = (kind, code, path, message, userMessage, meta) => createEvent('validate', kind, code, path, message, userMessage, meta);
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Validation Runner                                                         *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Executes the validation stage.
+ *
+ * Applies each validation rule to the value, collects all emitted events,
+ * and records fatal errors when rules throw. Produces the complete set of
+ * correctness observations for the stage.
+ */
+export const validationRunner = async (input) => {
+    const { value, path: inputPath, rules } = input;
+    const path = inputPath ?? rootPath();
+    const events = [];
+    for (const rule of rules) {
+        try {
+            const emitted = await rule(value, path);
+            if (emitted && emitted.length > 0) {
+                events.push(...emitted);
+            }
+        }
+        catch (err) {
+            events.push(createEvent('validate', 'fatal', 'error.while.validating', path, String(err)));
+        }
+    }
+    return { events };
+};

package/dist/core/scanners/any/scan-for-sentinels.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Scan For Sentinels
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Detects sentinel markers in raw input and emits structural‑
+ *                  hazard events.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ScanRule } from '../../shapes';
+/**
+ * Detects containment sentinels produced during safe‑clone operations.
+ *
+ * Flags any sentinel string as a fatal structural hazard, emitting a
+ * scan event that identifies the hazard code and the original sentinel
+ * value for downstream analysis and policy decisions.
+ */
+export declare const scanForSentinels: ScanRule;

package/dist/core/scanners/any/scan-for-sentinels.js

@@ -0,0 +1,35 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Scan For Sentinels
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Detects sentinel markers in raw input and emits structural‑
+ *                  hazard events.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Internal Modules                                                          *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+import { isSentinel, sentinelEvent } from '../../../core/pipeline';
+import { scanEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Detects containment sentinels produced during safe‑clone operations.
+ *
+ * Flags any sentinel string as a fatal structural hazard, emitting a
+ * scan event that identifies the hazard code and the original sentinel
+ * value for downstream analysis and policy decisions.
+ */
+export const scanForSentinels = (raw, path) => {
+    if (typeof raw !== 'string')
+        return [];
+    if (!isSentinel(raw))
+        return [];
+    const meta = sentinelEvent(raw);
+    return [
+        scanEvent('fatal', 'value.was.contained', path, `Structural hazard detected: ${meta.code}.`, 'A structural hazard was detected in the input.', { sentinel: raw, hazard: meta.code }),
+    ];
+};

package/dist/core/scanners/array/array-is-deep.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Array Is Deep
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Detects arrays nested beyond a safe structural depth and
+ *                  emits a warning event.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ScanRule } from '../../shapes';
+/**
+ * Warns when an array is nested beyond a safe structural depth.
+ *
+ * Walks down the first element chain to estimate nesting. If the depth
+ * exceeds the conservative threshold, emits a warning describing the
+ * observed and allowed depth.
+ */
+export declare const arrayIsDeep: ScanRule;

package/dist/core/scanners/array/array-is-deep.js

@@ -0,0 +1,38 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Array Is Deep
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Detects arrays nested beyond a safe structural depth and
+ *                  emits a warning event.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { scanEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Warns when an array is nested beyond a safe structural depth.
+ *
+ * Walks down the first element chain to estimate nesting. If the depth
+ * exceeds the conservative threshold, emits a warning describing the
+ * observed and allowed depth.
+ */
+export const arrayIsDeep = (raw, path) => {
+    if (!Array.isArray(raw))
+        return [];
+    const maxDepth = 20;
+    let depth = 0;
+    let current = raw;
+    while (Array.isArray(current)) {
+        depth++;
+        if (depth > maxDepth) {
+            return [
+                scanEvent('warn', 'array.is.deep', path, `Array nesting depth exceeds safe threshold ${maxDepth}.`, 'This list is nested too deeply.', { depth, maxDepth }),
+            ];
+        }
+        current = current[0];
+    }
+    return [];
+};

package/dist/core/scanners/array/array-is-heterogenous.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Array Is Heterogeneous
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Warns when an array contains mixed structural types,
+ *                  indicating inconsistent data shape.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ScanRule } from '../../shapes';
+/**
+ * Flags arrays whose length exceeds a conservative safety threshold.
+ *
+ * Emits a warning when the list is unusually large, helping prevent
+ * excessive memory usage or pathological input shapes during scanning.
+ */
+export declare const arrayIsHeterogeneous: ScanRule;

package/dist/core/scanners/array/array-is-heterogenous.js

@@ -0,0 +1,39 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Array Is Heterogeneous
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Warns when an array contains mixed structural types,
+ *                  indicating inconsistent data shape.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Internal Modules                                                          *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+import { detectStructuralType } from '../../../core/pipeline';
+import { scanEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Flags arrays whose length exceeds a conservative safety threshold.
+ *
+ * Emits a warning when the list is unusually large, helping prevent
+ * excessive memory usage or pathological input shapes during scanning.
+ */
+export const arrayIsHeterogeneous = (raw, path) => {
+    if (!Array.isArray(raw))
+        return [];
+    if (raw.length < 2)
+        return [];
+    const firstType = detectStructuralType(raw[0]);
+    for (let i = 1; i < raw.length; i++) {
+        if (detectStructuralType(raw[i]) !== firstType) {
+            return [
+                scanEvent('warn', 'array.is.heterogeneous', path, 'Array contains mixed element types.', 'This list contains different kinds of values.', { firstType, mixedType: detectStructuralType(raw[i]) }),
+            ];
+        }
+    }
+    return [];
+};

package/dist/core/scanners/array/array-is-large.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Array Is Large
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Flags arrays whose length exceeds a conservative safety
+ *                  threshold.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ScanRule } from '../../shapes';
+/**
+ * Detects containment sentinels produced during safe‑clone operations.
+ *
+ * Flags any sentinel string as a fatal structural hazard, emitting a
+ * scan event that identifies the hazard code and the original sentinel
+ * value for downstream analysis and policy decisions.
+ */
+export declare const arrayIsLarge: ScanRule;

package/dist/core/scanners/array/array-is-large.js

@@ -0,0 +1,32 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Array Is Large
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Flags arrays whose length exceeds a conservative safety
+ *                  threshold.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { scanEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Detects containment sentinels produced during safe‑clone operations.
+ *
+ * Flags any sentinel string as a fatal structural hazard, emitting a
+ * scan event that identifies the hazard code and the original sentinel
+ * value for downstream analysis and policy decisions.
+ */
+export const arrayIsLarge = (raw, path) => {
+    if (!Array.isArray(raw))
+        return [];
+    const max = 10_000;
+    if (raw.length > max) {
+        return [
+            scanEvent('warn', 'array.is.large', path, `Array length ${raw.length} exceeds safe threshold ${max}.`, 'This list is very large.', { length: raw.length, max }),
+        ];
+    }
+    return [];
+};

package/dist/core/scanners/bigint/bigint-is-large.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Bigint Is Large
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Flags BigInt values that fall outside JavaScript’s safe
+ *                  integer range, surfacing numbers that cannot be reliably
+ *                  represented or compared using standard numeric APIs.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ScanRule } from '../../shapes';
+/**
+ * Flags `BigInt` values whose bit‑length exceeds a safe structural boundary.
+ *
+ * Extremely large integers can stress memory, break downstream serializers,
+ * and indicate adversarial or malformed input. This rule surfaces oversized
+ * values early so validators and policy layers can decide how to handle them.
+ */
+export declare const bigintIsLarge: ScanRule;

package/dist/core/scanners/bigint/bigint-is-large.js

@@ -0,0 +1,34 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Bigint Is Large
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Flags BigInt values that fall outside JavaScript’s safe
+ *                  integer range, surfacing numbers that cannot be reliably
+ *                  represented or compared using standard numeric APIs.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { scanEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Flags `BigInt` values whose bit‑length exceeds a safe structural boundary.
+ *
+ * Extremely large integers can stress memory, break downstream serializers,
+ * and indicate adversarial or malformed input. This rule surfaces oversized
+ * values early so validators and policy layers can decide how to handle them.
+ */
+export const bigintIsLarge = (raw, path) => {
+    if (typeof raw !== 'bigint')
+        return [];
+    const maxBits = 2048;
+    const bitLength = raw === 0n ? 1 : raw.toString(2).length;
+    if (bitLength > maxBits) {
+        return [
+            scanEvent('warn', 'bigint.is.large', path, `BigInt exceeds safe bit-length threshold ${maxBits} bits.`, 'This number is too large to safely handle.', { bitLength, maxBits }),
+        ];
+    }
+    return [];
+};

package/dist/core/scanners/bigint/bigint-not-safe.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Bigint Not Safe
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Detects BigInt values whose bit-length exceeds a safe
+ *                  structural threshold, highlighting oversized or adversarial
+ *                  integers before deeper validation occurs.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ScanRule } from '../../shapes';
+/**
+ * Flags `BigInt` values that fall outside JavaScript’s safe integer range.
+ *
+ * While `BigInt` itself is unbounded, many systems assume values remain within
+ * the safe `number` range for interoperability. This rule highlights integers
+ * that cannot be safely represented or compared using standard numeric APIs.
+ */
+export declare const bigintNotSafe: ScanRule;

package/dist/core/scanners/bigint/bigint-not-safe.js

@@ -0,0 +1,34 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Bigint Not Safe
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Detects BigInt values whose bit-length exceeds a safe
+ *                  structural threshold, highlighting oversized or adversarial
+ *                  integers before deeper validation occurs.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { scanEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Flags `BigInt` values that fall outside JavaScript’s safe integer range.
+ *
+ * While `BigInt` itself is unbounded, many systems assume values remain within
+ * the safe `number` range for interoperability. This rule highlights integers
+ * that cannot be safely represented or compared using standard numeric APIs.
+ */
+export const bigintNotSafe = (raw, path) => {
+    if (typeof raw !== 'bigint')
+        return [];
+    const maxSafe = BigInt(Number.MAX_SAFE_INTEGER);
+    const minSafe = BigInt(Number.MIN_SAFE_INTEGER);
+    if (raw > maxSafe || raw < minSafe) {
+        return [
+            scanEvent('warn', 'bigint.not.safe', path, 'BigInt exceeds JavaScript safe integer range.', 'This number is outside the safe range.', { value: raw.toString(), maxSafe, minSafe }),
+        ];
+    }
+    return [];
+};

package/dist/core/scanners/date/date-is-before-epoch.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Date Is Before Epoch
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Flags Date values that occur before the Unix epoch,
+ *                  surfacing malformed or legacy timestamps early in scanning.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ScanRule } from '../../shapes';
+/**
+ * Flags Date values that occur before the Unix epoch (1970‑01‑01).
+ *
+ * Dates earlier than the epoch often indicate malformed input, legacy
+ * serialization issues, or unexpected coercions. This rule surfaces those
+ * anomalies early so downstream validators can respond appropriately.
+ */
+export declare const dateIsBeforeEpoch: ScanRule;

package/dist/core/scanners/date/date-is-before-epoch.js

@@ -0,0 +1,32 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Date Is Before Epoch
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Flags Date values that occur before the Unix epoch,
+ *                  surfacing malformed or legacy timestamps early in scanning.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { scanEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Flags Date values that occur before the Unix epoch (1970‑01‑01).
+ *
+ * Dates earlier than the epoch often indicate malformed input, legacy
+ * serialization issues, or unexpected coercions. This rule surfaces those
+ * anomalies early so downstream validators can respond appropriately.
+ */
+export const dateIsBeforeEpoch = (raw, path) => {
+    if (!(raw instanceof Date))
+        return [];
+    const epoch = 0;
+    if (raw.getTime() < epoch) {
+        return [
+            scanEvent('warn', 'date.is.before-epoch', path, 'Date occurs before Unix epoch (1970-01-01).', 'This date is earlier than 1970.', { timestamp: raw.getTime(), epoch }),
+        ];
+    }
+    return [];
+};

package/dist/core/scanners/date/date-is-far-future.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Date Is Far Future
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Detects Date values that fall far beyond a safe future
+ *                  boundary, highlighting unrealistic or adversarial timestamps.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ScanRule } from '../../shapes';
+/**
+ * Detects Date values that fall far beyond a conservative future boundary.
+ *
+ * Extremely future‑dated timestamps can signal corrupted data, unrealistic
+ * scheduling values, or adversarial input. This rule highlights such values
+ * before they propagate into business logic or policy layers.
+ */
+export declare const dateIsFarFuture: ScanRule;

package/dist/core/scanners/date/date-is-far-future.js

@@ -0,0 +1,32 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Date Is Far Future
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Detects Date values that fall far beyond a safe future
+ *                  boundary, highlighting unrealistic or adversarial timestamps.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { scanEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Detects Date values that fall far beyond a conservative future boundary.
+ *
+ * Extremely future‑dated timestamps can signal corrupted data, unrealistic
+ * scheduling values, or adversarial input. This rule highlights such values
+ * before they propagate into business logic or policy layers.
+ */
+export const dateIsFarFuture = (raw, path) => {
+    if (!(raw instanceof Date))
+        return [];
+    const max = new Date('2100-01-01T00:00:00.000Z').getTime();
+    if (raw.getTime() > max) {
+        return [
+            scanEvent('warn', 'date.is.far-future', path, 'Date occurs far in the future beyond safe bounds.', 'This date is far in the future.', { timestamp: raw.getTime(), max }),
+        ];
+    }
+    return [];
+};

package/dist/core/scanners/date/date-is-invalid.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Date Is Invalid
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Warns when a Date instance resolves to an invalid timestamp,
+ *                  ensuring parsing failures are surfaced explicitly.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ScanRule } from '../../shapes';
+/**
+ * Warns when a Date instance resolves to an invalid (NaN) timestamp.
+ *
+ * Invalid Date objects commonly arise from parsing failures or unexpected
+ * transformations. This rule ensures they are surfaced explicitly rather than
+ * silently passing through the scan pipeline.
+ */
+export declare const dateIsInvalid: ScanRule;

package/dist/core/scanners/date/date-is-invalid.js

@@ -0,0 +1,31 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Date Is Invalid
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Warns when a Date instance resolves to an invalid timestamp,
+ *                  ensuring parsing failures are surfaced explicitly.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { scanEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Warns when a Date instance resolves to an invalid (NaN) timestamp.
+ *
+ * Invalid Date objects commonly arise from parsing failures or unexpected
+ * transformations. This rule ensures they are surfaced explicitly rather than
+ * silently passing through the scan pipeline.
+ */
+export const dateIsInvalid = (raw, path) => {
+    if (!(raw instanceof Date))
+        return [];
+    if (Number.isNaN(raw.getTime())) {
+        return [
+            scanEvent('warn', 'date.is.invalid', path, 'Date value is invalid (NaN timestamp).', 'This date is not valid.', { value: raw }),
+        ];
+    }
+    return [];
+};

package/dist/core/scanners/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * ----------------------------------------------------------------------------
+ *  Scanners | Barrel File
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Re‑exports all scanner modules, providing a single,
+ *                  consolidated entry point for the scanning subsystem.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+export { scanForSentinels } from './any/scan-for-sentinels';
+export { arrayIsDeep } from './array/array-is-deep';
+export { arrayIsHeterogeneous } from './array/array-is-heterogenous';
+export { arrayIsLarge } from './array/array-is-large';
+export { bigintIsLarge } from './bigint/bigint-is-large';
+export { bigintNotSafe } from './bigint/bigint-not-safe';
+export { dateIsBeforeEpoch } from './date/date-is-before-epoch';
+export { dateIsFarFuture } from './date/date-is-far-future';
+export { dateIsInvalid } from './date/date-is-invalid';
+export { numberIsInfinite } from './number/number-is-infinite';
+export { numberIsNaN } from './number/number-is-nan';
+export { numberIsTooLarge } from './number/number-is-too-large';
+export { numberIsUnsafeInteger } from './number/number-is-unsafe-integer';
+export { objectHasCircularReferences } from './object/object-has-circular-references';
+export { objectHasManyKeys } from './object/object-has-many-keys';
+export { objectIsDeep } from './object/object-is-deep';
+export { stringHasUnsafeUnicode } from './string/string-has-unsafe-unicode';
+export { stringHasWhitespaceEdges } from './string/string-has-whitespace-edges';
+export { stringIsLong } from './string/string-is-long';
+export { unknownNotScannable } from './unknown/unknown-not-scannable';
+export { scanRuleRegistry } from './scanner-registry';