@clementine-solutions/jane-io 1.0.1 → 1.0.3

package/dist/core/scanners/string/string-has-whitespace-edges.js

@@ -0,0 +1,31 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | String Has Whitespace Edges
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Flags strings with leading or trailing whitespace, surfacing
+ *                  subtle formatting or input‑shape inconsistencies early.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { scanEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Flags strings with leading or trailing whitespace.
+ *
+ * Edge whitespace often indicates accidental padding, formatting mistakes, or
+ * subtle input‑shape inconsistencies. This rule highlights those anomalies
+ * before normalization or policy logic is applied.
+ */
+export const stringHasWhitespaceEdges = (raw, path) => {
+    if (typeof raw !== 'string')
+        return [];
+    if (raw !== raw.trim()) {
+        return [
+            scanEvent('warn', 'string.has.whitespace-edges', path, 'String has leading or trailing whitespace.', 'This text has extra spaces at the edges.', { raw }),
+        ];
+    }
+    return [];
+};

package/dist/core/scanners/string/string-is-long.js

@@ -0,0 +1,32 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | String Is Long
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Warns when text exceeds a conservative length threshold,
+ *                  highlighting oversized or potentially adversarial input.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { scanEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Warns when a string exceeds a conservative maximum length.
+ *
+ * Extremely long text can signal malformed payloads, denial‑of‑service
+ * attempts, or unbounded user input. This rule surfaces oversized strings
+ * early so containment and validation layers can respond safely.
+ */
+export const stringIsLong = (raw, path) => {
+    if (typeof raw !== 'string')
+        return [];
+    const max = 10_000;
+    if (raw.length > max) {
+        return [
+            scanEvent('warn', 'string.is.long', path, `String length ${raw.length} exceeds safe threshold ${max}.`, 'This text is very long.', { length: raw.length, max }),
+        ];
+    }
+    return [];
+};

package/dist/core/scanners/unknown/unknown-not-scannable.js

@@ -0,0 +1,34 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Scanners | Unknown Not Scannable
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Flags values whose structural type cannot be determined,
+ *                  surfacing opaque or unpredictable inputs that cannot be
+ *                  scanned safely.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Internal Modules                                                          *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+import { detectStructuralType } from '../../../core/pipeline';
+import { scanEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Flags values whose structural type cannot be determined.
+ *
+ * Unknown values have no predictable shape, traversal semantics, or guarantees
+ * about behavior. They may be callable, throw on access, or vary across realms.
+ * This rule surfaces opaque inputs early so containment, validation, and policy
+ * layers can decide how to handle them safely.
+ */
+export const unknownNotScannable = (raw, path) => {
+    if (detectStructuralType(raw) !== 'unknown')
+        return [];
+    return [
+        scanEvent('warn', 'unknown.not.scannable', path, 'Value has an unknown structural type and cannot be scanned safely.', 'This value cannot be scanned safely.', { value: raw }),
+    ];
+};

package/dist/core/shapes/analysis.js

@@ -0,0 +1,11 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Shapes | Analysis
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Shapes that define the structures used for diff, explain,
+ *                  replay, and telemetry analysis.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+export {};

package/dist/core/shapes/boundary.js

@@ -0,0 +1,11 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Shapes | Boundary
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Shapes that define the structure, policy surface, and
+ *                  results of boundary evaluation.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+export {};

package/dist/core/shapes/events.js

@@ -0,0 +1,10 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Shapes | Event
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Structured observations emitted by each pipeline phase.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+export {};

package/dist/core/shapes/field-path.js

@@ -0,0 +1,10 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Shapes | Field Path
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Structural paths that locate positions inside JSON‑like data.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+export {};

package/dist/core/shapes/index.js

@@ -0,0 +1,11 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Shapes | Barrel File
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Central export surface for all shape families in this
+ *                  module.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+export {};

package/dist/core/shapes/normalize.js

@@ -0,0 +1,11 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Shapes | Normalize
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Shapes that define mode‑aware value transformations during
+ *                  normalization.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+export {};

package/dist/core/shapes/parse.js

@@ -0,0 +1,11 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Shapes | Parse
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Shapes that define how raw strings are converted into typed
+ *                  values.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+export {};

package/dist/core/shapes/pipeline.js

@@ -0,0 +1,11 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Shapes | Pipeline
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Shapes that define the structural contracts between
+ *                  pipeline stages.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+export {};

package/dist/core/shapes/policy.js

@@ -0,0 +1,11 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Shapes | Policy
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Configuration shapes that control how boundaries interpret
+ *                  and act on events.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+export {};

package/dist/core/shapes/public.js

@@ -0,0 +1,10 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Shapes | Public
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Stable result and input shapes exposed by the public API.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+export {};

package/dist/core/shapes/scan.js

@@ -0,0 +1,11 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Shapes | Scan
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Shapes that define how raw input is inspected and converted
+ *                  into safe JSON‑like form.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+export {};

package/dist/core/shapes/validate.js

@@ -0,0 +1,11 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Shapes | Validate
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Shapes that define rule‑driven correctness checks during
+ *                  validation.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+export {};

package/dist/core/validators/array/array-max-items.js

@@ -0,0 +1,42 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Array Maximum Items (Array Max Items)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that an array does not exceed a maximum number of
+ *                  items.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that an array does not exceed a maximum number of items.
+ *
+ * This rule checks:
+ * - The value is structurally an array
+ * - The array length is less than or equal to the provided maximum
+ *
+ * Emits:
+ * - array.not.array
+ * - array.too.long
+ *
+ * This rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const arrayMaxItems = (max) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (!Array.isArray(value)) {
+        return [
+            validationEvent('error', 'array.not.array', path, `Expected 'array' but received '${structuralType}'.`, `Please provide a valid array.`, { value, expected: 'array', actual: structuralType }),
+        ];
+    }
+    if (value.length > max) {
+        return [
+            validationEvent('error', 'array.too.long', path, `Array length ${value.length} must be ≤ ${max}.`, `Please provide no more than ${max} items.`, { value, expected: `≤ ${max}`, actual: value.length }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/array/array-min-items.js

@@ -0,0 +1,42 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Array Minimum Items (Array Min Items)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that an array contains at least a minimum number of
+ *                  items.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that an array contains at least a minimum number of items.
+ *
+ * This rule checks:
+ * - The value is structurally an array
+ * - The array length is greater than or equal to the provided minimum
+ *
+ * Emits:
+ * - array.not.array
+ * - array.too.short
+ *
+ * This rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const arrayMinItems = (min) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (!Array.isArray(value)) {
+        return [
+            validationEvent('error', 'array.not.array', path, `Expected 'array' but received '${structuralType}'.`, `Please provide a valid array.`, { value, expected: 'array', actual: structuralType }),
+        ];
+    }
+    if (value.length < min) {
+        return [
+            validationEvent('error', 'array.too.short', path, `Array length ${value.length} must be ≥ ${min}.`, `Please provide at least ${min} items.`, { value, expected: `≥ ${min}`, actual: value.length }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/array/array.js

@@ -0,0 +1,34 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Array
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a value is structurally an array.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that a value is structurally an array.
+ *
+ * This rule checks:
+ * - The value is an array according to JavaScript semantics
+ *
+ * Emits:
+ * - array.not.array
+ *
+ * This rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const array = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (!Array.isArray(value)) {
+        return [
+            validationEvent('error', 'array.not.array', path, `Expected 'array' but received '${structuralType}'.`, `Please provide a valid array.`, { value, expected: 'array', actual: structuralType }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/array/excludes.js

@@ -0,0 +1,47 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Excludes
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that an array does not include a specific
+ *                  disallowed item.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { safeStringify } from '../../common';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that an array does not include a specific disallowed item.
+ *
+ * This rule checks:
+ * - The value is structurally an array
+ * - The array does not contain the provided item (using Array.prototype.includes)
+ *
+ * Emits:
+ * - array.not.array
+ * - array.has.invalid-value
+ *
+ * This rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const excludes = (item) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (!Array.isArray(value)) {
+        return [
+            validationEvent('error', 'array.not.array', path, `Expected 'array' but received '${structuralType}'.`, `Please provide a valid array.`, { value, expected: 'array', actual: structuralType }),
+        ];
+    }
+    if (value.includes(item)) {
+        return [
+            validationEvent('error', 'array.has.invalid-value', path, `Array must not include ${safeStringify(item)}.`, `Please remove the disallowed item.`, {
+                value,
+                expected: `exclude ${safeStringify(item)}`,
+                actual: value,
+            }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/array/has-unique-items.js

@@ -0,0 +1,46 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Has Unique Items
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that an array contains only unique items.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that an array contains only unique items.
+ *
+ * This rule checks:
+ * - The value is structurally an array
+ * - The array does not contain duplicate items (using reference and value equality via Set)
+ *
+ * Emits:
+ * - array.not.array
+ * - array.not.unique
+ *
+ * This rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const hasUniqueItems = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (!Array.isArray(value)) {
+        return [
+            validationEvent('error', 'array.not.array', path, `Expected 'array' but received '${structuralType}'.`, `Please provide a valid array.`, { value, expected: 'array', actual: structuralType }),
+        ];
+    }
+    const uniqueSet = new Set(value);
+    if (uniqueSet.size !== value.length) {
+        return [
+            validationEvent('error', 'array.not.unique', path, `Array must contain only unique items.`, `Please remove duplicate items.`, {
+                value,
+                expected: 'unique items',
+                actual: 'duplicates found',
+            }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/array/includes.js

@@ -0,0 +1,46 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Includes
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that an array includes a specific required item.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { safeStringify } from '../../common';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that an array includes a specific required item.
+ *
+ * This rule checks:
+ * - The value is structurally an array
+ * - The array contains the provided item (using Array.prototype.includes)
+ *
+ * Emits:
+ * - array.not.array
+ * - array.is.missing-value
+ *
+ * This rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const includes = (item) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (!Array.isArray(value)) {
+        return [
+            validationEvent('error', 'array.not.array', path, `Expected 'array' but received '${structuralType}'.`, `Please provide a valid array.`, { value, expected: 'array', actual: structuralType }),
+        ];
+    }
+    if (!value.includes(item)) {
+        return [
+            validationEvent('error', 'array.is.missing-value', path, `Array must include ${safeStringify(item)}.`, `Please include the required item.`, {
+                value,
+                expected: `includes ${safeStringify(item)}`,
+                actual: value,
+            }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/array/items-equal.js

@@ -0,0 +1,42 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Items Equal
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that an array contains exactly the specified
+ *                  number of items.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that an array contains exactly the specified number of items.
+ *
+ * This rule checks:
+ * - The value is structurally an array
+ * - The array length matches the exact required count
+ *
+ * Emits:
+ * - array.not.array
+ * - array.has.invalid-length
+ *
+ * This rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const itemsEqual = (exact) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (!Array.isArray(value)) {
+        return [
+            validationEvent('error', 'array.not.array', path, `Expected 'array' but received '${structuralType}'.`, `Please provide a valid array.`, { value, expected: 'array', actual: structuralType }),
+        ];
+    }
+    if (value.length !== exact) {
+        return [
+            validationEvent('error', 'array.has.invalid-length', path, `Array length ${value.length} must be exactly ${exact}.`, `Please provide exactly ${exact} items.`, { value, expected: exact, actual: value.length }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/array/no-empty-string-items.js

@@ -0,0 +1,46 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | No Empty String Items
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that an array does not contain empty string items.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that an array does not contain empty string items.
+ *
+ * This rule checks:
+ * - The value is structurally an array
+ * - No element in the array is an empty string ("")
+ *
+ * Emits:
+ * - array.not.array
+ * - array.has.empty-strings
+ *
+ * This rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const noEmptyStringItems = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (!Array.isArray(value)) {
+        return [
+            validationEvent('error', 'array.not.array', path, `Expected 'array' but received '${structuralType}'.`, `Please provide a valid array.`, { value, expected: 'array', actual: structuralType }),
+        ];
+    }
+    const containsEmptyString = value.some((item) => item === '');
+    if (containsEmptyString) {
+        return [
+            validationEvent('error', 'array.has.empty-strings', path, `Array must not contain empty strings.`, `Please remove empty string items.`, {
+                value,
+                expected: 'no empty strings',
+                actual: 'contains empty string',
+            }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/array/no-null-items.js

@@ -0,0 +1,46 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | No Null Items
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that an array does not contain null items.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that an array does not contain null items.
+ *
+ * This rule checks:
+ * - The value is structurally an array
+ * - No element in the array is strictly equal to null
+ *
+ * Emits:
+ * - array.not.array
+ * - array.has.null-items
+ *
+ * This rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const noNullItems = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (!Array.isArray(value)) {
+        return [
+            validationEvent('error', 'array.not.array', path, `Expected 'array' but received '${structuralType}'.`, `Please provide a valid array.`, { value, expected: 'array', actual: structuralType }),
+        ];
+    }
+    const containsNull = value.some((item) => item === null);
+    if (containsNull) {
+        return [
+            validationEvent('error', 'array.has.null-items', path, `Array must not contain null values.`, `Please remove null items.`, {
+                value,
+                expected: 'no null items',
+                actual: 'contains null',
+            }),
+        ];
+    }
+    return [];
+};