@clementine-solutions/jane-io 1.0.0 → 1.0.2

package/dist/core/normalizers/string/empty-to-undefined.js

@@ -0,0 +1,33 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Empty To Undefined
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Converts empty strings to undefined, removing text fields
+ *                  that contain no meaningful content.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Converts empty strings to undefined, removing text fields that contain no
+ * meaningful content.
+ */
+export const emptyToUndefined = (value, _mode, path) => {
+    if (typeof value !== 'string')
+        return [];
+    if (value.length > 0)
+        return [];
+    const event = normalizationEvent('info', 'string.now.undefined', path, 'Converted empty string to undefined.', 'Empty text was removed.', { before: value, after: undefined });
+    return [
+        {
+            path,
+            nextValue: undefined,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/string/trim.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Trim
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes leading and trailing whitespace, normalizing text
+ *                  edges while preserving internal content exactly as provided.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { NormalizationRule } from '../../shapes';
+/**
+ * Trims leading and trailing whitespace, normalizing text edges while
+ * preserving the internal content exactly as provided.
+ */
+export declare const trim: NormalizationRule<unknown>;

package/dist/core/normalizers/string/trim.js

@@ -0,0 +1,34 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Trim
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes leading and trailing whitespace, normalizing text
+ *                  edges while preserving internal content exactly as provided.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Trims leading and trailing whitespace, normalizing text edges while
+ * preserving the internal content exactly as provided.
+ */
+export const trim = (value, _mode, path) => {
+    if (typeof value !== 'string')
+        return [];
+    const trimmed = value.trim();
+    if (trimmed === value)
+        return [];
+    const event = normalizationEvent('info', 'string.now.trimmed', path, 'Removed leading and trailing whitespace.', 'Extra spaces at the beginning or end were removed.', { before: value, after: trimmed });
+    return [
+        {
+            path,
+            nextValue: trimmed,
+            lossy: 'lossless',
+            events: [event],
+        },
+    ];
+};

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

@@ -0,0 +1,22 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Barrel File
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Re‑exports all parser implementations, providing a unified
+ *                  entry point for Jane’s parsing subsystem.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+export { parseArrayString } from './parse-array-string';
+export { parseJsonString } from './parse-json-string';
+export { parseBigIntString } from './parse-bigint-string';
+export { parseBinaryString } from './parse-binary-string';
+export { parseHexString } from './parse-hex-string';
+export { parseOctalString } from './parse-octal-string';
+export { parseBooleanString } from './parse-boolean-string';
+export { parseIsoDateString } from './parse-date-string';
+export { parseDurationString } from './parse-duration-string';
+export { parseNumericString } from './parse-numeric-string';
+export { parseObjectString } from './parse-object-string';
+export { parseUrlString } from './parse-url-string';

package/dist/core/parsers/index.js

@@ -0,0 +1,43 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Barrel File
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Re‑exports all parser implementations, providing a unified
+ *                  entry point for Jane’s parsing subsystem.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Array Values                                                              *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { parseArrayString } from './parse-array-string';
+export { parseJsonString } from './parse-json-string';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Bigint Values                                                             *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { parseBigIntString } from './parse-bigint-string';
+export { parseBinaryString } from './parse-binary-string';
+export { parseHexString } from './parse-hex-string';
+export { parseOctalString } from './parse-octal-string';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Boolean Values                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { parseBooleanString } from './parse-boolean-string';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Date Values                                                               *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { parseIsoDateString } from './parse-date-string';
+export { parseDurationString } from './parse-duration-string';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Number Values                                                             *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { parseNumericString } from './parse-numeric-string';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Object Values                                                             *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { parseObjectString } from './parse-object-string';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* URL Values                                                                *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { parseUrlString } from './parse-url-string';

package/dist/core/parsers/parse-array-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Array String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses JSON‑compatible array strings into actual arrays,
+ *                  rejecting ambiguous or non‑array input.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses JSON‑compatible array strings into actual arrays, rejecting anything
+ * that is not a syntactically valid array literal.
+ */
+export declare const parseArrayString: ParseRule<unknown>;

package/dist/core/parsers/parse-array-string.js

@@ -0,0 +1,36 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Array String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses JSON‑compatible array strings into actual arrays,
+ *                  rejecting ambiguous or non‑array input.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { parseEvent } from '../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Parses JSON‑compatible array strings into actual arrays, rejecting anything
+ * that is not a syntactically valid array literal.
+ */
+export const parseArrayString = (value, path) => {
+    if (typeof value !== 'string')
+        return [];
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('[') || !trimmed.endsWith(']'))
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(parsed))
+        return [];
+    const event = parseEvent('info', 'string.now.array', 'Parsed string into a JSON array.', path, 'Converted text into a list.', { before: value, after: parsed });
+    return [{ path, nextValue: parsed, events: [event] }];
+};

package/dist/core/parsers/parse-bigint-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Bigint String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses canonical decimal bigint literals into `bigint`
+ *                  values, enforcing strict, non‑guessing numeric rules.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses canonical decimal bigint strings into `bigint` values, enforcing a
+ * strict digits‑only format with an optional leading minus.
+ */
+export declare const parseBigIntString: ParseRule<unknown>;

package/dist/core/parsers/parse-bigint-string.js

@@ -0,0 +1,33 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Bigint String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses canonical decimal bigint literals into `bigint`
+ *                  values, enforcing strict, non‑guessing numeric rules.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { parseEvent } from '../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Parses canonical decimal bigint strings into `bigint` values, enforcing a
+ * strict digits‑only format with an optional leading minus.
+ */
+export const parseBigIntString = (value, path) => {
+    if (typeof value !== 'string')
+        return [];
+    if (!/^-?\d+$/.test(value))
+        return [];
+    let parsed;
+    try {
+        parsed = BigInt(value);
+    }
+    catch {
+        return [];
+    }
+    const event = parseEvent('info', 'string.now.bigint', `String parsed into bigint ${parsed}.`, path, 'Converted text into a large integer.', { before: value, after: parsed });
+    return [{ path, nextValue: parsed, events: [event] }];
+};

package/dist/core/parsers/parse-binary-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Binary String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses binary string literals (0b…) into `bigint` values,
+ *                  validating format and rejecting malformed input.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses binary string literals (`0b…`) into `bigint` values, validating format
+ * and rejecting malformed or non‑binary input.
+ */
+export declare const parseBinaryString: ParseRule<unknown>;

package/dist/core/parsers/parse-binary-string.js

@@ -0,0 +1,33 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Binary String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses binary string literals (0b…) into `bigint` values,
+ *                  validating format and rejecting malformed input.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { parseEvent } from '../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Parses binary string literals (`0b…`) into `bigint` values, validating format
+ * and rejecting malformed or non‑binary input.
+ */
+export const parseBinaryString = (value, path) => {
+    if (typeof value !== 'string')
+        return [];
+    if (!/^0b[01]+$/.test(value))
+        return [];
+    let parsed;
+    try {
+        parsed = BigInt(value);
+    }
+    catch {
+        return [];
+    }
+    const event = parseEvent('info', 'string.now.binary', `Binary string parsed into bigint ${parsed}.`, path, 'Converted binary text into a number.', { before: value, after: parsed });
+    return [{ path, nextValue: parsed, events: [event] }];
+};

package/dist/core/parsers/parse-boolean-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Boolean String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses strict boolean strings (`"true"` / `"false"`) into
+ *                  boolean values without accepting loose or coercive forms.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses strict boolean strings (`"true"` or `"false"`) into boolean values,
+ * without accepting loose or coercive forms.
+ */
+export declare const parseBooleanString: ParseRule<unknown>;

package/dist/core/parsers/parse-boolean-string.js

@@ -0,0 +1,27 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Boolean String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses strict boolean strings (`"true"` / `"false"`) into
+ *                  boolean values without accepting loose or coercive forms.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { parseEvent } from '../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Parses strict boolean strings (`"true"` or `"false"`) into boolean values,
+ * without accepting loose or coercive forms.
+ */
+export const parseBooleanString = (value, path) => {
+    if (typeof value !== 'string')
+        return [];
+    if (value !== 'true' && value !== 'false')
+        return [];
+    const parsed = value === 'true';
+    const event = parseEvent('info', 'string.now.boolean', `String parsed into boolean ${parsed}.`, path, 'Converted text into true or false.', { before: value, after: parsed });
+    return [{ path, nextValue: parsed, events: [event] }];
+};

package/dist/core/parsers/parse-date-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse ISO Date String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses strict ISO‑8601 date strings into `Date` objects,
+ *                  rejecting malformed or non‑standard formats.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses strict ISO‑8601 date strings into `Date` objects, rejecting malformed
+ * or non‑standard formats and ensuring the resulting timestamp is valid.
+ */
+export declare const parseIsoDateString: ParseRule<unknown>;

package/dist/core/parsers/parse-date-string.js

@@ -0,0 +1,30 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse ISO Date String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses strict ISO‑8601 date strings into `Date` objects,
+ *                  rejecting malformed or non‑standard formats.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { parseEvent } from '../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Parses strict ISO‑8601 date strings into `Date` objects, rejecting malformed
+ * or non‑standard formats and ensuring the resulting timestamp is valid.
+ */
+export const parseIsoDateString = (value, path) => {
+    if (typeof value !== 'string')
+        return [];
+    const iso = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(?:Z|[+-]\d{2}:\d{2})?)?$/;
+    if (!iso.test(value))
+        return [];
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime()))
+        return [];
+    const event = parseEvent('info', 'string.now.date', `String parsed into Date ${parsed.toISOString()}.`, path, 'Converted text into a date.', { before: value, after: parsed });
+    return [{ path, nextValue: parsed, events: [event] }];
+};

package/dist/core/parsers/parse-duration-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Duration String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses duration strings of the form `<number><unit>` (s, m,
+ *                  h, d) into structured duration objects.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses duration strings of the form `<number><unit>` (s, m, h, d) into
+ * structured duration objects, rejecting ambiguous or partial formats.
+ */
+export declare const parseDurationString: ParseRule<unknown>;

package/dist/core/parsers/parse-duration-string.js

@@ -0,0 +1,37 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Duration String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses duration strings of the form `<number><unit>` (s, m,
+ *                  h, d) into structured duration objects.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { parseEvent } from '../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Parses duration strings of the form `<number><unit>` (s, m, h, d) into
+ * structured duration objects, rejecting ambiguous or partial formats.
+ */
+export const parseDurationString = (value, path) => {
+    if (typeof value !== 'string')
+        return [];
+    // Strict: number + unit (s, m, h, d)
+    const match = /^(-?\d+)([smhd])$/.exec(value);
+    if (!match)
+        return [];
+    const amount = Number(match[1]);
+    const unit = match[2];
+    const parsed = unit === 's'
+        ? { seconds: amount }
+        : unit === 'm'
+            ? { minutes: amount }
+            : unit === 'h'
+                ? { hours: amount }
+                : { days: amount };
+    const event = parseEvent('info', 'string.now.duration', `String parsed into duration object (${JSON.stringify(parsed)}).`, path, 'Converted text into a time duration.', { before: value, after: parsed });
+    return [{ path, nextValue: parsed, events: [event] }];
+};

package/dist/core/parsers/parse-hex-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Hex String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses hexadecimal string literals (0x…) into `bigint`
+ *                  values, enforcing canonical formatting.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses hexadecimal string literals (`0x…`) into numeric values, rejecting
+ * malformed or non‑hexadecimal input.
+ */
+export declare const parseHexString: ParseRule<unknown>;

package/dist/core/parsers/parse-hex-string.js

@@ -0,0 +1,29 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Hex String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses hexadecimal string literals (0x…) into `bigint`
+ *                  values, enforcing canonical formatting.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { parseEvent } from '../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Parses hexadecimal string literals (`0x…`) into numeric values, rejecting
+ * malformed or non‑hexadecimal input.
+ */
+export const parseHexString = (value, path) => {
+    if (typeof value !== 'string')
+        return [];
+    if (!/^0x[0-9a-fA-F]+$/.test(value))
+        return [];
+    const parsed = Number(value);
+    if (Number.isNaN(parsed))
+        return [];
+    const event = parseEvent('info', 'string.now.hex', `Hex string parsed into number ${parsed}.`, path, 'Converted hexadecimal text into a number.', { before: value, after: parsed });
+    return [{ path, nextValue: parsed, events: [event] }];
+};

package/dist/core/parsers/parse-integer-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Integer String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses strict integer strings into numeric values, rejecting
+ *                  floats, scientific notation, and ambiguous formats.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses strict integer strings into numeric values, rejecting floats,
+ * scientific notation, and any non‑digit characters.
+ */
+export declare const parseIntegerString: ParseRule<unknown>;

package/dist/core/parsers/parse-integer-string.js

@@ -0,0 +1,30 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Integer String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses strict integer strings into numeric values, rejecting
+ *                  floats, scientific notation, and ambiguous formats.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { parseEvent } from '../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Parses strict integer strings into numeric values, rejecting floats,
+ * scientific notation, and any non‑digit characters.
+ */
+export const parseIntegerString = (value, path) => {
+    if (typeof value !== 'string')
+        return [];
+    // Strict integer: optional leading minus, digits only
+    if (!/^-?\d+$/.test(value))
+        return [];
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed))
+        return [];
+    const event = parseEvent('info', 'string.now.integer', `String parsed into integer ${parsed}.`, path, 'Converted text into a whole number.', { before: value, after: parsed });
+    return [{ path, nextValue: parsed, events: [event] }];
+};

package/dist/core/parsers/parse-json-string.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse JSON String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses JSON‑compatible strings into structured data,
+ *                  accepting only valid objects, arrays, or quoted strings.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses JSON‑compatible strings into structured data, accepting only objects,
+ * arrays, or quoted strings and rejecting anything that cannot be parsed
+ * safely.
+ */
+export declare const parseJsonString: ParseRule<unknown>;

package/dist/core/parsers/parse-json-string.js

@@ -0,0 +1,35 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse JSON String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses JSON‑compatible strings into structured data,
+ *                  accepting only valid objects, arrays, or quoted strings.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { parseEvent } from '../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Parses JSON‑compatible strings into structured data, accepting only objects,
+ * arrays, or quoted strings and rejecting anything that cannot be parsed
+ * safely.
+ */
+export const parseJsonString = (value, path) => {
+    if (typeof value !== 'string')
+        return [];
+    const first = value.trim()[0];
+    if (first !== '{' && first !== '[' && first !== '"')
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        return [];
+    }
+    const event = parseEvent('info', 'string.now.json', 'String parsed as JSON.', path, 'Converted text into structured data.', { before: value, after: parsed });
+    return [{ path, nextValue: parsed, events: [event] }];
+};

package/dist/core/parsers/parse-numeric-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Numeric String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses strict numeric strings into numbers, supporting
+ *                  optional decimals while rejecting ambiguous formats.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses strict numeric strings into JavaScript numbers, supporting optional
+ * decimals while rejecting scientific notation and non‑numeric characters.
+ */
+export declare const parseNumericString: ParseRule<unknown>;