@oh-my-pi/omptype 17.2.6 → 17.2.7

package/dist/js/type.js

@@ -0,0 +1,1078 @@
+/**
+ * The public `type()` parser and `Type` schema surface — an ArkType-compatible
+ * validator with a lazy JIT:
+ *
+ * - calls 1-2 run the tree-walking interpreter (near-zero setup cost, so
+ *   schemas built per-request or validated once stay cheap)
+ * - the third call compiles a specialized validator via `new Function` and
+ *   swaps it in; hot schemas validate in tens of nanoseconds
+ *
+ * A schema is a callable: `schema(data)` returns the (possibly morphed)
+ * output, or an `OmpErrors` on failure (`result instanceof type.errors`).
+ */
+import { compile, compileAllows } from "./compile.js";
+import { OmpErrors, OmpTypeError, TraversalError } from "./errors.js";
+import { walk } from "./interp.js";
+import { embed, expectedOf, hasMorph, IR_BRAND, keyOf, parseDef, } from "./ir.js";
+import { irToJsonSchema } from "./json-schema.js";
+import { keywordIR, patternIR } from "./keywords.js";
+/** Runtime constructor-like value used by ArkType-compatible `instanceof Type` checks. */
+export const Type = Object.defineProperty(function Type() { }, Symbol.hasInstance, {
+    value: (value) => (typeof value === "function" || (typeof value === "object" && value !== null)) && IR_BRAND in value,
+});
+class Ctx {
+    expectation;
+    mustBe(expectation) {
+        this.expectation = expectation;
+        return false;
+    }
+    reject(problem) {
+        this.expectation = problem;
+        return false;
+    }
+}
+const kBase = Symbol("omptype.base");
+const kSteps = Symbol("omptype.steps");
+const EMPTY_STEPS = [];
+const EMPTY_META = {};
+/** Calls before the JIT compiles a schema (first two run the interpreter). */
+const JIT_THRESHOLD = 3;
+function metaOf(schema) {
+    return {
+        description: schema.description,
+        defaultValue: schema.defaultValue,
+        hasDefault: schema.hasDefault,
+        errorConfig: schema.errorConfig,
+    };
+}
+const typeMethods = {
+    describe(description) {
+        return makeType({ ...this.ir, desc: description }, this[kSteps], { ...metaOf(this), description });
+    },
+    configure(config) {
+        const errorConfig = {
+            ...this.errorConfig,
+            ...(config.expected === undefined ? {} : { expected: config.expected }),
+            ...(config.actual === undefined ? {} : { actual: config.actual }),
+            ...(config.problem === undefined ? {} : { problem: config.problem }),
+            ...(config.message === undefined ? {} : { message: config.message }),
+        };
+        const meta = {
+            ...metaOf(this),
+            errorConfig,
+            ...(config.description === undefined ? {} : { description: config.description }),
+        };
+        return config.description === undefined
+            ? makeType(this.ir, this[kSteps], meta)
+            : makeType({ ...this.ir, desc: config.description }, this[kSteps], meta);
+    },
+    default(value) {
+        return makeType(this.ir, this[kSteps], { ...metaOf(this), defaultValue: value, hasDefault: true });
+    },
+    optional() {
+        return [this, "?"];
+    },
+    or(def) {
+        const other = parseDef(def);
+        const a = embed(this);
+        const members = [...(a.k === "union" ? a.members : [a]), ...(other.k === "union" ? other.members : [other])];
+        return makeType({ k: "union", members }, [], {});
+    },
+    equals(def) {
+        return irEquals(embed(this), parseDef(def));
+    },
+    ifEquals(def) {
+        return irEquals(embed(this), parseDef(def)) ? this : undefined;
+    },
+    extends(def) {
+        return isSubtype(embed(this), parseDef(def));
+    },
+    overlaps(def) {
+        try {
+            intersect(embed(this), parseDef(def));
+            return true;
+        }
+        catch (error) {
+            if (error instanceof OmpTypeError)
+                return false;
+            throw error;
+        }
+    },
+    distribute(mapper) {
+        const branches = this.ir.k === "union" ? this.ir.members : [embed(this)];
+        const members = branches.map(branch => embed(mapper(makeType(branch, [], {}))));
+        return makeType(members.length === 1 ? members[0] : { k: "union", members }, [], {});
+    },
+    select(kind) {
+        return selectNodes(this.ir, kind);
+    },
+    and(def) {
+        return makeType(intersect(embed(this), parseDef(def)), [], {});
+    },
+    array() {
+        return makeType({ k: "array", el: embed(this) }, [], {});
+    },
+    atLeastLength(bound) {
+        return makeType(withLengthBound(this.ir, "min", bound), this[kSteps], metaOf(this));
+    },
+    atMostLength(bound) {
+        return makeType(withLengthBound(this.ir, "max", bound), this[kSteps], metaOf(this));
+    },
+    moreThanLength(bound) {
+        return makeType(withLengthBound(this.ir, "min", bound + 1), this[kSteps], metaOf(this));
+    },
+    lessThanLength(bound) {
+        return makeType(withLengthBound(this.ir, "max", bound - 1), this[kSteps], metaOf(this));
+    },
+    exactlyLength(bound) {
+        const bounded = withLengthBound(withLengthBound(this.ir, "min", bound), "max", bound);
+        return makeType(bounded, this[kSteps], metaOf(this));
+    },
+    atLeast(bound) {
+        return makeType(withNumericBound(this.ir, "min", bound), this[kSteps], metaOf(this));
+    },
+    atMost(bound) {
+        return makeType(withNumericBound(this.ir, "max", bound), this[kSteps], metaOf(this));
+    },
+    moreThan(bound) {
+        return makeType(withNumericBound(this.ir, "min", bound, true), this[kSteps], metaOf(this));
+    },
+    lessThan(bound) {
+        return makeType(withNumericBound(this.ir, "max", bound, true), this[kSteps], metaOf(this));
+    },
+    divisibleBy(divisor) {
+        if (this.ir.k !== "number")
+            throw new OmpTypeError(`cannot apply divisibility to ${this.ir.k}`);
+        if (!Number.isFinite(divisor) || divisor === 0)
+            throw new OmpTypeError("divisor must be non-zero");
+        return makeType({ ...this.ir, divisor }, this[kSteps], metaOf(this));
+    },
+    positive() {
+        return makeType(withNumericBound(this.ir, "min", 0, true), this[kSteps], metaOf(this));
+    },
+    negative() {
+        return makeType(withNumericBound(this.ir, "max", 0, true), this[kSteps], metaOf(this));
+    },
+    nonNegative() {
+        return makeType(withNumericBound(this.ir, "min", 0), this[kSteps], metaOf(this));
+    },
+    nonPositive() {
+        return makeType(withNumericBound(this.ir, "max", 0), this[kSteps], metaOf(this));
+    },
+    matching(pattern) {
+        return makeType(intersect(this.ir, patternIR(pattern)), this[kSteps], metaOf(this));
+    },
+    atOrAfter(bound) {
+        return dateRefinement(this, bound, "at or after", value => value >= bound.valueOf());
+    },
+    atOrBefore(bound) {
+        return dateRefinement(this, bound, "at or before", value => value <= bound.valueOf());
+    },
+    laterThan(bound) {
+        return dateRefinement(this, bound, "later than", value => value > bound.valueOf());
+    },
+    earlierThan(bound) {
+        return dateRefinement(this, bound, "earlier than", value => value < bound.valueOf());
+    },
+    pipe(fn) {
+        return makeType(this.ir, [...this[kSteps], { kind: "pipe", fn }], metaOf(this));
+    },
+    to(def) {
+        const output = makeType(parseDef(def), [], {});
+        return makeType(this.ir, [
+            ...this[kSteps],
+            {
+                kind: "pipe",
+                fn: value => output(value),
+            },
+        ], metaOf(this));
+    },
+    filter(fn) {
+        return makeType(this.ir, [{ kind: "filter", fn }, ...this[kSteps]], metaOf(this));
+    },
+    narrow(fn) {
+        return makeType(this.ir, [...this[kSteps], { kind: "narrow", fn }], metaOf(this));
+    },
+    brand() {
+        return makeType(this.ir, this[kSteps], metaOf(this));
+    },
+    as() {
+        return makeType(this.ir, this[kSteps], metaOf(this));
+    },
+    keyof() {
+        return makeType(keyOf(this.ir), [], {});
+    },
+    get(key) {
+        const object = requireObject(this.ir, "get");
+        const prop = object.props.find(candidate => candidate.key === String(key));
+        if (!prop)
+            throw new OmpTypeError(`key ${String(key)} is not declared`);
+        const ir = prop.opt ? { k: "union", members: [prop.val, { k: "undefined" }] } : prop.val;
+        return makeType(ir, [], {});
+    },
+    pick(...keys) {
+        const object = requireObject(this.ir, "pick");
+        const selected = new Set(keys.map(String));
+        return makeType({ ...object, props: object.props.filter(prop => selected.has(prop.key)) }, [], {});
+    },
+    omit(...keys) {
+        const object = requireObject(this.ir, "omit");
+        const omitted = new Set(keys.map(String));
+        return makeType({ ...object, props: object.props.filter(prop => !omitted.has(prop.key)) }, [], {});
+    },
+    partial() {
+        const object = requireObject(this.ir, "partial");
+        return makeType({ ...object, props: object.props.map(prop => ({ ...prop, opt: true })) }, [], {});
+    },
+    required() {
+        const object = requireObject(this.ir, "required");
+        return makeType({ ...object, props: object.props.map(prop => ({ ...prop, opt: false })) }, [], {});
+    },
+    map(mapper) {
+        const object = requireObject(this.ir, "map");
+        const props = object.props.flatMap(prop => {
+            const mapped = mapper(propertyFromIR(prop));
+            return (Array.isArray(mapped) ? mapped : [mapped]).map(propertyToIR);
+        });
+        return makeType({ ...object, props }, [], {});
+    },
+    merge(def) {
+        return makeType(mergeObjects(requireObject(this.ir, "merge"), requireObject(parseDef(def), "merge")), [], {});
+    },
+    extract(def) {
+        const other = parseDef(def);
+        return makeType({
+            k: "refine",
+            base: embed(this),
+            pred: value => !(walk(other, value) instanceof OmpErrors),
+            expected: "a value included by the extracted type",
+        }, [], {});
+    },
+    exclude(def) {
+        const other = parseDef(def);
+        return makeType({
+            k: "refine",
+            base: embed(this),
+            pred: value => walk(other, value) instanceof OmpErrors,
+            expected: "a value not excluded by the type",
+        }, [], {});
+    },
+    onUndeclaredKey(behavior) {
+        const object = requireObject(this.ir, "onUndeclaredKey");
+        return makeType({ ...object, extras: behavior === "ignore" ? "keep" : behavior }, this[kSteps], metaOf(this));
+    },
+    onDeepUndeclaredKey(behavior) {
+        return makeType(withDeepExtras(this.ir, behavior === "ignore" ? "keep" : behavior), this[kSteps], metaOf(this));
+    },
+    allows(data) {
+        const steps = this[kSteps];
+        let needsPredicates = false;
+        for (const step of steps) {
+            if (step.kind !== "pipe") {
+                needsPredicates = true;
+                break;
+            }
+        }
+        if (!needsPredicates) {
+            const allows = compileAllows(this.ir);
+            // Shadow the shared dispatcher once this schema has its specialized check.
+            this.allows = allows;
+            return allows(data);
+        }
+        for (const step of steps) {
+            if (step.kind === "filter" && !step.fn(data, new Ctx()))
+                return false;
+        }
+        const out = this[kBase](data);
+        if (out instanceof OmpErrors)
+            return false;
+        for (const step of steps) {
+            if (step.kind === "narrow" && !step.fn(out, new Ctx()))
+                return false;
+        }
+        return true;
+    },
+    assert(data) {
+        const out = this.run(data);
+        if (out instanceof OmpErrors)
+            throw new TraversalError(out);
+        return out;
+    },
+    from(data) {
+        const out = this.run(data);
+        if (out instanceof OmpErrors)
+            throw new TraversalError(out);
+        return out;
+    },
+    toJsonSchema(options) {
+        const description = options?.description ?? this.description;
+        return irToJsonSchema(this.ir, options === undefined && description === undefined
+            ? undefined
+            : { ...options, ...(description === undefined ? {} : { description }) });
+    },
+};
+Object.defineProperty(typeMethods, "props", {
+    get() {
+        const object = requireObject(this.ir, "props");
+        return object.props.map(prop => propertyFromIR(prop));
+    },
+});
+// Share the fluent surface without per-schema method allocations or copies.
+// Function.prototype remains in the chain, except bind is intentionally hidden
+// so generic tool wrappers recognize callable schemas rather than rebinding them.
+Object.setPrototypeOf(typeMethods, Function.prototype);
+Object.defineProperty(typeMethods, "bind", { value: undefined });
+function makeType(ir, steps, meta) {
+    let calls = 0;
+    let impl = (data) => {
+        if (++calls >= JIT_THRESHOLD) {
+            impl = compile(ir);
+            return impl(data);
+        }
+        return walk(ir, data);
+    };
+    const base = meta.errorConfig === undefined
+        ? (data) => impl(data)
+        : (data) => {
+            const result = impl(data);
+            return result instanceof OmpErrors ? result.configure(meta.errorConfig ?? {}) : result;
+        };
+    const callable = steps.length === 0
+        ? base
+        : (data) => {
+            for (const step of steps) {
+                if (step.kind !== "filter")
+                    continue;
+                const ctx = new Ctx();
+                if (!step.fn(data, ctx)) {
+                    return OmpErrors.single([], ctx.expectation ?? "valid (input predicate failed)", data, meta.errorConfig);
+                }
+            }
+            let out = base(data);
+            if (out instanceof OmpErrors)
+                return out;
+            for (const step of steps) {
+                if (step.kind === "filter")
+                    continue;
+                const ctx = new Ctx();
+                if (step.kind === "narrow") {
+                    if (!step.fn(out, ctx)) {
+                        return OmpErrors.single([], ctx.expectation ?? "valid (narrow predicate failed)", out, meta.errorConfig);
+                    }
+                }
+                else {
+                    out = step.fn(out, ctx);
+                    if (out instanceof OmpErrors) {
+                        return meta.errorConfig === undefined ? out : out.configure(meta.errorConfig);
+                    }
+                }
+            }
+            return out;
+        };
+    const self = callable;
+    self[IR_BRAND] = true;
+    self[kBase] = base;
+    self[kSteps] = steps;
+    self.ir = ir;
+    self.hasSteps = steps.length > 0;
+    self.hasDefault = meta.hasDefault === true;
+    self.defaultValue = meta.defaultValue;
+    self.description = meta.description;
+    self.errorConfig = meta.errorConfig;
+    self.run = callable;
+    Object.setPrototypeOf(self, typeMethods);
+    return self;
+}
+function requireObject(ir, operation) {
+    if (ir.k !== "object")
+        throw new OmpTypeError(`${operation} requires an object schema`);
+    return ir;
+}
+function propertyFromIR(prop) {
+    return {
+        kind: prop.opt ? "optional" : "required",
+        key: prop.key,
+        value: makeType(prop.val, [], {}),
+        ...(prop.hasDefault ? { default: prop.def } : {}),
+        meta: {},
+    };
+}
+function propertyToIR(property) {
+    if (property.kind !== "required" && property.kind !== "optional") {
+        throw new OmpTypeError(`mapped property ${String(property.key)} has invalid kind`);
+    }
+    if (!(IR_BRAND in property.value)) {
+        throw new OmpTypeError(`mapped property ${String(property.key)} must contain a schema value`);
+    }
+    const hasDefault = Object.hasOwn(property, "default");
+    return {
+        key: String(property.key),
+        opt: property.kind === "optional",
+        val: embed(property.value),
+        ...(hasDefault
+            ? { def: property.default, defFactory: typeof property.default === "function", hasDefault: true }
+            : {}),
+    };
+}
+function dateRefinement(schema, bound, relation, predicate) {
+    if (!Number.isFinite(bound.valueOf()))
+        throw new OmpTypeError("date bound must be valid");
+    return makeType({
+        k: "refine",
+        base: schema.ir,
+        pred: value => value instanceof Date && predicate(value.valueOf()),
+        expected: `a Date ${relation} ${bound.toISOString()}`,
+        json: relation.includes("after") ? { minimum: bound.toISOString() } : { maximum: bound.toISOString() },
+    }, schema[kSteps], metaOf(schema));
+}
+function selectNodes(root, kind) {
+    const selected = [];
+    const seen = new Set();
+    const visit = (node) => {
+        if (seen.has(node))
+            return;
+        seen.add(node);
+        const nodeKind = node.k === "lit" ? "unit" : node.k;
+        if (kind === nodeKind || kind === node.k) {
+            selected.push(node.k === "lit" ? { kind: nodeKind, node, unit: node.v } : { kind: nodeKind, node });
+        }
+        switch (node.k) {
+            case "alias":
+                visit(node.resolve());
+                break;
+            case "array":
+                visit(node.el);
+                break;
+            case "tuple":
+                for (const item of node.prefix)
+                    visit(item.val);
+                if (node.variadic !== undefined)
+                    visit(node.variadic);
+                for (const item of node.postfix)
+                    visit(item);
+                break;
+            case "object":
+                for (const prop of node.props)
+                    visit(prop.val);
+                if (node.index !== undefined)
+                    visit(node.index);
+                break;
+            case "union":
+            case "intersection":
+                for (const member of node.members)
+                    visit(member);
+                break;
+            case "refine":
+                visit(node.base);
+                break;
+            case "morph":
+                visit(node.input);
+                if (node.out !== undefined)
+                    visit(node.out);
+                break;
+            case "sub":
+                visit(node.schema.ir);
+                break;
+        }
+    };
+    visit(root);
+    return selected;
+}
+function mergeObjects(left, right) {
+    const props = [...left.props];
+    for (const prop of right.props) {
+        const index = props.findIndex(candidate => candidate.key === prop.key);
+        if (index < 0)
+            props.push(prop);
+        else
+            props[index] = prop;
+    }
+    return {
+        k: "object",
+        props,
+        index: right.index ?? left.index,
+        extras: right.extras === "keep" ? left.extras : right.extras,
+    };
+}
+function withDeepExtras(ir, extras) {
+    switch (ir.k) {
+        case "object":
+            return {
+                ...ir,
+                extras,
+                props: ir.props.map(prop => ({ ...prop, val: withDeepExtras(prop.val, extras) })),
+                index: ir.index === undefined ? undefined : withDeepExtras(ir.index, extras),
+            };
+        case "array":
+            return { ...ir, el: withDeepExtras(ir.el, extras) };
+        case "tuple":
+            return {
+                ...ir,
+                prefix: ir.prefix.map(item => ({ ...item, val: withDeepExtras(item.val, extras) })),
+                variadic: ir.variadic === undefined ? undefined : withDeepExtras(ir.variadic, extras),
+                postfix: ir.postfix.map(item => withDeepExtras(item, extras)),
+            };
+        case "union":
+        case "intersection":
+            return { ...ir, members: ir.members.map(member => withDeepExtras(member, extras)) };
+        case "refine":
+            return { ...ir, base: withDeepExtras(ir.base, extras) };
+        case "morph":
+            return {
+                ...ir,
+                input: withDeepExtras(ir.input, extras),
+                out: ir.out === undefined ? undefined : withDeepExtras(ir.out, extras),
+            };
+        default:
+            return ir;
+    }
+}
+/** Intersect two IR nodes, rejecting statically disjoint domains. */
+function intersect(a, b) {
+    if (a.k === "alias")
+        return intersect(a.resolve(), b);
+    if (b.k === "alias")
+        return intersect(a, b.resolve());
+    if (a.k === "never" || b.k === "never")
+        throw new OmpTypeError("intersection with never is unsatisfiable");
+    if (a.k === "unknown")
+        return b;
+    if (b.k === "unknown")
+        return a;
+    if (a === b)
+        return a;
+    if (a.k === "union" || b.k === "union") {
+        const union = a.k === "union" ? a : b.k === "union" ? b : undefined;
+        if (union === undefined)
+            throw new OmpTypeError("union intersection invariant failed");
+        const branches = union.members;
+        const other = a.k === "union" ? b : a;
+        const members = [];
+        for (const branch of branches) {
+            try {
+                members.push(intersect(branch, other));
+            }
+            catch (error) {
+                if (!(error instanceof OmpTypeError))
+                    throw error;
+            }
+        }
+        if (members.length === 0)
+            throw new OmpTypeError("intersection has no satisfiable branches");
+        return members.length === 1 ? members[0] : { k: "union", members };
+    }
+    if (a.k === "lit") {
+        if (walk(b, a.v) instanceof OmpErrors)
+            throw new OmpTypeError("literal is excluded by the intersection");
+        return a;
+    }
+    if (b.k === "lit")
+        return intersect(b, a);
+    if (a.k === "object" && b.k === "object") {
+        const props = [...a.props];
+        for (const bp of b.props) {
+            const index = props.findIndex(prop => prop.key === bp.key);
+            if (index < 0)
+                props.push(bp);
+            else {
+                const ap = props[index];
+                props[index] = { ...ap, opt: ap.opt && bp.opt, val: intersect(ap.val, bp.val) };
+            }
+        }
+        const extras = a.extras === "reject" || b.extras === "reject"
+            ? "reject"
+            : a.extras === "delete" || b.extras === "delete"
+                ? "delete"
+                : "keep";
+        const index = a.index && b.index ? intersect(a.index, b.index) : (a.index ?? b.index);
+        return { k: "object", props, index, extras };
+    }
+    if (a.k === "string" && b.k === "string") {
+        const min = maxOf(a.min, b.min);
+        const max = minOf(a.max, b.max);
+        if (min !== undefined && max !== undefined && min > max) {
+            throw new OmpTypeError("string length intersection is unsatisfiable");
+        }
+        return { k: "string", min, max, url: a.url || b.url };
+    }
+    if (a.k === "number" && b.k === "number") {
+        const min = maxOf(a.min, b.min);
+        const max = minOf(a.max, b.max);
+        const xmin = min !== undefined && ((a.min === min && a.xmin === true) || (b.min === min && b.xmin === true));
+        const xmax = max !== undefined && ((a.max === max && a.xmax === true) || (b.max === max && b.xmax === true));
+        if (min !== undefined && max !== undefined && (min > max || (min === max && (xmin || xmax)))) {
+            throw new OmpTypeError("numeric range intersection is unsatisfiable");
+        }
+        if (a.divisor !== undefined && b.divisor !== undefined && a.divisor !== b.divisor) {
+            return { k: "intersection", members: [a, b] };
+        }
+        return {
+            k: "number",
+            int: a.int || b.int,
+            divisor: a.divisor ?? b.divisor,
+            min,
+            max,
+            xmin,
+            xmax,
+        };
+    }
+    if (a.k === "array" && b.k === "array") {
+        const min = maxOf(a.min, b.min);
+        const max = minOf(a.max, b.max);
+        if (min !== undefined && max !== undefined && min > max) {
+            throw new OmpTypeError("array length intersection is unsatisfiable");
+        }
+        return { k: "array", el: intersect(a.el, b.el), min, max };
+    }
+    if (a.k === "instance" && b.k === "instance") {
+        if (a.ctor === b.ctor || a.ctor.prototype instanceof b.ctor)
+            return a;
+        if (b.ctor.prototype instanceof a.ctor)
+            return b;
+        throw new OmpTypeError(`intersection of ${a.expected} and ${b.expected} is unsatisfiable`);
+    }
+    if (a.k === b.k && ["null", "undefined", "boolean", "bigint", "symbol", "anyobject"].includes(a.k))
+        return a;
+    const leftDomain = domainOf(a);
+    const rightDomain = domainOf(b);
+    if (leftDomain !== undefined && rightDomain !== undefined && leftDomain !== rightDomain) {
+        throw new OmpTypeError(`intersection of ${leftDomain} and ${rightDomain} is unsatisfiable`);
+    }
+    if (a.k === "anyobject" && rightDomain === "object")
+        return b;
+    if (b.k === "anyobject" && leftDomain === "object")
+        return a;
+    const members = [...(a.k === "intersection" ? a.members : [a]), ...(b.k === "intersection" ? b.members : [b])];
+    return { k: "intersection", members };
+}
+function domainOf(ir) {
+    switch (ir.k) {
+        case "null":
+            return "null";
+        case "undefined":
+        case "boolean":
+        case "bigint":
+        case "symbol":
+        case "string":
+        case "number":
+            return ir.k;
+        case "array":
+        case "tuple":
+            return "array";
+        case "object":
+        case "anyobject":
+        case "instance":
+            return "object";
+        case "lit":
+            return ir.v === null ? "null" : Array.isArray(ir.v) ? "array" : typeof ir.v;
+        case "refine":
+            return domainOf(ir.base);
+        case "morph":
+            return domainOf(ir.input);
+        case "sub":
+            return domainOf(ir.schema.ir);
+        case "alias":
+            return domainOf(ir.resolve());
+        case "union":
+        case "intersection": {
+            const first = domainOf(ir.members[0] ?? { k: "never" });
+            return ir.members.every(member => domainOf(member) === first) ? first : undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+function lowerBoundWithin(source, target) {
+    if (target.min === undefined)
+        return true;
+    if (source.min === undefined || source.min < target.min)
+        return false;
+    return source.min !== target.min || target.xmin !== true || source.xmin === true;
+}
+function upperBoundWithin(source, target) {
+    if (target.max === undefined)
+        return true;
+    if (source.max === undefined || source.max > target.max)
+        return false;
+    return source.max !== target.max || target.xmax !== true || source.xmax === true;
+}
+function lengthWithin(source, target) {
+    return ((target.min === undefined || (source.min !== undefined && source.min >= target.min)) &&
+        (target.max === undefined || (source.max !== undefined && source.max <= target.max)));
+}
+function isSubtype(source, target, seen = new WeakMap()) {
+    if (source === target || target.k === "unknown" || source.k === "never")
+        return true;
+    let targets = seen.get(source);
+    if (targets?.has(target))
+        return true;
+    if (targets === undefined) {
+        targets = new Set();
+        seen.set(source, targets);
+    }
+    targets.add(target);
+    if (source.k === "alias")
+        return isSubtype(source.resolve(), target, seen);
+    if (target.k === "alias")
+        return isSubtype(source, target.resolve(), seen);
+    if (source.k === "union")
+        return source.members.every(member => isSubtype(member, target, seen));
+    if (target.k === "union")
+        return target.members.some(member => isSubtype(source, member, seen));
+    if (target.k === "intersection")
+        return target.members.every(member => isSubtype(source, member, seen));
+    if (source.k === "intersection")
+        return source.members.some(member => isSubtype(member, target, seen));
+    if (source.k === "lit")
+        return !(walk(target, source.v) instanceof OmpErrors);
+    if (source.k === "refine")
+        return isSubtype(source.base, target, seen);
+    if (source.k === "morph")
+        return isSubtype(source.out ?? source.input, target, seen);
+    if (source.k === "sub")
+        return isSubtype(source.schema.ir, target, seen);
+    if (target.k === "refine" || target.k === "morph" || target.k === "sub")
+        return false;
+    if (source.k === "string" && target.k === "string") {
+        return lengthWithin(source, target) && (!target.url || source.url === true);
+    }
+    if (source.k === "number" && target.k === "number") {
+        return (lowerBoundWithin(source, target) &&
+            upperBoundWithin(source, target) &&
+            (!target.int || source.int === true) &&
+            (target.divisor === undefined || (source.divisor !== undefined && source.divisor % target.divisor === 0)));
+    }
+    if (source.k === "array" && target.k === "array") {
+        return lengthWithin(source, target) && isSubtype(source.el, target.el, seen);
+    }
+    if (source.k === "object" && target.k === "object") {
+        for (const targetProp of target.props) {
+            const sourceProp = source.props.find(prop => prop.key === targetProp.key);
+            if (sourceProp === undefined) {
+                if (!targetProp.opt)
+                    return false;
+                continue;
+            }
+            if (!targetProp.opt && sourceProp.opt)
+                return false;
+            if (!isSubtype(sourceProp.val, targetProp.val, seen))
+                return false;
+        }
+        if (target.extras === "reject") {
+            if (source.extras !== "reject")
+                return false;
+            if (target.index === undefined &&
+                source.props.some(sourceProp => !target.props.some(targetProp => targetProp.key === sourceProp.key))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (source.k === "instance" && target.k === "instance") {
+        return source.ctor === target.ctor || source.ctor.prototype instanceof target.ctor;
+    }
+    if (source.k === "object" && target.k === "anyobject")
+        return true;
+    if (source.k === "instance" && target.k === "anyobject")
+        return true;
+    if (source.k === "tuple" && target.k === "array") {
+        return (source.prefix.every(item => isSubtype(item.val, target.el, seen)) &&
+            source.postfix.every(item => isSubtype(item, target.el, seen)) &&
+            (source.variadic === undefined || isSubtype(source.variadic, target.el, seen)));
+    }
+    if (source.k !== target.k)
+        return false;
+    switch (source.k) {
+        case "null":
+        case "undefined":
+        case "boolean":
+        case "bigint":
+        case "symbol":
+        case "anyobject":
+            return true;
+        case "tuple":
+            return target.k === "tuple" && expectedTuple(source) === expectedTuple(target);
+        case "instance":
+            return target.k === "instance" && source.ctor === target.ctor;
+        default:
+            return false;
+    }
+}
+function expectedTuple(tuple) {
+    return JSON.stringify({
+        prefix: tuple.prefix.map(item => [item.opt, item.hasDefault, expectedOf(item.val)]),
+        variadic: tuple.variadic === undefined ? undefined : expectedOf(tuple.variadic),
+        postfix: tuple.postfix.map(expectedOf),
+    });
+}
+function irEquals(left, right) {
+    return isSubtype(left, right) && isSubtype(right, left);
+}
+function maxOf(a, b) {
+    if (a === undefined)
+        return b;
+    if (b === undefined)
+        return a;
+    return Math.max(a, b);
+}
+function minOf(a, b) {
+    if (a === undefined)
+        return b;
+    if (b === undefined)
+        return a;
+    return Math.min(a, b);
+}
+function withLengthBound(ir, side, bound) {
+    if (ir.k === "array" || ir.k === "string") {
+        return side === "min" ? { ...ir, min: bound } : { ...ir, max: bound };
+    }
+    throw new OmpTypeError(`cannot apply length bound to ${ir.k}`);
+}
+function withNumericBound(ir, side, bound, exclusive = false) {
+    if (ir.k === "number") {
+        return side === "min" ? { ...ir, min: bound, xmin: exclusive } : { ...ir, max: bound, xmax: exclusive };
+    }
+    throw new OmpTypeError(`cannot apply numeric bound to ${ir.k}`);
+}
+/**
+ * Parse a definition into a callable schema with distinct input/output inference.
+ */
+export function type(def) {
+    return makeType(parseDef(def), EMPTY_STEPS, EMPTY_META);
+}
+function keywordSchema(name) {
+    const ir = keywordIR(name);
+    if (ir === undefined)
+        throw new OmpTypeError(`missing built-in keyword ${name}`);
+    return makeType(ir, [], {});
+}
+function parsedKeyword(name) {
+    return Object.assign(keywordSchema(name), {
+        parse: keywordSchema(`${name}.parse`),
+    });
+}
+function preformattedKeyword(name) {
+    return Object.assign(keywordSchema(name), {
+        preformatted: keywordSchema(`${name}.preformatted`),
+    });
+}
+function caseResolver(value) {
+    if (typeof value !== "function")
+        throw new OmpTypeError("match case values must be functions");
+    return input => Reflect.apply(value, undefined, [input]);
+}
+(function (type) {
+    /** Error aggregate returned by failed validations (`result instanceof type.errors`). */
+    type.errors = OmpErrors;
+    const normalize = Object.assign(keywordSchema("string.normalize"), {
+        preformatted: keywordSchema("string.normalize.NFC.preformatted"),
+        NFC: preformattedKeyword("string.normalize.NFC"),
+        NFD: preformattedKeyword("string.normalize.NFD"),
+        NFKC: preformattedKeyword("string.normalize.NFKC"),
+        NFKD: preformattedKeyword("string.normalize.NFKD"),
+    });
+    const base64 = Object.assign(keywordSchema("string.base64"), {
+        url: keywordSchema("string.base64.url"),
+    });
+    const date = Object.assign(parsedKeyword("string.date"), {
+        iso: parsedKeyword("string.date.iso"),
+        epoch: parsedKeyword("string.date.epoch"),
+    });
+    const ip = Object.assign(keywordSchema("string.ip"), {
+        v4: keywordSchema("string.ip.v4"),
+        v6: keywordSchema("string.ip.v6"),
+    });
+    const uuid = Object.assign(keywordSchema("string.uuid"), {
+        v1: keywordSchema("string.uuid.v1"),
+        v2: keywordSchema("string.uuid.v2"),
+        v3: keywordSchema("string.uuid.v3"),
+        v4: keywordSchema("string.uuid.v4"),
+        v5: keywordSchema("string.uuid.v5"),
+        v6: keywordSchema("string.uuid.v6"),
+        v7: keywordSchema("string.uuid.v7"),
+        v8: keywordSchema("string.uuid.v8"),
+    });
+    /** String validator and its refinement/morph keyword module. */
+    type.string = Object.assign(makeType({ k: "string" }, [], {}), {
+        alpha: keywordSchema("string.alpha"),
+        alphanumeric: keywordSchema("string.alphanumeric"),
+        base64,
+        capitalize: preformattedKeyword("string.capitalize"),
+        creditCard: keywordSchema("string.creditCard"),
+        date,
+        digits: keywordSchema("string.digits"),
+        email: keywordSchema("string.email"),
+        hex: keywordSchema("string.hex"),
+        integer: parsedKeyword("string.integer"),
+        ip,
+        json: parsedKeyword("string.json"),
+        lower: preformattedKeyword("string.lower"),
+        normalize,
+        numeric: parsedKeyword("string.numeric"),
+        regex: keywordSchema("string.regex"),
+        semver: keywordSchema("string.semver"),
+        trim: preformattedKeyword("string.trim"),
+        upper: preformattedKeyword("string.upper"),
+        url: parsedKeyword("string.url"),
+        uuid,
+    });
+    /** Runtime parser keyword family. */
+    type.parse = {
+        number: keywordSchema("parse.number"),
+        integer: keywordSchema("parse.integer"),
+        json: keywordSchema("parse.json"),
+        date: keywordSchema("parse.date"),
+        url: keywordSchema("parse.url"),
+        boolean: keywordSchema("parse.boolean"),
+        bigint: keywordSchema("parse.bigint"),
+    };
+    /** Number validator with integer refinement. */
+    type.number = Object.assign(makeType({ k: "number" }, [], {}), {
+        integer: makeType({ k: "number", int: true }, [], {}),
+    });
+    /** Boolean validator. */
+    type.boolean = makeType({ k: "boolean" }, [], {});
+    /** Bigint validator. */
+    type.bigint = makeType({ k: "bigint" }, [], {});
+    /** Symbol validator. */
+    type.symbol = makeType({ k: "symbol" }, [], {});
+    /** Non-null object validator. */
+    type.object = makeType({ k: "anyobject" }, [], {});
+    /** Unknown validator. */
+    type.unknown = makeType({ k: "unknown" }, [], {});
+    /** Alias of the unknown validator. */
+    type.any = type.unknown;
+    /** Validator that rejects every value. */
+    type.never = makeType({ k: "never" }, [], {});
+    /** Date instance validator. */
+    // biome-ignore lint/suspicious/noShadowRestrictedNames: ArkType exposes this exact keyword.
+    type.Date = makeType({ k: "instance", ctor: globalThis.Date, expected: "a Date" }, [], {});
+    /** Validate instances of `ctor`. */
+    function instanceOf(ctor) {
+        const name = Reflect.get(ctor, "name");
+        const expected = typeof name === "string" && name.length > 0 ? `an instance of ${name}` : "an instance";
+        return makeType({ k: "instance", ctor, expected }, [], {});
+    }
+    type.instanceOf = instanceOf;
+    /** Validate one exact unit value. */
+    function unit(value) {
+        return makeType({ k: "lit", v: value }, [], {});
+    }
+    type.unit = unit;
+    /** Union of literal values from a runtime array. */
+    function enumerated(...values) {
+        const members = values.map(value => ({ k: "lit", v: value }));
+        const ir = members.length === 0 ? { k: "never" } : members.length === 1 ? members[0] : { k: "union", members };
+        return makeType(ir, [], {});
+    }
+    type.enumerated = enumerated;
+    /** Build a first-match dispatcher from schema-expression keys and a `default` case. */
+    function match(cases) {
+        const branches = [];
+        let fallback;
+        for (const definition in cases) {
+            const resolver = caseResolver(cases[definition]);
+            if (definition === "default")
+                fallback = resolver;
+            else
+                branches.push({ schema: raw(definition), resolve: resolver });
+        }
+        return value => {
+            for (const branch of branches) {
+                if (branch.schema.allows(value))
+                    return branch.resolve(value);
+            }
+            if (fallback !== undefined)
+                return fallback(value);
+            throw new OmpTypeError("match requires a matching case or default");
+        };
+    }
+    type.match = match;
+    /** Preserve a definition's literal type while authoring reusable modules. */
+    function define(definition) {
+        return definition;
+    }
+    type.define = define;
+    /** Build a lazy named scope from aliases and recursive definitions. */
+    function scope(aliases, options) {
+        return buildScope(aliases, options);
+    }
+    type.scope = scope;
+    /** Compile a named schema module whose definitions may reference each other. */
+    function module(definitions) {
+        return scope(definitions).export();
+    }
+    type.module = module;
+    /** Build a runtime generic whose parameter names are supplied as `"<t, u>"`. */
+    function generic(parameters, definition) {
+        const names = parameters
+            .replace(/^<|>$/g, "")
+            .split(",")
+            .map(name => name.trim())
+            .filter(Boolean);
+        return (...arguments_) => {
+            if (arguments_.length !== names.length) {
+                throw new OmpTypeError(`generic expects ${names.length} arguments (received ${arguments_.length})`);
+            }
+            const aliases = {};
+            for (let index = 0; index < names.length; index++)
+                aliases[names[index]] = arguments_[index];
+            return scope(aliases).type(definition);
+        };
+    }
+    type.generic = generic;
+    /** Untyped builder for runtime-assembled definitions. */
+    function raw(def) {
+        return makeType(parseDef(def), [], {});
+    }
+    type.raw = raw;
+})(type || (type = {}));
+// Reserved words cannot be declared as namespace bindings, but ArkType exposes
+// them as runtime keyword properties.
+Object.assign(type, {
+    null: makeType({ k: "null" }, [], {}),
+    undefined: makeType({ k: "undefined" }, [], {}),
+    true: makeType({ k: "lit", v: true }, [], {}),
+    false: makeType({ k: "lit", v: false }, [], {}),
+});
+/** Build a scope whose aliases resolve lazily, including recursive cycles. */
+export function scope(aliases, options) {
+    return buildScope(aliases, options);
+}
+function buildScope(aliases, _options) {
+    const references = new Map();
+    const targets = new Map();
+    const resolve = name => {
+        if (!Object.hasOwn(aliases, name))
+            return undefined;
+        const existing = references.get(name);
+        if (existing !== undefined)
+            return existing;
+        const reference = {
+            k: "alias",
+            name,
+            resolve: () => {
+                const target = targets.get(name);
+                if (target !== undefined)
+                    return target;
+                const parsed = parseDef(aliases[name], resolve);
+                targets.set(name, parsed);
+                return parsed;
+            },
+        };
+        references.set(name, reference);
+        return reference;
+    };
+    const scoped = Object.assign((definition) => makeType(parseDef(definition, resolve), [], {}), type);
+    return {
+        type: scoped,
+        export() {
+            const schemas = {};
+            for (const name in aliases)
+                schemas[name] = scoped(name);
+            return schemas;
+        },
+    };
+}
+/** `hasMorph` re-export for diagnostics/tooling. */
+export { hasMorph };