@clementine-solutions/jane-io 1.0.0 → 1.0.1

package/dist/core/pipeline/boundary.d.ts

@@ -0,0 +1,36 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Pipeline | Boundary
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Aggregates field results and applies boundary‑level policy
+ *                  to produce a final decision.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { BoundaryContext, BoundaryDecision, BoundaryInput, BoundaryResult } from '../shapes';
+import type { BoundaryRule } from '../shapes/boundary';
+/**
+ * Holds all registered boundary‑level rules.
+ *
+ * Provides a central lookup for rule names used in boundary policies,
+ * allowing contributors to extend or customize boundary evaluation
+ * without modifying the core engine.
+ */
+export declare const boundaryRuleRegistry: Record<string, BoundaryRule>;
+/**
+ * Executes boundary evaluation across all field results.
+ *
+ * Aggregates issues and events from each pipeline result, applies
+ * boundary‑level rules, shapes values and metadata according to policy,
+ * and produces the final boundary result used for acceptance decisions.
+ */
+export declare function boundaryRunner(input: BoundaryInput): Promise<BoundaryResult>;
+/**
+ * Applies boundary decision logic to the aggregated context.
+ *
+ * Shapes events and issues through ignore, override, escalate, and
+ * visibility rules, evaluates acceptance modes, and optionally invokes
+ * a reducer to refine or override the final decision.
+ */
+export declare function decideBoundary(context: BoundaryContext): Promise<BoundaryDecision>;

package/dist/core/pipeline/contain.d.ts

@@ -0,0 +1,122 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Pipeline | Contain
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Enforces structural limits and produces a safe, cycle‑free
+ *                  representation of input.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ContainmentContext, ContainmentOptions, FieldPath, InternalJsonValue, Policy } from '../shapes';
+/**
+ * Sentinel markers used when a value cannot be safely contained.
+ *
+ * These appear when encountering cycles, excessive depth or size, unsafe
+ * structures, or disallowed types such as functions, symbols, and proxies.
+ */
+export declare const ContainmentSentinel: {
+    readonly Circular: "[Circular]";
+    readonly TooDeep: "[TooDeep]";
+    readonly TooLarge: "[TooLarge]";
+    readonly Proxy: "[Proxy]";
+    readonly Getter: "[Getter]";
+    readonly Function: "[Function]";
+    readonly Symbol: "[Symbol]";
+    readonly BigInt: "[BigInt]";
+};
+export type ContainmentSentinel = (typeof ContainmentSentinel)[keyof typeof ContainmentSentinel];
+/**
+ * Contains an array by applying depth and length limits.
+ *
+ * Recursively contains each element, records the container for cycle
+ * detection, and appends a TooLarge sentinel when the array exceeds
+ * the configured maximum length.
+ */
+export declare function containArray(value: readonly unknown[], path: FieldPath, context: ContainmentContext, depth: number): unknown;
+/**
+ * Represents a bigint value in a safe, JSON‑compatible form.
+ *
+ * Used only when bigint is explicitly allowed by policy; otherwise
+ * containment falls back to the BigInt sentinel.
+ */
+export declare function containBigInt(value: bigint): {
+    kind: "bigint";
+    asString: string;
+};
+/**
+ * Contains a plain object by enforcing key limits and safe property access.
+ *
+ * Skips prototype‑pollution vectors, replaces getters/setters with a
+ * Getter sentinel, and recursively contains each value. Adds a TooLarge
+ * sentinel entry when the object exceeds the configured key limit.
+ */
+export declare function containObject(value: Record<string, unknown>, path: FieldPath, ctx: ContainmentContext, depth: number): unknown;
+/**
+ * Recursively contains any value into a safe, JSON‑like structure.
+ *
+ * Enforces depth limits, detects cycles, handles primitives directly,
+ * applies policy‑controlled exceptions (e.g., bigint), and replaces
+ * unsafe or non‑plain objects with appropriate sentinels.
+ */
+export declare function containRecursive(value: unknown, path: FieldPath, context: ContainmentContext, depth: number): unknown;
+/**
+ * Entry point for containment.
+ *
+ * Creates a fresh containment context and produces a safe representation
+ * of the input value. Falls back to the Proxy sentinel if containment
+ * fails unexpectedly.
+ */
+export declare function containValue(value: unknown, path?: FieldPath, options?: ContainmentOptions, policy?: Policy): unknown;
+/**
+ * Constructs a containment context with structural limits, policy,
+ * and a fresh cycle‑detection map.
+ */
+export declare function createContainmentContext(options: ContainmentOptions, policy: Policy): ContainmentContext;
+/**
+ * Produces a deep, acyclic clone of an internal JSON value.
+ *
+ * Preserves primitives, arrays, plain objects, and Date instances while
+ * tracking references to avoid infinite recursion. Used to safely copy
+ * containment output without re‑running containment.
+ */
+export declare function deepClone(input: InternalJsonValue, seen?: WeakMap<object, InternalJsonValue>): InternalJsonValue | undefined;
+/**
+ * Default structural limits applied during containment.
+ *
+ * These bounds prevent excessive recursion and traversal by capping depth,
+ * array length, and object key count.
+ */
+export declare const defaultContainmentOptions: ContainmentOptions;
+/**
+ * Determines whether a value is a containment sentinel.
+ *
+ * Sentinels represent structural hazards or disallowed types encountered
+ * during containment and are encoded as well‑known string markers.
+ */
+export declare function isSentinel(value: unknown): value is ContainmentSentinel;
+/**
+ * Safely retrieves an object's own enumerable keys.
+ *
+ * Returns an empty array if key enumeration fails, protecting containment
+ * from objects with hostile or unusual prototypes.
+ */
+export declare function safeObjectKeys(value: Record<string, unknown>): string[];
+/**
+ * Safely retrieves a property descriptor.
+ *
+ * Returns undefined if descriptor access throws, allowing containment to
+ * gracefully handle objects with unsafe or non‑standard behavior.
+ */
+export declare function safePropertyDescriptor(value: Record<string, unknown>, key: string): PropertyDescriptor | undefined;
+/**
+ * Maps a containment sentinel to its corresponding event.
+ *
+ * Used to surface structural hazards—such as cycles, excessive depth,
+ * unsafe objects, or disallowed types—as typed events during scanning
+ * and policy evaluation.
+ */
+export declare function sentinelEvent(kind: ContainmentSentinel): {
+    code: string;
+    severity: string;
+};

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

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Pipeline | Barrel File
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+export { boundaryRunner, decideBoundary } from './boundary';
+export { ContainmentSentinel, containArray, containBigInt, containObject, containRecursive, containValue, createContainmentContext, deepClone, defaultContainmentOptions, isSentinel, safeObjectKeys, safePropertyDescriptor, sentinelEvent, } from './contain';
+export { normalizationEvent, normalizationRunner, selectNormalizationRules } from './normalize';
+export { isFluentParser, isParseFactory, parseEvent, parseRunner } from './parse';
+export { createPipeline, pipelineRunner } from './pipeline';
+export { detectStructuralType, measureDepth, scanEvent, scanRunner, selectScanRules } from './scan';
+export { isFluentValidator, isValidationFactory, validationEvent, validationRunner, } from './validate';

package/dist/core/pipeline/normalize.d.ts

@@ -0,0 +1,34 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Pipeline | Normalize
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Applies mode‑aware transformations to the safe value
+ *                  before validation.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { EventCode, EventKind, FieldPath, JaneEvent, NormalizationRule, NormalizationStageContext, NormalizationStageOutput } from '../shapes';
+/**
+ * Creates a normalization‑stage event.
+ *
+ * Wraps createEvent with the 'normalize' stage tag, producing structured
+ * messages emitted during value‑shaping operations.
+ */
+export declare const normalizationEvent: (kind: EventKind, code: EventCode, path: FieldPath, message?: string, userMessage?: string, meta?: Record<string, unknown>) => JaneEvent;
+/**
+ * Executes the normalization stage.
+ *
+ * Applies each normalization rule in sequence, collects emitted events,
+ * and updates the working value according to the active mode. Lossy
+ * transformations are skipped in moderate mode, with a corresponding
+ * warning event recorded.
+ */
+export declare const normalizationRunner: (input: NormalizationStageContext) => Promise<NormalizationStageOutput>;
+/**
+ * Selects normalization rules based on the structural type of the value.
+ *
+ * Uses detectStructuralType to choose the appropriate rule set from the
+ * registry, ensuring predictable and type‑specific normalization behavior.
+ */
+export declare function selectNormalizationRules(value: unknown): readonly NormalizationRule[];

package/dist/core/pipeline/parse.d.ts

@@ -0,0 +1,40 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Pipeline | Parse
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Converts raw input into typed values using registered parse
+ *                  rules.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { EventCode, EventKind, FieldPath, JaneEvent, ParserFactory, ParserFluentRule, ParseRule, ParseStageContext, ParseStageOutput } from '../shapes';
+/**
+ * Creates a parse‑stage event.
+ *
+ * Produces a structured event tagged with the 'parse' phase, used to
+ * surface observations or errors encountered while interpreting input.
+ */
+export declare function parseEvent(kind: EventKind, code: EventCode, message: string, path: FieldPath, userMessage?: string, metadata?: Record<string, unknown>): JaneEvent;
+/**
+ * Determines whether a fluent parser entry is a factory.
+ *
+ * Factories accept arbitrary parameters and return a ParseRule, while
+ * fluent parsers expose a fixed two‑argument rule signature.
+ */
+export declare function isParseFactory(fn: ParserFluentRule | ParserFactory): fn is ParserFactory;
+/**
+ * Determines whether a fluent parser entry is a direct parse rule.
+ *
+ * Fluent rules always accept exactly two parameters—value and path—
+ * distinguishing them from parameterized factories.
+ */
+export declare function isFluentParser(fn: ParserFluentRule): fn is ParseRule;
+/**
+ * Executes the parse stage.
+ *
+ * Applies each parse rule in sequence, collects emitted events, and
+ * updates the working value as rules propose transformations. Errors
+ * thrown by rules are captured as fatal parse events.
+ */
+export declare function parseRunner(ctx: ParseStageContext): Promise<ParseStageOutput>;

package/dist/core/pipeline/pipeline.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Pipeline | Pipeline
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Orchestrates all pipeline stages into a unified execution
+ *                  lifecycle.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { FieldPath, ParseRule, PipelineBuilder, PipelineInput, PipelineResult, Policy, PolicyOverrides, ScanRule, ValidationRule } from '../shapes';
+/**
+ * Runs the configured pipeline through all enabled stages and assembles the
+ * complete result. Coordinates scan, normalize, parse, validate, analysis,
+ * and policy decision into a single execution flow.
+ */
+export declare function pipelineRunner<T>(input: PipelineInput): Promise<PipelineResult<T>>;
+/**
+ * Creates a new pipeline builder rooted at the given raw value and path.
+ * Establishes the initial rule sets, policy state, and override surface,
+ * returning a fluent interface for assembling and running a complete pipeline.
+ */
+export declare function createPipeline(raw: unknown, path?: FieldPath, scanRules?: readonly ScanRule[], parseRules?: readonly ParseRule[], validationRules?: readonly ValidationRule[], policy?: Policy, overrides?: PolicyOverrides): PipelineBuilder;

package/dist/core/pipeline/scan.d.ts

@@ -0,0 +1,46 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Pipeline | Scan
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Inspects the contained value and emits structural
+ *                  observations for later stages.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { EventCode, EventKind, FieldPath, JaneEvent, ScanRule, ScanRunner, StructuralType } from '../shapes';
+/**
+ * Classifies a raw value into one of Jane’s structural types.
+ *
+ * Used by the scanner to select appropriate rules without relying on
+ * user‑defined schemas or runtime shape assumptions.
+ */
+export declare function detectStructuralType(input: unknown): StructuralType;
+/**
+ * Computes the maximum nesting depth of a JSON‑like structure.
+ *
+ * Traverses objects recursively and returns the deepest level encountered,
+ * ignoring non‑object values and null.
+ */
+export declare function measureDepth(value: unknown, current?: number): number;
+/**
+ * Creates a scan‑stage event.
+ *
+ * Wraps createEvent with the 'scan' stage tag, producing structured
+ * observations emitted during the scan pipeline phase.
+ */
+export declare const scanEvent: (kind: EventKind, code: EventCode, path: FieldPath, message: string, userMessage?: string, meta?: Record<string, unknown>) => JaneEvent;
+/**
+ * Executes the scan stage for a single value.
+ *
+ * Produces a safe contained value, applies all scan rules, collects
+ * emitted events, and performs a structural walk to ensure full coverage.
+ */
+export declare const scanRunner: ScanRunner;
+/**
+ * Selects scan rules based on the structural type of the raw value.
+ *
+ * Returns the union of universal rules and the rules specific to the
+ * detected type, ensuring consistent and predictable scan behavior.
+ */
+export declare function selectScanRules(raw: unknown): readonly ScanRule[];

package/dist/core/pipeline/validate.d.ts

@@ -0,0 +1,40 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Pipeline | Validate
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Evaluates the normalized value and emits rule‑driven
+ *                  correctness events.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { EventCode, EventKind, FieldPath, JaneEvent, ValidatorFactory, ValidationStageContext, ValidationStageOutput, ValidatorFluentRule, ValidationRule } from '../shapes';
+/**
+ * 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 declare function isValidationFactory(fn: ValidatorFluentRule): fn is ValidatorFactory;
+/**
+ * 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 declare function isFluentValidator(fn: ValidatorFluentRule): fn is ValidationRule;
+/**
+ * Creates a validation‑stage event.
+ *
+ * Wraps createEvent with the 'validate' phase tag, producing correctness‑
+ * focused messages emitted during rule evaluation.
+ */
+export declare const validationEvent: (kind: EventKind, code: EventCode, path: FieldPath, message?: string, userMessage?: string, meta?: Record<string, unknown>) => JaneEvent;
+/**
+ * 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 declare const validationRunner: (input: ValidationStageContext) => Promise<ValidationStageOutput>;

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/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-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-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/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-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/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-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-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/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';

package/dist/core/scanners/number/number-is-infinite.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Number Is Infinite
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Flags numeric values that resolve to Infinity, surfacing
+ *                  calculation errors or malformed inputs before they propagate.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ScanRule } from '../../shapes';
+/**
+ * Flags numeric values that are infinite rather than finite.
+ *
+ * Infinite values often indicate upstream calculation errors, division
+ * anomalies, or malformed input. This rule surfaces them early so downstream
+ * logic never assumes a safe, bounded number.
+ */
+export declare const numberIsInfinite: ScanRule;

package/dist/core/scanners/number/number-is-nan.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Number Is NaN
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Detects numeric values that evaluate to NaN, ensuring failed
+ *                  arithmetic or parsing does not silently pass through scanning.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ScanRule } from '../../shapes';
+/**
+ * Detects numeric values that resolve to NaN.
+ *
+ * NaN commonly arises from failed arithmetic, invalid parsing, or unexpected
+ * coercions. This rule ensures such values are treated as structurally unsafe
+ * rather than silently propagating through the scan pipeline.
+ */
+export declare const numberIsNaN: ScanRule;

package/dist/core/scanners/number/number-is-too-large.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Number Is Too Large
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Warns when a number exceeds a conservative magnitude limit,
+ *                  highlighting values that may indicate corrupted or adversarial
+ *                  input.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ScanRule } from '../../shapes';
+/**
+ * Warns when a numeric value exceeds a conservative magnitude threshold.
+ *
+ * Extremely large numbers can signal corrupted data, unrealistic inputs, or
+ * adversarial payloads. This rule highlights values that may cause overflow,
+ * precision loss, or performance issues in downstream systems.
+ */
+export declare const numberIsTooLarge: ScanRule;