@clementine-solutions/jane-io 1.0.1 → 1.0.3

package/dist/core/boundary-rules/require-all.js

@@ -0,0 +1,39 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Boundary Rules | Require All
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Requires that all specified fields be present and accepted.
+ *                  Missing or rejected fields each produce a boundary error.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { rootPath } from '../field-path';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Requires that all specified fields be present and accepted. Any missing or
+ * rejected field results in a boundary‑level error for that key.
+ */
+export function requireAll(...keys) {
+    return ({ fields }) => {
+        const events = [];
+        const issues = [];
+        for (const key of keys) {
+            const r = fields[key];
+            if (!r || r.decision?.code !== 'accept') {
+                const ev = {
+                    phase: 'decide',
+                    kind: 'error',
+                    code: 'boundary.does.require-all',
+                    message: `Field "${key}" is required`,
+                    path: rootPath(key),
+                };
+                events.push(ev);
+                issues.push(ev);
+            }
+        }
+        return { events, issues };
+    };
+}

package/dist/core/boundary-rules/require-one.js

@@ -0,0 +1,41 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Boundary Rules | Require One
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Requires that at least one of the specified fields be
+ *                  accepted. If none are present, a single boundary error is
+ *                  emitted.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { rootPath } from '../field-path';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Requires that at least one of the specified fields be present and accepted.
+ * If none are provided, a single boundary‑level error is emitted.
+ */
+export function requireOne(...keys) {
+    return ({ fields }) => {
+        const events = [];
+        const issues = [];
+        const ok = keys.some((key) => {
+            const r = fields[key];
+            return r && r.decision?.code === 'accept';
+        });
+        if (!ok) {
+            const ev = {
+                phase: 'decide',
+                kind: 'error',
+                code: 'boundary.does.require-one',
+                message: `At least one of [${keys.join(', ')}] is required`,
+                path: rootPath(),
+            };
+            events.push(ev);
+            issues.push(ev);
+        }
+        return { events, issues };
+    };
+}

package/dist/core/common/events.js

@@ -0,0 +1,82 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Common | Events
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Shared event types, factories, and helpers used across all
+ *                  pipeline stages. These modules define how Jane records and
+ *                  communicates observable facts during execution.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Create Event                                                              *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Creates a frozen JaneEvent with consistent metadata.
+ *
+ * This factory centralizes event construction so all stages emit the same
+ * shape: stable identifiers, optional context, and a metadata block that
+ * tooling can rely on. Callers provide only the facts; the factory attaches
+ * timestamps and prepares the object for safe sharing across the pipeline.
+ *
+ * The returned event is immutable to prevent accidental mutation during
+ * scan, parse, normalize, validate, boundary, or policy execution.
+ */
+export function createEvent(phase, kind, code, path, message, userMessage, meta) {
+    return Object.freeze({
+        phase,
+        kind,
+        code,
+        path,
+        message,
+        userMessage,
+        metadata: {
+            ...meta,
+            runId: undefined,
+            createdAt: Date.now(),
+        },
+    });
+}
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Is Jane Event                                                             *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Structural type guard for JaneEvent.
+ *
+ * This check verifies that a value has the minimal shape required for an
+ * event: a valid phase, kind, code, and optional context fields. It does not
+ * validate semantics or metadata—only that the object is structurally safe to
+ * treat as a JaneEvent inside the pipeline.
+ *
+ * The guard is intentionally strict and literal. It accepts only the phases
+ * and kinds defined here, ensuring that stray or misspelled values cannot
+ * enter policy, explain, or replay logic.
+ */
+export function isJaneEvent(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const item = value;
+    const path = item['path'];
+    const kind = item['kind'];
+    const phase = item['phase'];
+    const kindIsValid = kind === 'info' || kind === 'warn' || kind === 'error' || kind === 'fatal';
+    const phaseIsValid = phase === 'scan' ||
+        phase === 'normalize' ||
+        phase === 'validate' ||
+        phase === 'parse' ||
+        phase === 'decide';
+    const pathIsValid = path === undefined ||
+        (typeof path === 'object' &&
+            path !== null &&
+            'segments' in path &&
+            Array.isArray(path['segments']));
+    const messageIsValid = item['message'] === undefined || typeof item['message'] === 'string';
+    return (typeof phase === 'string' &&
+        phaseIsValid &&
+        typeof kind === 'string' &&
+        kindIsValid &&
+        typeof item['code'] === 'string' &&
+        messageIsValid &&
+        pathIsValid);
+}

package/dist/core/common/fluent.js

@@ -0,0 +1,429 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Common | Fluent
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Internal helpers that build Jane’s fluent API surface.
+ *                  These modules attach parser and validator methods and wrap
+ *                  PipelineBuilder instances into the public pipeline.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { rootPath } from '../field-path';
+import { boundaryRunner, createPipeline } from '../pipeline';
+import { telemetry } from '../analysis';
+import { defaultPolicy } from '../common';
+import { janeRegistry } from '../fluent-registry';
+import { boundaryPolicyDefault, boundaryPolicyLax, boundaryPolicyStrict, mergeBoundaryPolicies, normalizePolicy, resolvePolicy, } from './policy';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Attach Public Fluent Validators                                           *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Attaches public fluent validator methods to a pipeline instance.
+ *
+ * Each validator name in the registry becomes a fluent method on the public
+ * pipeline. Calls delegate to the underlying builder, then wrap the updated
+ * builder to produce the next public pipeline in the chain.
+ *
+ * Methods are defined as non‑enumerable and immutable so the fluent surface
+ * stays stable, predictable, and free of accidental overrides.
+ */
+function attachPublicFluentValidators(pub, builder, wrap) {
+    for (const name of Object.keys(janeRegistry.validators)) {
+        Object.defineProperty(pub, name, {
+            enumerable: false,
+            configurable: true,
+            writable: false,
+            value: (...args) => {
+                const next = builder.validate(name, ...args);
+                return wrap(next);
+            },
+        });
+    }
+}
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Builder                                                                   *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Internal hook used to associate a PipelineBuilder with a PublicPipeline.
+ *
+ * The unique symbol prevents accidental collisions with user code and keeps
+ * the builder hidden from the public API. Only internal helpers read or
+ * write this property, and it is never surfaced to consumers.
+ *
+ * PublicPipelineInternal exists solely to give internal code a typed way to
+ * access the builder without widening the public interface.
+ */
+const BUILDER = Symbol('JANE_PIPELINE_BUILDER');
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Attach Fluent Validators                                                  *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Attaches fluent validator methods directly to a PipelineBuilder.
+ *
+ * Each validator in the registry becomes a fluent method on the builder.
+ * Calls record the validator request on the current builder and return the
+ * same builder instance, allowing internal code to compose validation steps
+ * without wrapping or producing a new public pipeline.
+ *
+ * Methods are non‑enumerable and immutable so the builder’s shape stays
+ * stable and free of accidental overrides.
+ */
+export function attachFluentValidators(builder) {
+    for (const name of Object.keys(janeRegistry.validators)) {
+        Object.defineProperty(builder, name, {
+            enumerable: false,
+            configurable: true,
+            writable: false,
+            value: (...args) => builder.validate(name, ...args),
+        });
+    }
+}
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Attach Public Fluent Parsers                                              *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Attaches public fluent parser methods to a pipeline instance.
+ *
+ * Each parser name in the registry becomes a fluent method on the public
+ * pipeline. Calls delegate to the underlying builder, apply the parser, and
+ * wrap the updated builder to produce the next public pipeline in the chain.
+ *
+ * Methods are defined as non‑enumerable and immutable so the fluent surface
+ * stays stable, predictable, and free of accidental overrides.
+ */
+function attachPublicFluentParsers(pub, builder, wrap) {
+    for (const name of Object.keys(janeRegistry.parsers)) {
+        Object.defineProperty(pub, name, {
+            enumerable: false,
+            configurable: true,
+            writable: false,
+            value: (...args) => {
+                const next = builder.parse(name, ...args);
+                return wrap(next);
+            },
+        });
+    }
+}
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Attach Fluent Parsers                                                     *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Attaches fluent parser methods directly to a PipelineBuilder.
+ *
+ * Each parser in the registry becomes a fluent method on the builder. Calls
+ * record the parser request on the current builder and return the same
+ * builder instance, allowing internal code to compose parse steps without
+ * wrapping or producing a new public pipeline.
+ *
+ * Methods are non‑enumerable and immutable so the builder’s shape stays
+ * stable and free of accidental overrides.
+ */
+export function attachFluentParsers(builder) {
+    for (const name of Object.keys(janeRegistry.parsers)) {
+        Object.defineProperty(builder, name, {
+            enumerable: false,
+            configurable: true,
+            writable: false,
+            value: (...args) => builder.parse(name, ...args),
+        });
+    }
+}
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Create Jane                                                               *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Creates a policy‑aware Jane instance.
+ *
+ * Normalizes the base policy, wraps pipeline builders with the public API,
+ * and wires in analysis features (diff, explain, replay, telemetry) according
+ * to the active policy. Each fluent call returns a new wrapped builder, keeping
+ * the pipeline immutable and policy‑driven end‑to‑end.
+ */
+export function createJane(basePolicyInput) {
+    const basePolicy = normalizePolicy(defaultPolicy, basePolicyInput);
+    const wrap = (builder) => {
+        const core = {
+            async run() {
+                const result = await builder.run();
+                const policy = builder.policy ?? defaultPolicy;
+                if (policy.analysis?.telemetry && builder.overrides.telemetrySink) {
+                    const tel = telemetry({
+                        boundaryName: policy.boundaryName ?? 'unknown-boundary',
+                        pipelineName: policy.pipelineName ?? 'unknown-pipeline',
+                        result,
+                    });
+                    builder.overrides.telemetrySink(tel.records);
+                }
+                return toJaneResult(result);
+            },
+            named(name) {
+                return wrap(builder.named(name));
+            },
+            userMessage(userMessage) {
+                return wrap(builder.userMessage(userMessage));
+            },
+            parse(ruleOrName, ...args) {
+                const next = typeof ruleOrName === 'string'
+                    ? builder.parse(ruleOrName, ...args)
+                    : builder.parse(ruleOrName);
+                return wrap(next);
+            },
+            validate(ruleOrName, ...args) {
+                const next = typeof ruleOrName === 'string'
+                    ? builder.validate(ruleOrName, ...args)
+                    : builder.validate(ruleOrName);
+                return wrap(next);
+            },
+            scan() {
+                return wrap(builder.scan());
+            },
+            strict() {
+                return wrap(builder.strict());
+            },
+            moderate() {
+                return wrap(builder.moderate());
+            },
+            lax() {
+                return wrap(builder.lax());
+            },
+            withDiff() {
+                return wrap(builder.withDiff());
+            },
+            withExplain() {
+                return wrap(builder.withExplain());
+            },
+            withReplay() {
+                return wrap(builder.withReplay());
+            },
+            withTelemetry(sink) {
+                return wrap(builder.withTelemetry(sink));
+            },
+            withPolicy(input) {
+                const merged = normalizePolicy(basePolicy, input);
+                return createJane(merged);
+            },
+            allowBigint() {
+                return wrap(builder.allowBigint());
+            },
+            strictBoundary(shape) {
+                const merged = normalizePolicy(basePolicy, {
+                    boundary: boundaryPolicyStrict,
+                });
+                return createJane(merged).boundary(shape);
+            },
+            laxBoundary(shape) {
+                const merged = normalizePolicy(basePolicy, {
+                    boundary: boundaryPolicyLax,
+                });
+                return createJane(merged).boundary(shape);
+            },
+            defaultBoundary(shape) {
+                const merged = normalizePolicy(basePolicy, {
+                    boundary: boundaryPolicyDefault,
+                });
+                return createJane(merged).boundary(shape);
+            },
+            severity(map) {
+                return wrap(builder.withPolicy({ severity: map }));
+            },
+            reject(...patterns) {
+                return wrap(builder.withPolicy({ reject: patterns }));
+            },
+            review(...patterns) {
+                return wrap(builder.withPolicy({ review: patterns }));
+            },
+            warn(...patterns) {
+                return wrap(builder.withPolicy({ warn: patterns }));
+            },
+            boundaryAccept(mode) {
+                return wrap(builder.withPolicy({ boundary: { accept: mode } }));
+            },
+            boundaryIncludeRejected() {
+                return wrap(builder.withPolicy({ boundary: { values: { includeRejected: true } } }));
+            },
+            boundaryIncludeUndefined() {
+                return wrap(builder.withPolicy({ boundary: { values: { includeUndefined: true } } }));
+            },
+            boundaryTransform(fn) {
+                return wrap(builder.withPolicy({ boundary: { values: { transform: fn } } }));
+            },
+            boundaryIgnore(...patterns) {
+                return wrap(builder.withPolicy({ boundary: { ignore: patterns } }));
+            },
+            boundaryHideEvents(...patterns) {
+                return wrap(builder.withPolicy({ boundary: { hideEvents: patterns } }));
+            },
+            boundaryHideIssues(...patterns) {
+                return wrap(builder.withPolicy({ mode: 'lax', boundary: { hideIssues: patterns } }));
+            },
+            boundaryReducer(fn) {
+                return wrap(builder.withPolicy({ boundary: { reducer: fn } }));
+            },
+            boundaryHideFields() {
+                return wrap(builder.withPolicy({ boundary: { metadata: { includeFields: false } } }));
+            },
+            boundaryHideTimestamps() {
+                return wrap(builder.withPolicy({ boundary: { metadata: { includeTimestamps: false } } }));
+            },
+            boundaryHideRunId() {
+                return wrap(builder.withPolicy({ boundary: { metadata: { includeRunId: false } } }));
+            },
+            boundaryRule(rule) {
+                const existing = builder.policy?.boundary?.rules ?? [];
+                return wrap(builder.withPolicy({
+                    boundary: {
+                        rules: [...existing, rule],
+                    },
+                }));
+            },
+            boundaryRules(...rules) {
+                const existing = builder.policy?.boundary?.rules ?? [];
+                return wrap(builder.withPolicy({
+                    boundary: {
+                        rules: [...existing, ...rules],
+                    },
+                }));
+            },
+        };
+        const pub = core;
+        const internal = pub;
+        internal[BUILDER] = builder;
+        attachPublicFluentParsers(pub, builder, wrap);
+        attachPublicFluentValidators(pub, builder, wrap);
+        return pub;
+    };
+    return {
+        value(raw, path, options) {
+            const { inputName } = options ?? {};
+            const internal = createPipeline(raw, path ?? rootPath(inputName), [], [], [], basePolicy, { inputName });
+            return wrap(internal);
+        },
+        async boundary(shape) {
+            const entries = Object.entries(shape);
+            const pipelineResults = await Promise.all(entries.map(async ([key, pub]) => {
+                const internal = pub;
+                const builder = internal[BUILDER];
+                if (!builder) {
+                    throw new Error(`Internal error: missing builder for field "${key}"`);
+                }
+                const result = await builder.run();
+                return [key, result];
+            }));
+            const fields = Object.fromEntries(pipelineResults);
+            const pipelineBoundaryConfigs = pipelineResults
+                .map(([_, result]) => result.policy?.boundary)
+                .filter(Boolean);
+            const builderBoundaryConfigs = entries
+                .map(([_key, pub]) => {
+                const internal = pub;
+                const b = internal[BUILDER];
+                return b?.policy?.boundary;
+            })
+                .filter(Boolean);
+            const mergedBoundary = mergeBoundaryPolicies(basePolicy.boundary, ...builderBoundaryConfigs, ...pipelineBoundaryConfigs);
+            const effectivePolicy = resolvePolicy(defaultPolicy, {
+                ...basePolicy,
+                boundary: mergedBoundary,
+            }, {});
+            const boundary = await boundaryRunner({
+                policy: effectivePolicy,
+                fields,
+            });
+            return {
+                ...toJaneBoundaryResult(boundary, fields),
+                policy: effectivePolicy,
+            };
+        },
+        withPolicy(input) {
+            const merged = normalizePolicy(basePolicy, input);
+            return createJane(merged);
+        },
+        strictBoundary(shape) {
+            const merged = normalizePolicy(basePolicy, {
+                boundary: boundaryPolicyStrict,
+            });
+            return createJane(merged).boundary(shape);
+        },
+        laxBoundary(shape) {
+            const merged = normalizePolicy(basePolicy, {
+                boundary: boundaryPolicyLax,
+            });
+            return createJane(merged).boundary(shape);
+        },
+        defaultBoundary(shape) {
+            const merged = normalizePolicy(basePolicy, {
+                boundary: boundaryPolicyDefault,
+            });
+            return createJane(merged).boundary(shape);
+        },
+    };
+}
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* To Jane Result                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Creates a Jane instance with a normalized base policy and the full fluent API.
+ *
+ * The factory wraps a PipelineBuilder and exposes a stable, user‑facing
+ * pipeline surface. Each fluent call produces a new wrapped builder, while
+ * root‑level helpers (value, boundary, withPolicy) create new Jane instances
+ * with merged policy state.
+ *
+ * The wrapper isolates internal builder mechanics from consumers, attaches
+ * parser and validator methods from the registry, and ensures that telemetry,
+ * diff, explain, replay, and boundary behavior all flow through a consistent
+ * entry point. All policy resolution happens here so contributors can reason
+ * about effective behavior without tracing through individual pipeline steps.
+ */
+export function toJaneResult(r) {
+    const issues = r.events.filter((e) => e.kind === 'error' || e.kind === 'fatal');
+    const events = r.events.filter((e) => e.kind === 'info' || e.kind === 'warn');
+    return {
+        ok: issues.length === 0,
+        issues: issues.length > 0 ? issues : undefined,
+        events: events.length > 0 ? events : undefined,
+        value: r.final,
+        path: r.path,
+        diff: r.diff,
+        explain: r.explain,
+        replay: r.replay,
+        metadata: {
+            raw: r.raw,
+            rawType: r.rawType,
+            safe: r.safe,
+            safeType: r.safeType,
+            normalized: r.normalized,
+            normalizedType: r.normalizedType,
+            final: r.final,
+            finalType: r.finalType,
+            startedAt: r.metadata.startedAt,
+            finishedAt: r.metadata.finishedAt,
+            durationMs: r.metadata.durationMs,
+            inputName: r.metadata.inputName,
+        },
+    };
+}
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* To Jane Boundary Result                                                   *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Converts an internal BoundaryResult and its field-level PipelineResults
+ * into the public JaneBoundaryResult shape.
+ *
+ * Each pipeline result is first converted to a JaneResult, then assembled
+ * alongside the boundary’s own decision, issues, events, values, and metadata.
+ * No interpretation or rewriting occurs here—this function preserves the
+ * boundary runner’s output exactly while projecting it into the public API.
+ */
+export function toJaneBoundaryResult(boundary, pipelines) {
+    const janeResults = Object.fromEntries(Object.entries(pipelines).map(([k, p]) => [k, toJaneResult(p)]));
+    return {
+        ok: boundary.ok,
+        issues: boundary.issues,
+        events: boundary.events,
+        values: boundary.values,
+        fields: janeResults,
+        metadata: boundary.metadata,
+    };
+}

package/dist/core/common/index.js

@@ -0,0 +1,31 @@
+/**
+ * ----------------------------------------------------------------------------
+ *  Common | Barrel File
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Re‑exports shared common modules to provide a stable,
+ *                  minimal entry point for internal consumers. This file
+ *                  exposes no logic of its own.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Events                                                                    *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { createEvent, isJaneEvent } from './events';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Fluent                                                                    *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { attachFluentParsers, attachFluentValidators, createJane, toJaneBoundaryResult, toJaneResult, } from './fluent';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Policy                                                                    *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { applyEscalate, applyOverride, boundaryPolicyDefault, boundaryPolicyLax, boundaryPolicyStrict, clampSeverityIndex, compileSeverityMap, decideEvent, defaultPolicy, laxPolicy, normalizePolicy, mergeBoundaryPolicies, policyDecision, resolveLevel, resolvePolicy, severityIndex, SEVERITY_ORDER, strictPolicy, } from './policy';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Utilities                                                                 *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { deepEqual, generateRunId, isObject, isPlainObject, isPrimitive, safeStringify, } from './utilities';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Wildcard                                                                  *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { compileWildcard, getCompiledWildcard, matchesWildcard } from './wildcard';