@oh-my-pi/omptype 17.2.6 → 17.2.7

package/dist/js/typebox.js

@@ -0,0 +1,346 @@
+import { OmpTypeError } from "./errors.js";
+import { type } from "./type.js";
+const OPTIONAL_INNER = Symbol("omptype.typebox.optionalInner");
+const OBJECT_INFO = Symbol("omptype.typebox.objectInfo");
+function validationFailure(message) {
+    return { message };
+}
+function withLegacyCompat(schema) {
+    const compatSchema = schema;
+    if (!Object.hasOwn(compatSchema, "__validator")) {
+        Object.defineProperty(compatSchema, "__validator", {
+            value: (data) => {
+                const result = schema(data);
+                return result instanceof type.errors ? validationFailure(result.summary) : result;
+            },
+            configurable: true,
+        });
+    }
+    if (!Object.hasOwn(compatSchema, "safeParse")) {
+        Object.defineProperty(compatSchema, "safeParse", {
+            value: (input) => {
+                const result = schema(input);
+                return result instanceof type.errors
+                    ? { success: false, error: validationFailure(result.summary) }
+                    : { success: true, data: result };
+            },
+            configurable: true,
+        });
+    }
+    return compatSchema;
+}
+function applyMeta(schema, opts) {
+    let result = schema;
+    const description = opts?.description ?? opts?.title;
+    if (description !== undefined)
+        result = result.describe(description);
+    if (opts && Object.hasOwn(opts, "default"))
+        result = result.default(opts.default);
+    return withLegacyCompat(result);
+}
+function withJsonSchemaKeywords(schema, keywords) {
+    const emitBase = schema.toJsonSchema.bind(schema);
+    schema.toJsonSchema = options => ({ ...emitBase(options), ...keywords });
+    return schema;
+}
+function checkFiniteOption(name, value) {
+    if (value !== undefined && !Number.isFinite(value))
+        throw new OmpTypeError(`${name} must be finite`);
+}
+function tString(opts) {
+    checkFiniteOption("minLength", opts?.minLength);
+    checkFiniteOption("maxLength", opts?.maxLength);
+    let schema = type.raw(opts?.format === "url" || opts?.format === "uri" ? "string.url" : "string");
+    if (opts?.minLength !== undefined)
+        schema = schema.atLeastLength(opts.minLength);
+    if (opts?.maxLength !== undefined)
+        schema = schema.atMostLength(opts.maxLength);
+    if (opts?.pattern !== undefined) {
+        let regex;
+        try {
+            regex = new RegExp(opts.pattern);
+        }
+        catch {
+            throw new OmpTypeError(`invalid regular expression pattern ${JSON.stringify(opts.pattern)}`);
+        }
+        schema = schema.narrow((value, ctx) => regex.test(value) || ctx.mustBe(`a string matching ${opts.pattern}`));
+    }
+    if (opts?.format !== undefined && opts.format !== "url" && opts.format !== "uri") {
+        const format = opts.format;
+        const valid = formatPredicate(format);
+        schema = schema.narrow((value, ctx) => valid(value) || ctx.mustBe(`a string in ${format} format`));
+    }
+    return applyMeta(schema, opts);
+}
+function formatPredicate(format) {
+    switch (format) {
+        case "url":
+        case "uri":
+            return value => {
+                try {
+                    new URL(value);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            };
+        case "email":
+            return value => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+        case "uuid":
+            return value => /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+        case "date-time":
+            return value => /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d+)?(?:Z|[+-]\d\d:\d\d)$/.test(value) &&
+                !Number.isNaN(Date.parse(value));
+        case "date":
+            return value => /^\d{4}-\d\d-\d\d$/.test(value) && !Number.isNaN(Date.parse(`${value}T00:00:00Z`));
+        default:
+            return () => true;
+    }
+}
+function tNumber(opts, integer = false) {
+    for (const key of ["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf"]) {
+        checkFiniteOption(key, opts?.[key]);
+    }
+    if (opts?.multipleOf !== undefined && opts.multipleOf <= 0)
+        throw new OmpTypeError("multipleOf must be greater than zero");
+    let lower;
+    if (opts?.minimum !== undefined)
+        lower = { value: opts.minimum, exclusive: false };
+    if (opts?.exclusiveMinimum !== undefined && (!lower || opts.exclusiveMinimum >= lower.value)) {
+        lower = { value: opts.exclusiveMinimum, exclusive: true };
+    }
+    let upper;
+    if (opts?.maximum !== undefined)
+        upper = { value: opts.maximum, exclusive: false };
+    if (opts?.exclusiveMaximum !== undefined && (!upper || opts.exclusiveMaximum <= upper.value)) {
+        upper = { value: opts.exclusiveMaximum, exclusive: true };
+    }
+    const keyword = integer ? "number.integer" : "number";
+    const lowerDsl = lower ? `${lower.value} ${lower.exclusive ? "<" : "<="} ` : "";
+    const upperDsl = upper ? ` ${upper.exclusive ? "<" : "<="} ${upper.value}` : "";
+    let schema = type.raw(`${lowerDsl}${keyword}${upperDsl}`);
+    if (opts?.multipleOf !== undefined) {
+        const divisor = opts.multipleOf;
+        schema = schema.narrow((value, ctx) => {
+            const quotient = value / divisor;
+            return (Math.abs(quotient - Math.round(quotient)) <= Number.EPSILON * Math.max(1, Math.abs(quotient)) ||
+                ctx.mustBe(`a multiple of ${divisor}`));
+        });
+    }
+    return applyMeta(schema, opts);
+}
+function tLiteral(value, opts) {
+    return applyMeta(type.enumerated(value), opts);
+}
+function tNever(opts) {
+    return applyMeta(type.raw("unknown").narrow((_value, ctx) => ctx.mustBe("never")), opts);
+}
+function tUnion(schemas, opts) {
+    if (schemas.length === 0)
+        return tNever(opts);
+    let result = schemas[0];
+    for (let i = 1; i < schemas.length; i++)
+        result = result.or(schemas[i]);
+    return applyMeta(result, opts);
+}
+function tIntersect(schemas, opts) {
+    if (schemas.length === 0)
+        return applyMeta(type.raw("unknown"), opts);
+    const validateAll = () => {
+        const base = type.raw("unknown");
+        return base.narrow((value, ctx) => {
+            for (const schema of schemas) {
+                if (schema(value) instanceof type.errors)
+                    return ctx.mustBe("a value satisfying every intersection member");
+            }
+            return true;
+        });
+    };
+    if (schemas.some(schema => schema.hasSteps))
+        return applyMeta(validateAll(), opts);
+    let result = schemas[0];
+    try {
+        for (let i = 1; i < schemas.length; i++)
+            result = result.and(schemas[i]);
+    }
+    catch (error) {
+        if (error instanceof OmpTypeError)
+            return applyMeta(validateAll(), opts);
+        throw error;
+    }
+    return applyMeta(result, opts);
+}
+function enumValues(values) {
+    if (Array.isArray(values))
+        return [...values];
+    const result = [];
+    const record = values;
+    for (const key in record) {
+        const value = record[key];
+        if (!(/^\d+$/.test(key) && typeof value === "string") && !result.includes(value))
+            result.push(value);
+    }
+    return result;
+}
+function tEnum(values, opts) {
+    return applyMeta(type.enumerated(...enumValues(values)), opts);
+}
+function tArray(item, opts) {
+    checkFiniteOption("minItems", opts?.minItems);
+    checkFiniteOption("maxItems", opts?.maxItems);
+    let schema = item.array();
+    if (opts?.minItems !== undefined)
+        schema = schema.atLeastLength(opts.minItems);
+    if (opts?.maxItems !== undefined)
+        schema = schema.atMostLength(opts.maxItems);
+    if (opts?.uniqueItems) {
+        schema = schema.narrow((values, ctx) => {
+            for (let i = 0; i < values.length; i++) {
+                for (let j = i + 1; j < values.length; j++) {
+                    if (jsonEqual(values[i], values[j]))
+                        return ctx.mustBe("an array with unique items");
+                }
+            }
+            return true;
+        });
+    }
+    const result = applyMeta(schema, opts);
+    return opts?.uniqueItems ? withJsonSchemaKeywords(result, { uniqueItems: true }) : result;
+}
+function jsonEqual(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (typeof left !== "object" || left === null || typeof right !== "object" || right === null)
+        return false;
+    try {
+        return JSON.stringify(left) === JSON.stringify(right);
+    }
+    catch {
+        return false;
+    }
+}
+function tTuple(items, opts) {
+    const schema = type.raw("unknown").narrow((value, ctx) => {
+        if (!Array.isArray(value) || value.length !== items.length)
+            return ctx.mustBe(`a tuple of length ${items.length}`);
+        for (let i = 0; i < items.length; i++)
+            if (items[i](value[i]) instanceof type.errors)
+                return ctx.mustBe(`a valid item at index ${i}`);
+        return true;
+    });
+    return applyMeta(schema, opts);
+}
+function tObject(properties, opts) {
+    const def = {};
+    const props = {};
+    for (const key in properties) {
+        const schema = properties[key];
+        const inner = schema[OPTIONAL_INNER];
+        def[inner ? `${key}?` : key] = (inner ?? schema);
+        props[key] = schema;
+    }
+    if (opts?.additionalProperties === false)
+        def["+"] = "reject";
+    else if (opts?.additionalProperties && opts.additionalProperties !== true)
+        def["[string]"] = opts.additionalProperties;
+    const schema = applyMeta(type.raw(def), opts);
+    schema[OBJECT_INFO] = { props, additionalProperties: opts?.additionalProperties };
+    return schema;
+}
+function tRecord(key, value, opts) {
+    const base = type.raw({ "[string]": value }).narrow((record, ctx) => {
+        for (const name in record)
+            if (key(name) instanceof type.errors)
+                return ctx.mustBe("an object with valid record keys");
+        return true;
+    });
+    return applyMeta(base, opts);
+}
+function tOptional(schema, opts) {
+    const marker = applyMeta(schema.or(type.raw("undefined")), opts);
+    marker[OPTIONAL_INNER] = schema;
+    return marker;
+}
+function tNullable(schema, opts) {
+    return applyMeta(schema.or(type.raw("null")), opts);
+}
+function requireObject(schema, operation) {
+    const info = schema[OBJECT_INFO];
+    if (!info)
+        throw new OmpTypeError(`Type.${operation} requires a schema created by Type.Object`);
+    return info;
+}
+function tPartial(schema) {
+    const info = requireObject(schema, "Partial");
+    const props = {};
+    for (const key in info.props)
+        props[key] = info.props[key][OPTIONAL_INNER]
+            ? info.props[key]
+            : tOptional(info.props[key]);
+    return tObject(props, { additionalProperties: info.additionalProperties });
+}
+function tRequired(schema) {
+    const info = requireObject(schema, "Required");
+    const props = {};
+    for (const key in info.props) {
+        props[key] = info.props[key][OPTIONAL_INNER] ?? info.props[key];
+    }
+    return tObject(props, { additionalProperties: info.additionalProperties });
+}
+function tPick(schema, keys) {
+    const info = requireObject(schema, "Pick");
+    const props = {};
+    for (const key of keys)
+        if (typeof key === "string" && info.props[key])
+            props[key] = info.props[key];
+    return tObject(props, { additionalProperties: info.additionalProperties });
+}
+function tOmit(schema, keys) {
+    const info = requireObject(schema, "Omit");
+    const omitted = new Set(keys);
+    const props = {};
+    for (const key in info.props)
+        if (!omitted.has(key))
+            props[key] = info.props[key];
+    return tObject(props, { additionalProperties: info.additionalProperties });
+}
+function tComposite(schemas, opts) {
+    const props = {};
+    for (const schema of schemas)
+        Object.assign(props, requireObject(schema, "Composite").props);
+    return tObject(props, opts);
+}
+function tUnsafe(_jsonSchema = {}) {
+    // Raw JSON Schema is accepted for source compatibility but is not retained or validated:
+    // omptype cannot honestly implement that contract without importing a second validator.
+    return withLegacyCompat(type.unknown);
+}
+export const Type = {
+    String: tString,
+    Number: (opts) => tNumber(opts),
+    Integer: (opts) => tNumber(opts, true),
+    Boolean: (opts) => applyMeta(type.raw("boolean"), opts),
+    Null: (opts) => applyMeta(type.raw("null"), opts),
+    Any: (opts) => applyMeta(type.raw("unknown"), opts),
+    Unknown: (opts) => applyMeta(type.raw("unknown"), opts),
+    Never: tNever,
+    Literal: tLiteral,
+    Union: tUnion,
+    Intersect: tIntersect,
+    Enum: tEnum,
+    Array: tArray,
+    Tuple: tTuple,
+    Object: tObject,
+    Record: tRecord,
+    Optional: tOptional,
+    Nullable: tNullable,
+    Readonly: (schema) => withLegacyCompat(schema),
+    Partial: tPartial,
+    Required: tRequired,
+    Pick: tPick,
+    Omit: tOmit,
+    Composite: tComposite,
+    Unsafe: tUnsafe,
+};
+export default { Type };

package/dist/js/zod.js

@@ -0,0 +1,269 @@
+import { OmpTypeError } from "./errors.js";
+import { embed, IR_BRAND } from "./ir.js";
+import { type } from "./type.js";
+function schemaFromIR(ir) {
+    const embedded = {
+        [IR_BRAND]: true,
+        ir,
+        hasSteps: false,
+        hasDefault: false,
+        run: value => value,
+    };
+    return type.raw(embedded);
+}
+function restrictBase(source, ir) {
+    let next = source.hasSteps
+        ? schemaFromIR({ k: "morph", input: ir, fn: value => source(value) })
+        : schemaFromIR(ir);
+    if (source.description !== undefined)
+        next = next.describe(source.description);
+    if (source.hasDefault)
+        next = next.default(source.defaultValue);
+    return next;
+}
+function lengthBound(kind, schema, bound) {
+    if (schema.ir.k !== "string" && schema.ir.k !== "array")
+        return;
+    if (!Number.isSafeInteger(bound) || bound < 0) {
+        throw new OmpTypeError(`${kind} length must be a nonnegative safe integer`);
+    }
+}
+function refinementMessage(messageOrOptions) {
+    if (typeof messageOrOptions === "string")
+        return messageOrOptions;
+    return messageOrOptions?.message ?? messageOrOptions?.error ?? "valid (refinement failed)";
+}
+function isStringKeyIR(ir) {
+    switch (ir.k) {
+        case "string":
+            return true;
+        case "lit":
+            return typeof ir.v === "string";
+        case "union":
+            return ir.members.length > 0 && ir.members.every(isStringKeyIR);
+        case "sub":
+            return isStringKeyIR(ir.schema.ir);
+        default:
+            return false;
+    }
+}
+function decorate(schema, optional = false) {
+    const next = (inner, nextOptional = optional) => decorate(inner, nextOptional);
+    const withObjectExtras = (extras) => {
+        if (schema.ir.k !== "object")
+            throw new OmpTypeError("object mode requires an object schema");
+        return next(restrictBase(schema, { ...schema.ir, extras }));
+    };
+    Object.defineProperty(schema, "isOptional", { value: optional, enumerable: false });
+    return Object.assign(schema, {
+        parse(value) {
+            const result = schema(value);
+            if (result instanceof type.errors)
+                throw new Error(result.summary);
+            return result;
+        },
+        safeParse(value) {
+            const result = schema(value);
+            if (!(result instanceof type.errors))
+                return { success: true, data: result };
+            return {
+                success: false,
+                error: {
+                    message: result.summary,
+                    issues: result.map(issue => ({ path: [...issue.path], message: issue.problem })),
+                },
+            };
+        },
+        min(bound) {
+            const ir = schema.ir;
+            if (ir.k === "string" || ir.k === "array") {
+                lengthBound("min", schema, bound);
+                const min = ir.min === undefined ? bound : Math.max(ir.min, bound);
+                return next(restrictBase(schema, { ...ir, min }));
+            }
+            if (ir.k === "number") {
+                if (Number.isNaN(bound))
+                    throw new OmpTypeError("number min must not be NaN");
+                if (ir.min !== undefined && ir.min >= bound)
+                    return next(restrictBase(schema, ir));
+                return next(restrictBase(schema, { ...ir, min: bound, xmin: false }));
+            }
+            throw new OmpTypeError(`cannot apply min to ${ir.k}`);
+        },
+        max(bound) {
+            const ir = schema.ir;
+            if (ir.k === "string" || ir.k === "array") {
+                lengthBound("max", schema, bound);
+                const max = ir.max === undefined ? bound : Math.min(ir.max, bound);
+                return next(restrictBase(schema, { ...ir, max }));
+            }
+            if (ir.k === "number") {
+                if (Number.isNaN(bound))
+                    throw new OmpTypeError("number max must not be NaN");
+                if (ir.max !== undefined && ir.max <= bound)
+                    return next(restrictBase(schema, ir));
+                return next(restrictBase(schema, { ...ir, max: bound, xmax: false }));
+            }
+            throw new OmpTypeError(`cannot apply max to ${ir.k}`);
+        },
+        int() {
+            if (schema.ir.k !== "number")
+                throw new OmpTypeError(`cannot apply int to ${schema.ir.k}`);
+            return next(restrictBase(schema, { ...schema.ir, int: true }));
+        },
+        positive() {
+            if (schema.ir.k !== "number")
+                throw new OmpTypeError(`cannot apply positive to ${schema.ir.k}`);
+            const ir = schema.ir;
+            if (ir.min !== undefined && ir.min > 0)
+                return next(restrictBase(schema, ir));
+            return next(restrictBase(schema, { ...ir, min: 0, xmin: true }));
+        },
+        nonnegative() {
+            if (schema.ir.k !== "number")
+                throw new OmpTypeError(`cannot apply nonnegative to ${schema.ir.k}`);
+            return this.min(0);
+        },
+        regex(expression, message) {
+            if (schema.ir.k !== "string")
+                throw new OmpTypeError(`cannot apply regex to ${schema.ir.k}`);
+            const expectation = message ?? `matching ${expression}`;
+            const narrowed = schema.narrow((value, ctx) => {
+                expression.lastIndex = 0;
+                const matches = expression.test(value);
+                expression.lastIndex = 0;
+                return matches || ctx.mustBe(expectation);
+            });
+            return next(narrowed);
+        },
+        url() {
+            if (schema.ir.k !== "string")
+                throw new OmpTypeError(`cannot apply url to ${schema.ir.k}`);
+            return next(restrictBase(schema, { ...schema.ir, url: true }));
+        },
+        optional() {
+            const widened = schema.or(type.raw("undefined"));
+            return decorate(widened, true);
+        },
+        nullable() {
+            return decorate(schema.or(type.raw("null")), optional);
+        },
+        default(value) {
+            const widened = schema.or(type.raw("undefined"));
+            const piped = widened.pipe(output => {
+                if (output !== undefined)
+                    return output;
+                return typeof value === "function" ? value() : value;
+            });
+            return decorate(piped.default(value));
+        },
+        describe(description) {
+            return next(restrictBase(schema, { ...schema.ir, desc: description }).describe(description));
+        },
+        refine(predicate, messageOrOptions) {
+            const expectation = refinementMessage(messageOrOptions);
+            return next(schema.narrow((value, ctx) => Boolean(predicate(value)) || ctx.mustBe(expectation)));
+        },
+        transform(transformer) {
+            return decorate(schema.pipe(value => transformer(value)), optional);
+        },
+        catch(fallback) {
+            const caught = type.unknown.pipe(input => {
+                try {
+                    const result = schema(input);
+                    if (!(result instanceof type.errors))
+                        return result;
+                }
+                catch {
+                    // A caught schema is deliberately total, including user refinement/transform exceptions.
+                }
+                return typeof fallback === "function" ? fallback() : fallback;
+            });
+            return decorate(caught, optional);
+        },
+        strict() {
+            return withObjectExtras("reject");
+        },
+        passthrough() {
+            return withObjectExtras("keep");
+        },
+        strip() {
+            return withObjectExtras("delete");
+        },
+        partial() {
+            if (schema.ir.k !== "object")
+                throw new OmpTypeError(`cannot apply partial to ${schema.ir.k}`);
+            const props = schema.ir.props.map(prop => ({ ...prop, opt: true }));
+            return next(restrictBase(schema, { ...schema.ir, props }));
+        },
+    });
+}
+function decorateUnknown(schema) {
+    return decorate(schema);
+}
+function objectSchema(shape) {
+    const props = [];
+    for (const key in shape) {
+        const member = shape[key];
+        const prop = { key, opt: member.isOptional, val: embed(member) };
+        if (member.hasDefault) {
+            prop.hasDefault = true;
+            prop.def = member.defaultValue;
+            prop.defFactory = typeof member.defaultValue === "function";
+        }
+        props.push(prop);
+    }
+    return decorateUnknown(schemaFromIR({ k: "object", props, extras: "delete" }));
+}
+export const string = () => decorate(schemaFromIR(type.string.ir));
+export const number = () => decorate(schemaFromIR(type.number.ir));
+export const boolean = () => decorate(schemaFromIR(type.boolean.ir));
+export const literal = (value) => decorate(schemaFromIR(type.enumerated(value).ir));
+const enumSchema = (values) => {
+    if (values.length === 0)
+        throw new OmpTypeError("enum requires at least one value");
+    return decorate(schemaFromIR(type.enumerated(...values).ir));
+};
+export { enumSchema as enum };
+export const union = (schemas) => decorate(schemaFromIR({ k: "union", members: schemas.map(schema => embed(schema)) }));
+export const array = (element) => decorate(schemaFromIR({ k: "array", el: embed(element) }));
+export const object = (shape) => objectSchema(shape);
+export const record = (keySchema, valueSchema) => {
+    if (!isStringKeyIR(keySchema.ir))
+        throw new OmpTypeError("record keys must use a string schema");
+    const base = schemaFromIR({
+        k: "object",
+        props: [],
+        index: embed(valueSchema),
+        extras: "keep",
+    });
+    const checked = base.narrow((value, ctx) => {
+        for (const key in value) {
+            if (keySchema(key) instanceof type.errors)
+                return ctx.mustBe("a record with valid string keys");
+        }
+        return true;
+    });
+    return decorate(checked);
+};
+export const unknown = () => decorate(schemaFromIR(type.unknown.ir));
+export const any = () => decorate(schemaFromIR(type.unknown.ir));
+const nullSchema = () => decorate(type.raw("null"));
+const undefinedSchema = () => decorate(type.raw("undefined"));
+export { nullSchema as null, undefinedSchema as undefined };
+/** Runtime `z.*` facade, merged with the `z.infer` type namespace below. */
+export const z = {
+    string,
+    number,
+    boolean,
+    literal,
+    enum: enumSchema,
+    union,
+    array,
+    object,
+    record,
+    unknown,
+    any,
+    null: nullSchema,
+    undefined: undefinedSchema,
+};

package/dist/types/ark.d.ts

@@ -6,21 +6,13 @@
  * `from "@oh-my-pi/omptype/ark"` and nothing else changes. New code should
  * import `@oh-my-pi/omptype` directly.
  *
- * Compatibility affordances beyond the plain re-export:
- * - `ArkError` / `ArkErrors` alias `OmpError` / `OmpErrors`.
- * - `scope()` (alias-free form only) returns `{ type }`; the `jitless` flag is
- *   obsolete — omptype always starts interpreted and JIT-compiles lazily.
+ * Compatibility affordance: `ArkError` / `ArkErrors` alias `OmpError` /
+ * `OmpErrors`. All schema builders, including recursive `scope()`, are
+ * re-exported unchanged.
  */
 import { OmpError, OmpErrors } from "./errors.js";
-import { type } from "./type.js";
 export * from "./index.js";
 export declare const ArkError: typeof OmpError;
 export type ArkError = OmpError;
 export declare const ArkErrors: typeof OmpErrors;
 export type ArkErrors = OmpErrors;
-/** ArkType `scope()` shim: only the alias-free `scope({}, config?)` form is supported. */
-export declare function scope(aliases: Record<string, never>, _config?: {
-    jitless?: boolean;
-}): {
-    type: typeof type;
-};

package/dist/types/compile.d.ts

@@ -1,5 +1,7 @@
 import { type IR } from "./ir.js";
 /** Compile `ir` into a specialized validator. */
 export declare function compile(ir: IR): (value: unknown) => unknown;
+/** Compile `ir` into an allocation-free boolean validator. */
+export declare function compileAllows(ir: IR): (value: unknown) => boolean;
 /** Generated source for inspection/debugging. */
 export declare function compileToSource(ir: IR): string;