@clementine-solutions/jane-io 1.0.1 → 1.0.3

package/dist/core/validators/string/is-printable.js

@@ -0,0 +1,53 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Printable
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string containing only
+ *                  printable ASCII characters (code points 0x20–0x7E).
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is a string containing only printable ASCII
+ * characters (code points 0x20–0x7E).
+ *
+ * - Non‑string values emit `string.not.string`.
+ * - Strings containing characters outside the printable ASCII range emit
+ *   `string.not.printable`.
+ * - Returns an empty array when the value is valid.
+ *
+ * This rule is pure, total, async‑compatible, and returns a readonly array of
+ * JaneEvent objects. It preserves the provided path and supports userMessage
+ * overrides applied at the pipeline level.
+ */
+export const isPrintable = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Type check
+    // ------------------------------------------------------------
+    if (typeof value !== 'string') {
+        return [
+            validationEvent('error', 'string.not.string', path, `Expected 'string' but received '${structuralType}'.`, `Please enter a valid string.`, { value, expected: 'string', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Printable ASCII check
+    // ------------------------------------------------------------
+    const printablePattern = /^[\x20-\x7E]+$/;
+    if (!printablePattern.test(value)) {
+        return [
+            validationEvent('error', 'string.not.printable', path, `${safeStringify(value)} must contain only printable ASCII characters.`, `Please use only printable characters.`, { value, expected: 'printable ASCII', actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/matches.js

@@ -0,0 +1,50 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Matches
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string matching the provided
+ *                  regular expression.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is a string matching the provided regular expression.
+ *
+ * - Non‑string values emit `string.not.string`.
+ * - Strings that do not satisfy the pattern emit `string.is.not-match`.
+ * - Returns an empty array when the value is valid.
+ *
+ * This rule is pure, total, async‑compatible, and returns a readonly array of
+ * JaneEvent objects. It preserves the provided path and supports userMessage
+ * overrides applied at the pipeline level.
+ */
+export const matches = (pattern) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Type check
+    // ------------------------------------------------------------
+    if (typeof value !== 'string') {
+        return [
+            validationEvent('error', 'string.not.string', path, `Expected 'string' but received '${structuralType}'.`, `Please provide a valid string.`, { value, expected: 'string', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Pattern match check
+    // ------------------------------------------------------------
+    if (!pattern.test(value)) {
+        return [
+            validationEvent('error', 'string.is.not-match', path, `${safeStringify(value)} must match pattern ${pattern}.`, `Please provide a value matching the required format.`, { value, expected: pattern.toString(), actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/max-length.js

@@ -0,0 +1,50 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Maximum Length (Max Length)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string whose length is less
+ *                  than or equal to the provided `max` value.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is a string whose length is less than or equal to
+ * the provided `max` value.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings longer than `max` emit `string.too.long`.
+ * - Returns an empty array when the value is valid.
+ *
+ * This rule is pure, total, async‑compatible, and returns a readonly array of
+ * JaneEvent objects. It preserves the provided path and supports userMessage
+ * overrides applied at the pipeline level.
+ */
+export const maxLength = (max) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Type check
+    // ------------------------------------------------------------
+    if (typeof value !== 'string') {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'string' but received '${structuralType}'.`, `Please enter a valid string.`, { value, expected: 'string', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Maximum-length check
+    // ------------------------------------------------------------
+    if (value.length > max) {
+        return [
+            validationEvent('error', 'string.too.long', path, `String length ${value.length} must be ≤ ${max}.`, `Please enter no more than ${max} characters.`, { value, expected: `≤ ${max}`, actual: value.length }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/min-length.js

@@ -0,0 +1,50 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Minimum Length (Min Length)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string whose length is greater
+ *                  than or equal to the provided `min` value.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is a string whose length is greater than or equal to
+ * the provided `min` value.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings shorter than `min` emit `string.too.short`.
+ * - Returns an empty array when the value is valid.
+ *
+ * This rule is pure, total, async‑compatible, and returns a readonly array of
+ * JaneEvent objects. It preserves the provided path and supports userMessage
+ * overrides applied at the pipeline level.
+ */
+export const minLength = (min) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Type check
+    // ------------------------------------------------------------
+    if (typeof value !== 'string') {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'string' but received '${structuralType}'.`, `Please enter a valid string.`, { value, expected: 'string', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Minimum-length check
+    // ------------------------------------------------------------
+    if (value.length < min) {
+        return [
+            validationEvent('error', 'string.too.short', path, `String length ${value.length} must be ≥ ${min}.`, `Please enter at least ${min} characters.`, { value, expected: `≥ ${min}`, actual: value.length }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/no-lead-space.js

@@ -0,0 +1,50 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | No Leading Whitespace (No Lead Space)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string that does not begin
+ *                  with whitespace.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { safeStringify } from '../../common';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is a string that does not begin with whitespace.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings beginning with whitespace emit `string.has.leading-whitespace`.
+ * - Returns an empty array when the value is valid.
+ *
+ * This rule is pure, total, async‑compatible, and returns a readonly array of
+ * JaneEvent objects. It preserves the provided path and supports userMessage
+ * overrides applied at the pipeline level.
+ */
+export const noLeadSpace = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Type check
+    // ------------------------------------------------------------
+    if (typeof value !== 'string') {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'string' but received '${structuralType}'.`, `Please enter a valid string.`, { value, expected: 'string', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Leading whitespace check
+    // ------------------------------------------------------------
+    if (/^\s/.test(value)) {
+        return [
+            validationEvent('error', 'string.has.leading-whitespace', path, `${safeStringify(value)} must not start with whitespace.`, `Please remove leading spaces.`, { value, expected: 'no leading space', actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/no-repeat-space.js

@@ -0,0 +1,52 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | No Repeated Whitespace (No Repeat Space)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string that does not contain
+ *                  repeated consecutive space characters.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { safeStringify } from '../../common';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is a string that does not contain repeated
+ * consecutive space characters.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings containing `"  "` (two or more consecutive spaces) emit
+ *   `string.has.repeating-whitespace`.
+ * - Returns an empty array when the value is valid.
+ *
+ * This rule is pure, total, async‑compatible, and returns a readonly array of
+ * JaneEvent objects. It preserves the provided path and supports userMessage
+ * overrides applied at the pipeline level.
+ */
+export const noRepeatSpace = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Type check
+    // ------------------------------------------------------------
+    if (typeof value !== 'string') {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'string' but received '${structuralType}'.`, `Please enter a valid string.`, { value, expected: 'string', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Repeated-space check
+    // ------------------------------------------------------------
+    if (/ {2,}/.test(value)) {
+        return [
+            validationEvent('error', 'string.has.repeating-whitespace', path, `${safeStringify(value)} must not contain repeated spaces.`, `Please remove extra spaces.`, { value, expected: 'no repeated spaces', actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/no-space.js

@@ -0,0 +1,51 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | No Whitespace (No Space)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string containing no
+ *                  whitespace characters.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { safeStringify } from '../../common';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is a string containing no whitespace characters.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings containing any whitespace (spaces, tabs, newlines, etc.) emit
+ *   `string.has.whitespace`.
+ * - Returns an empty array when the value is valid.
+ *
+ * This rule is pure, total, async‑compatible, and returns a readonly array of
+ * JaneEvent objects. It preserves the provided path and supports userMessage
+ * overrides applied at the pipeline level.
+ */
+export const noSpace = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Type check
+    // ------------------------------------------------------------
+    if (typeof value !== 'string') {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'string' but received '${structuralType}'.`, `Please enter a valid string.`, { value, expected: 'string', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Whitespace check
+    // ------------------------------------------------------------
+    if (/\s/.test(value)) {
+        return [
+            validationEvent('error', 'string.has.whitespace', path, `${safeStringify(value)} must not contain whitespace.`, `Please remove spaces.`, { value, expected: 'no whitespace', actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/no-trail-space.js

@@ -0,0 +1,50 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | No Trailing Whitespace (No Trail Space)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string that does not end with
+ *                  whitespace.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { safeStringify } from '../../common';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is a string that does not end with whitespace.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings ending with whitespace emit `string.has.trailing-whitespace`.
+ * - Returns an empty array when the value is valid.
+ *
+ * This rule is pure, total, async‑compatible, and returns a readonly array of
+ * JaneEvent objects. It preserves the provided path and supports userMessage
+ * overrides applied at the pipeline level.
+ */
+export const noTrailSpace = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Type check
+    // ------------------------------------------------------------
+    if (typeof value !== 'string') {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'string' but received '${structuralType}'.`, `Please enter a valid string.`, { value, expected: 'string', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Trailing whitespace check
+    // ------------------------------------------------------------
+    if (/\s$/.test(value)) {
+        return [
+            validationEvent('error', 'string.has.trailing-whitespace', path, `${safeStringify(value)} must not end with whitespace.`, `Please remove trailing spaces.`, { value, expected: 'no trailing space', actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/non-empty.js

@@ -0,0 +1,48 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Non-Empty
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a non-empty string.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is a non-empty string.
+ *
+ * - Non‑string values emit `string.not.string`.
+ * - Empty strings emit `string.is.empty`.
+ * - Returns an empty array when the value is valid.
+ *
+ * This rule is pure, total, async‑compatible, and returns a readonly array of
+ * JaneEvent objects. It preserves the provided path and supports userMessage
+ * overrides applied at the pipeline level.
+ */
+export const nonEmpty = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Type check
+    // ------------------------------------------------------------
+    if (typeof value !== 'string') {
+        return [
+            validationEvent('error', 'string.not.string', path, `Expected 'string' but received '${structuralType}'.`, `Please enter a valid string.`, { value, expected: 'string', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Non-empty check
+    // ------------------------------------------------------------
+    if (value.length === 0) {
+        return [
+            validationEvent('error', 'string.is.empty', path, `String must not be empty.`, `Please enter a non-empty string.`, { value, expected: 'non-empty', actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/not-one-of.js

@@ -0,0 +1,51 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Not One Of
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string that is *not* included
+ *                  in the provided `disallowed` list.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { safeStringify } from '../../common';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is a string that is *not* included in the provided
+ * `disallowed` list.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings that appear in the disallowed list emit `string.is.disallowed`.
+ * - Returns an empty array when the value is valid.
+ *
+ * This rule is pure, total, async‑compatible, and returns a readonly array of
+ * JaneEvent objects. It preserves the provided path and supports userMessage
+ * overrides applied at the pipeline level.
+ */
+export const notOneOf = (disallowed) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Type check
+    // ------------------------------------------------------------
+    if (typeof value !== 'string') {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'string' but received '${structuralType}'.`, `Please enter a valid string.`, { value, expected: 'string', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Disallowed membership check
+    // ------------------------------------------------------------
+    if (disallowed.includes(value)) {
+        return [
+            validationEvent('error', 'string.is.disallowed', path, `${safeStringify(value)} must not be one of: ${disallowed.join(', ')}.`, `Please enter a different value.`, { value, expected: `not in ${disallowed}`, actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/num-string.js

@@ -0,0 +1,50 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Number String (Num String)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string containing only ASCII
+ *                  digits (`0–9`).
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is a string containing only ASCII digits (`0–9`).
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings containing any non-digit character emit `string.not.numeric`.
+ * - Returns an empty array when the value is valid.
+ *
+ * This rule is pure, total, async‑compatible, and returns a readonly array of
+ * JaneEvent objects. It preserves the provided path and supports userMessage
+ * overrides applied at the pipeline level.
+ */
+export const numString = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Type check
+    // ------------------------------------------------------------
+    if (typeof value !== 'string') {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'string' but received '${structuralType}'.`, `Please enter a valid string.`, { value, expected: 'string', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Digit-only check
+    // ------------------------------------------------------------
+    if (!/^[0-9]+$/.test(value)) {
+        return [
+            validationEvent('error', 'string.not.numeric', path, `${safeStringify(value)} must contain only digits.`, `Please use only numbers.`, { value, expected: '0-9', actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/one-of.js

@@ -0,0 +1,50 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | One Of
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string included in the
+ *                  provided `allowed` list.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is a string included in the provided `allowed` list.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings not present in the allowed list emit `string.not.allowed`.
+ * - Returns an empty array when the value is valid.
+ *
+ * This rule is pure, total, async‑compatible, and returns a readonly array of
+ * JaneEvent objects. It preserves the provided path and supports userMessage
+ * overrides applied at the pipeline level.
+ */
+export const oneOf = (allowed) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Type check
+    // ------------------------------------------------------------
+    if (typeof value !== 'string') {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'string' but received '${structuralType}'.`, `Please enter a valid string.`, { value, expected: 'string', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Allowed membership check
+    // ------------------------------------------------------------
+    if (!allowed.includes(value)) {
+        return [
+            validationEvent('error', 'string.not.allowed', path, `${safeStringify(value)} must be one of: ${allowed.join(', ')}.`, `Please enter one of the allowed values.`, { value, expected: allowed, actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};