pema 0.11.0 → 0.12.1

package/lib/private/ArrayType.js

@@ -1,3 +1,4 @@
+import cardinality from "#cardinality";
 import DefaultType from "#DefaultType";
 import EnumType from "#EnumType";
 import E from "#errors";
@@ -60,16 +61,15 @@ export default class ArrayType extends GenericType {
         return this.with({ validators: [uniqueBy(select)] });
     }
     min(limit) {
-        if (limit < 0)
-            throw S.min_negative(limit);
+        cardinality.min(limit);
         return this.with({ validators: [min(limit)] });
     }
     max(limit) {
-        if (limit < 0)
-            throw S.max_negative(limit);
+        cardinality.max(limit);
         return this.with({ validators: [max(limit)] });
     }
     length(from, to) {
+        cardinality.length(from, to);
         return this.with({ validators: [length(from, to)] });
     }
     parse(u, options = {}) {

package/lib/private/BooleanType.d.ts

@@ -8,7 +8,7 @@ export default class BooleanType<M extends Mode = undefined> extends PrimitiveTy
     constructor(mode?: M);
     get name(): "boolean";
     get datatype(): "boolean";
-    [CoerceKey](x: unknown): unknown;
+    [CoerceKey](x: unknown): boolean;
     toJSON(): {
         type: "boolean";
         datatype: "boolean";

package/lib/private/DateType.d.ts

@@ -10,6 +10,7 @@ export default class DateType<M extends boolean | undefined = undefined> extends
     get Type(): DateConstructor;
     get name(): "date";
     get datatype(): "datetime";
+    now(): import("./DefaultType.js").default<this, Date>;
     toJSON(): {
         type: "date";
         datatype: "datetime";

package/lib/private/DateType.js

@@ -19,6 +19,9 @@ export default class DateType extends BuiltinType {
     get datatype() {
         return "datetime";
     }
+    now() {
+        return this.default(() => new Date());
+    }
     toJSON() {
         return Storable.serialize(this);
     }

package/lib/private/IssueType.d.ts

@@ -1,3 +1,3 @@
-type IssueType = "invalid_type" | "invalid_format" | "too_small" | "too_large" | "out_of_range" | "not_in_set" | "duplicate" | "network_error";
+type IssueType = "invalid_type" | "invalid_format" | "too_small" | "too_large" | "out_of_range" | "not_in_set" | "duplicate" | "unknown_property" | "network_error";
 export type { IssueType as default };
 //# sourceMappingURL=IssueType.d.ts.map

package/lib/private/JSONType.d.ts

@@ -8,12 +8,13 @@ import Storable from "#Storable";
 import type { JSONValue } from "@rcompat/type";
 export type ParsedJSON = Parsed<JSONValue>;
 type JSONInput = ParsedJSON | undefined;
-type JSONInfer<S extends JSONInput> = S extends ParsedJSON ? Infer<S> : JSONValue;
-export default class JSONType<S extends JSONInput = undefined> extends Storable<"json", JSONInfer<S>> {
+type JSONInfer<S extends JSONInput, D extends boolean> = D extends true ? Record<string, JSONValue> : S extends ParsedJSON ? Infer<S> : JSONValue;
+export default class JSONType<S extends JSONInput = undefined, D extends boolean = false> extends Storable<"json", JSONInfer<S, D>> {
     #private;
-    constructor(inner?: S);
+    constructor(inner?: S, dictionary?: D);
     get name(): "json";
     get datatype(): "json";
+    dict(this: JSONType<undefined, false>): JSONType<undefined, true>;
     optional(): OptionalType<this>;
     default(value: (() => Infer<this>) | Infer<this>): DefaultType<this, Infer<this>>;
     parse(u: unknown, options?: ParseOptions): Infer<this>;
@@ -21,6 +22,7 @@ export default class JSONType<S extends JSONInput = undefined> extends Storable<
         type: "json";
         datatype: "json";
         of?: Serialized;
+        dictionary?: true;
     };
 }
 export {};

package/lib/private/JSONType.js

@@ -4,19 +4,36 @@ import OptionalType from "#OptionalType";
 import resolve from "#resolve";
 import Storable from "#Storable";
 import is from "@rcompat/is";
-function json_with_undefined_object_values(x) {
-    if (is.array(x))
-        return x.every(json_with_undefined_object_values);
-    if (is.dict(x)) {
-        return Object.values(x).every(value => is.undefined(value) || json_with_undefined_object_values(value));
+function json_with_undefined_object_values(x, ancestors = new Set()) {
+    if (!is.array(x) && !is.dict(x))
+        return is.json(x);
+    if (ancestors.has(x))
+        return false;
+    ancestors.add(x);
+    let valid = true;
+    if (is.array(x)) {
+        for (let index = 0; index < x.length; index++) {
+            if (!Object.hasOwn(x, index)
+                || !json_with_undefined_object_values(x[index], ancestors)) {
+                valid = false;
+                break;
+            }
+        }
+    }
+    else {
+        valid = Object.values(x).every(value => is.undefined(value)
+            || json_with_undefined_object_values(value, ancestors));
     }
-    return is.json(x);
+    ancestors.delete(x);
+    return valid;
 }
 export default class JSONType extends Storable {
     #inner;
-    constructor(inner) {
+    #dictionary;
+    constructor(inner, dictionary = false) {
         super();
         this.#inner = inner;
+        this.#dictionary = dictionary;
     }
     get name() {
         return "json";
@@ -24,6 +41,9 @@ export default class JSONType extends Storable {
     get datatype() {
         return "json";
     }
+    dict() {
+        return new JSONType(undefined, true);
+    }
     optional() {
         return new OptionalType(this);
     }
@@ -32,6 +52,9 @@ export default class JSONType extends Storable {
     }
     parse(u, options = {}) {
         const x = resolve(u);
+        if (this.#dictionary && !is.dict(x)) {
+            throw E.invalid_type(x, "dictionary", options);
+        }
         // delegate to inner schema for typed validation
         if (is.defined(this.#inner))
             return this.#inner.parse(x, options);
@@ -45,6 +68,7 @@ export default class JSONType extends Storable {
             type: "json",
             datatype: "json",
             ...is.defined(this.#inner) && { of: this.#inner.toJSON() },
+            ...this.#dictionary && { dictionary: true },
         };
     }
 }

package/lib/private/ObjectPolicy.d.ts

@@ -0,0 +1,6 @@
+type ObjectPolicy = {
+    closed?: boolean;
+    minimum?: number;
+};
+export type { ObjectPolicy as default };
+//# sourceMappingURL=ObjectPolicy.d.ts.map

package/lib/private/ObjectPolicy.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ObjectPolicy.js.map

package/lib/private/ObjectType.d.ts

@@ -4,6 +4,7 @@ import type InferInputSchema from "#InferInputSchema";
 import Loose from "#Loose";
 import type Mode from "#Mode";
 import OptionalType from "#OptionalType";
+import type ObjectPolicy from "#ObjectPolicy";
 import type Parsed from "#Parsed";
 import type ParseOptions from "#ParseOptions";
 import type Serialized from "#Serialized";
@@ -16,11 +17,13 @@ export default class ObjectType<P extends Dict<Parsed<unknown>> = Dict<Parsed<un
     #private;
     [Loose]: M;
     readonly Complement: ObjectType<Record<Exclude<string, keyof P>, Parsed<unknown>>>;
-    constructor(properties: P, mode?: M, options?: ParseOptions);
+    constructor(properties: P, mode?: M, options?: ParseOptions, policy?: ObjectPolicy);
     get name(): string;
     get properties(): P;
     get input(): InferInputSchema<P>;
     optional(): OptionalType<this>;
+    closed(): ObjectType<P, M, I>;
+    min(limit: number): ObjectType<P, M, I>;
     shape<T>(): ObjectType<P, M, T>;
     extend<E extends {
         [K in keyof E]: K extends keyof P ? never : Parsed<unknown>;

package/lib/private/ObjectType.js

@@ -1,7 +1,9 @@
+import cardinality from "#cardinality";
 import E from "#errors";
 import GenericType from "#GenericType";
 import Loose from "#Loose";
 import OptionalType from "#OptionalType";
+import ParsedKey from "#ParsedKey";
 import next from "#path/next";
 import resolve from "#resolve";
 import SE from "#schema-errors";
@@ -9,12 +11,14 @@ import is from "@rcompat/is";
 export default class ObjectType extends GenericType {
     #properties;
     #options;
+    #policy;
     [Loose];
-    constructor(properties, mode, options = {}) {
+    constructor(properties, mode, options = {}, policy = {}) {
         super();
         this.#properties = properties;
         this[Loose] = mode;
         this.#options = options;
+        this.#policy = policy;
     }
     get name() {
         const props = Object.entries(this.#properties)
@@ -30,17 +34,22 @@ export default class ObjectType extends GenericType {
     }
     #derive(options) {
         const Constructor = this.constructor;
-        const instance = new Constructor(this.#properties, this[Loose], {
-            ...this.#options, ...options,
-        });
+        const instance = new Constructor(this.#properties, this[Loose], { ...this.#options, ...options }, this.#policy);
         instance[Loose] = this[Loose];
         return instance;
     }
     optional() {
         return new OptionalType(this);
     }
+    closed() {
+        return new ObjectType(this.#properties, this[Loose], this.#options, { ...this.#policy, closed: true });
+    }
+    min(limit) {
+        cardinality.min(limit);
+        return new ObjectType(this.#properties, this[Loose], this.#options, { ...this.#policy, minimum: limit });
+    }
     shape() {
-        return new ObjectType(this.#properties, this[Loose], this.#options);
+        return new ObjectType(this.#properties, this[Loose], this.#options, this.#policy);
     }
     extend(extra) {
         const properties = extra instanceof ObjectType ? extra.properties : extra;
@@ -48,22 +57,39 @@ export default class ObjectType extends GenericType {
             if (key in this.#properties)
                 throw SE.extend_key_collision(key);
         }
-        return new ObjectType({ ...this.#properties, ...properties }, this[Loose], this.#options);
+        return new ObjectType({ ...this.#properties, ...properties }, this[Loose], this.#options, this.#policy);
     }
     parse(u, options = {}) {
         const x = resolve(u);
         const $options = is.defined(this[Loose])
             ? { ...this.#options, ...options, [Loose]: this[Loose] }
             : { ...this.#options, ...options };
-        if (is.defined(x) && !is.dict(x))
+        if (is.defined(x) && !is.dict(x)) {
             throw E.invalid_type(x, "object", $options);
+        }
         const input = x ?? {};
         const out = {};
-        for (const k in this.#properties) {
+        if (this.#policy.closed === true) {
+            for (const key of Object.keys(input)) {
+                if (!Object.hasOwn(this.#properties, key)) {
+                    throw E.unknown_property(input[key], next(key, $options));
+                }
+            }
+        }
+        let count = 0;
+        for (const k of Object.keys(this.#properties)) {
             const parsed = this.#properties[k].parse(input[k], next(k, $options));
+            if (Object.prototype.propertyIsEnumerable.call(input, k) &&
+                is.defined(input[k])) {
+                count++;
+            }
             if (is.defined(parsed))
                 out[k] = parsed;
         }
+        const minimum = this.#policy.minimum;
+        if (is.defined(minimum) && count < minimum) {
+            throw E.too_small(input, `min ${minimum} properties`, $options[ParsedKey] ?? "");
+        }
         return out;
     }
     toJSON() {

package/lib/private/PartialType.d.ts

@@ -2,6 +2,7 @@ import DefaultType from "#DefaultType";
 import type Infer from "#Infer";
 import Loose from "#Loose";
 import type Mode from "#Mode";
+import type ObjectPolicy from "#ObjectPolicy";
 import type ParseOptions from "#ParseOptions";
 import type Partialable from "#Partialable";
 import type DefaultTrait from "#trait/Default";
@@ -12,10 +13,12 @@ type InferPartial<D extends Partialable> = {
 export default class PartialType<D extends Partialable, M extends Mode = undefined> extends VirtualType<D, InferPartial<D>, "PartialType"> implements DefaultTrait<InferPartial<D>> {
     #private;
     [Loose]: M;
-    constructor(spec: D, mode?: M);
+    constructor(spec: D, mode?: M, policy?: ObjectPolicy);
     get name(): "partial";
     get schema(): D;
     default(value: (() => InferPartial<D>) | InferPartial<D>): DefaultType<this, InferPartial<D>>;
+    closed(): PartialType<D, M>;
+    min(limit: number): PartialType<D, M>;
     parse(u: unknown, options?: ParseOptions): InferPartial<D>;
     toJSON(): {
         type: "partial";

package/lib/private/PartialType.js

@@ -1,3 +1,4 @@
+import cardinality from "#cardinality";
 import DefaultType from "#DefaultType";
 import E from "#errors";
 import Loose from "#Loose";
@@ -10,11 +11,13 @@ import VirtualType from "#VirtualType";
 import is from "@rcompat/is";
 export default class PartialType extends VirtualType {
     #spec;
+    #policy;
     [Loose];
-    constructor(spec, mode) {
+    constructor(spec, mode, policy = {}) {
         super();
         this.#spec = spec;
         this[Loose] = mode;
+        this.#policy = policy;
     }
     get name() {
         return "partial";
@@ -25,6 +28,13 @@ export default class PartialType extends VirtualType {
     default(value) {
         return new DefaultType(this, value);
     }
+    closed() {
+        return new PartialType(this.#spec, this[Loose], { ...this.#policy, closed: true });
+    }
+    min(limit) {
+        cardinality.min(limit);
+        return new PartialType(this.#spec, this[Loose], { ...this.#policy, minimum: limit });
+    }
     parse(u, options = {}) {
         const x = resolve(u);
         if (!is.dict(x))
@@ -32,12 +42,22 @@ export default class PartialType extends VirtualType {
         const input = x;
         const out = {};
         const issues = [];
+        if (this.#policy.closed === true) {
+            for (const key of Object.keys(input)) {
+                if (!Object.hasOwn(this.#spec, key)) {
+                    throw E.unknown_property(input[key], next(key, options));
+                }
+            }
+        }
+        let count = 0;
         for (const key of Object.keys(this.#spec)) {
             // skip missing/undefined keys (partial semantics)
-            if (!(key in input) || is.undefined(input[key]))
+            if (!Object.prototype.propertyIsEnumerable.call(input, key) ||
+                is.undefined(input[key]))
                 continue;
             try {
                 const parsed = this.#spec[key].parse(input[key], next(key, options));
+                count++;
                 if (is.defined(parsed))
                     out[key] = parsed;
             }
@@ -49,7 +69,7 @@ export default class PartialType extends VirtualType {
                 }
                 else {
                     // wrap non-ParseError into a properly-pathed issue at /<key>
-                    const message = e && typeof e.message === "string"
+                    const message = e && is.string(e.message)
                         ? e.message
                         : String(e);
                     issues.push({
@@ -63,6 +83,10 @@ export default class PartialType extends VirtualType {
         }
         if (issues.length > 0)
             throw new ParseError(issues);
+        const minimum = this.#policy.minimum;
+        if (is.defined(minimum) && count < minimum) {
+            throw E.too_small(input, `min ${minimum} properties`, options[ParsedKey] ?? "");
+        }
         return out;
     }
     toJSON() {

package/lib/private/PrimitiveType.js

@@ -46,6 +46,7 @@ export default class PrimitiveType extends Type {
             : this.#validators;
         const loose = this[Loose] ?? $options[Loose] ?? false;
         const $x = loose ? this[CoerceKey](x) : x;
+        // eslint-disable-next-line no-restricted-syntax -- expected type is dynamic
         if (typeof $x !== this.name)
             throw E.invalid_type($x, this.name, $options);
         const base = $options[ParsedKey] ?? "";
@@ -65,7 +66,7 @@ export default class PrimitiveType extends Type {
                     throw new ParseError(rebased);
                 }
                 // not a ParseError - wrap with proper path
-                const message = e && typeof e.message === "string"
+                const message = e && is.string(e.message)
                     ? e.message
                     : String(e);
                 throw E.invalid_type(x, message, base);

package/lib/private/Serialized.d.ts

@@ -73,6 +73,7 @@ type StructuralSerialized = {
     type: "json";
     datatype: "json";
     of?: Serialized;
+    dictionary?: true;
 } | {
     type: "omit";
     properties: Dict<Serialized>;

package/lib/private/StringType.js

@@ -1,11 +1,11 @@
 import CoerceKey from "#CoerceKey";
+import cardinality from "#cardinality";
 import E from "#errors";
 import Loose from "#Loose";
 import ParsedKey from "#ParsedKey";
 import ParseError from "#ParseError";
 import PrimitiveType from "#PrimitiveType";
 import resolve from "#resolve";
-import S from "#schema-errors";
 import Storable from "#Storable";
 import email from "#validator/email";
 import ends_with from "#validator/ends-with";
@@ -39,6 +39,7 @@ export default class StringType extends PrimitiveType {
             : options;
         const loose = this[Loose] ?? $options[Loose] ?? false;
         const $x = loose ? this[CoerceKey](x) : x;
+        // eslint-disable-next-line no-restricted-syntax -- expected type is dynamic
         if (typeof $x !== this.name)
             throw E.invalid_type($x, this.name, $options);
         let value = $x;
@@ -97,16 +98,15 @@ export default class StringType extends PrimitiveType {
         return this.with({ validators: [ends_with(suffix, options)] });
     }
     min(limit, options) {
-        if (limit < 0)
-            throw S.min_negative(limit);
+        cardinality.min(limit);
         return this.with({ validators: [min(limit, options)] });
     }
     max(limit, options) {
-        if (limit < 0)
-            throw S.max_negative(limit);
+        cardinality.max(limit);
         return this.with({ validators: [max(limit, options)] });
     }
     length(from, to, options) {
+        cardinality.length(from, to);
         return this.with({ validators: [length(from, to, options)] });
     }
     toJSON() {

package/lib/private/cardinality.d.ts

@@ -0,0 +1,10 @@
+declare function min(limit: number): void;
+declare function max(limit: number): void;
+declare function length(from: number, to: number): void;
+declare const cardinality: {
+    length: typeof length;
+    max: typeof max;
+    min: typeof min;
+};
+export default cardinality;
+//# sourceMappingURL=cardinality.d.ts.map

package/lib/private/cardinality.js

@@ -0,0 +1,32 @@
+import S from "#schema-errors";
+import is from "@rcompat/is";
+function min(limit) {
+    if (!is.finite(limit))
+        throw S.min_limit_not_finite(limit);
+    if (limit < 0)
+        throw S.min_negative(limit);
+    if (!is.int(limit))
+        throw S.min_limit_not_integer(limit);
+}
+function max(limit) {
+    if (!is.finite(limit))
+        throw S.max_limit_not_finite(limit);
+    if (limit < 0)
+        throw S.max_negative(limit);
+    if (!is.int(limit))
+        throw S.max_limit_not_integer(limit);
+}
+function length(from, to) {
+    if (!is.finite(from) || !is.finite(to)) {
+        throw S.length_not_finite(from, to);
+    }
+    if (from < 0 || to < 0)
+        throw S.length_not_positive(from, to);
+    if (!is.int(from) || !is.int(to))
+        throw S.length_not_integer(from, to);
+    if (from > to)
+        throw S.length_from_exceeds_to(from, to);
+}
+const cardinality = { length, max, min };
+export default cardinality;
+//# sourceMappingURL=cardinality.js.map

package/lib/private/coerce/date.js

@@ -9,7 +9,7 @@ function epoch(n, digits) {
     // for numbers we always treat as ms (no digits provided)
     const ms = is.defined(digits) ? (digits >= 13 ? n : n * 1000) : n;
     const date = new Date(ms);
-    return Number.isNaN(date.getTime()) ? undefined : date;
+    return is.nan(date.getTime()) ? undefined : date;
 }
 function fromNumber(n) {
     const date = epoch(n);
@@ -29,18 +29,18 @@ function fromString(raw) {
     // ISO date-only -> interpret as UTC midnight
     if (ISO_DATE.test(s)) {
         const date = new Date(`${s}T00:00:00.000Z`);
-        return Number.isNaN(date.getTime()) ? raw : date;
+        return is.nan(date.getTime()) ? raw : date;
     }
     // ISO datetime *with* timezone
     if (ISO_DATETIME_TZ.test(s)) {
         const date = new Date(s);
-        return Number.isNaN(date.getTime()) ? raw : date;
+        return is.nan(date.getTime()) ? raw : date;
     }
     return raw;
 }
 export default function coerceDate(x) {
     // already a Date
-    if (x instanceof Date)
+    if (is.date(x))
         return x;
     // numbers are treated as epochs
     if (is.finite(x))

package/lib/private/errors.d.ts

@@ -8,6 +8,7 @@ declare function too_large(input: unknown, message: string, path?: JSONPointer):
 declare function out_of_range(input: unknown, message: string, path?: JSONPointer): ParseError;
 declare function duplicate(input: unknown, message: string, path?: JSONPointer): ParseError;
 declare function not_in_set(input: unknown, message: string, path?: JSONPointer): ParseError;
+declare function unknown_property(input: unknown, options: ParseOptions): ParseError;
 declare function field(path: string, message: string): ParseError;
 declare const _default: {
     invalid_type: typeof invalid_type;
@@ -17,6 +18,7 @@ declare const _default: {
     out_of_range: typeof out_of_range;
     duplicate: typeof duplicate;
     not_in_set: typeof not_in_set;
+    unknown_property: typeof unknown_property;
     field: typeof field;
 };
 export default _default;

package/lib/private/errors.js

@@ -40,6 +40,14 @@ function duplicate(input, message, path = "") {
 function not_in_set(input, message, path = "") {
     return new ParseError([{ type: "not_in_set", input, message, path }]);
 }
+function unknown_property(input, options) {
+    return new ParseError([{
+            type: "unknown_property",
+            input,
+            message: "unknown property",
+            path: options[ParsedKey] ?? "",
+        }]);
+}
 function field(path, message) {
     return new ParseError([{
             type: "invalid_format",
@@ -56,6 +64,7 @@ export default {
     out_of_range,
     duplicate,
     not_in_set,
+    unknown_property,
     field,
 };
 //# sourceMappingURL=errors.js.map

package/lib/private/index.d.ts

@@ -43,6 +43,7 @@ export type { default as UUIDV4Type } from "#UUIDV4Type";
 export type { default as UUIDV7Type } from "#UUIDV7Type";
 import async_schema from "#async";
 import type NormalizeSchema from "#NormalizeSchema";
+import parseable from "#parseable";
 import type Schema from "#Schema";
 /**
 * Create a schema.
@@ -146,6 +147,7 @@ declare namespace schema {
     export var _18: import("#UUIDType").default;
     export { _18 as uuid };
     export var error: (path: string, message: string) => import("./ParseError.js").default;
+    export { parseable };
     export { loose };
     export { strict };
 }

package/lib/private/index.js

@@ -29,6 +29,7 @@ import number from "#number";
 import object from "#object";
 import omit from "#omit";
 import partial from "#partial";
+import parseable from "#parseable";
 import pure from "#pure";
 import record from "#record";
 import string from "#string";
@@ -194,6 +195,7 @@ schema.unknown = unknown.vanilla;
 schema.url = url.vanilla;
 schema.uuid = uuid.vanilla;
 schema.error = E.field;
+schema.parseable = parseable;
 schema.loose = loose;
 schema.strict = strict;
 export default schema;

package/lib/private/normalize.js

@@ -19,7 +19,7 @@ export default function normalize(x) {
     if (is.newable(x)) {
         return new ConstructorType(x);
     }
-    if (Array.isArray(x)) {
+    if (is.array(x)) {
         const schemas = x;
         return schemas.length === 1
             ? new ArrayType(normalize(schemas[0]))

package/lib/private/parseable.d.ts

@@ -0,0 +1,3 @@
+declare const parseable: unique symbol;
+export default parseable;
+//# sourceMappingURL=parseable.d.ts.map

package/lib/private/parseable.js

@@ -0,0 +1,3 @@
+const parseable = Symbol.for("pema:parseable");
+export default parseable;
+//# sourceMappingURL=parseable.js.map

package/lib/private/resolve.js

@@ -1,7 +1,8 @@
+import parseable from "#parseable";
 import is from "@rcompat/is";
-import symbol from "@rcompat/symbol";
-const { parse } = symbol;
 export default function resolve(x) {
-    return is.object(x) && parse in x ? x[parse]() : x;
+    return is.object(x) && parseable in x
+        ? x[parseable]()
+        : x;
 }
 //# sourceMappingURL=resolve.js.map

package/lib/private/schema-errors.d.ts

@@ -1,15 +1,18 @@
 declare const errors: {
-    unique_subtype_not_primitive: (subtype: string) => import("@rcompat/error").TemplateError;
-    min_negative: (limit: number) => import("@rcompat/error").TemplateError;
-    max_negative: (limit: number) => import("@rcompat/error").TemplateError;
-    length_not_finite: (from: number, to: number) => import("@rcompat/error").TemplateError;
-    length_not_positive: (from: number, to: number) => import("@rcompat/error").TemplateError;
-    length_from_exceeds_to: (from: number, to: number) => import("@rcompat/error").TemplateError;
-    min_limit_not_finite: (limit: number) => import("@rcompat/error").TemplateError;
-    max_limit_not_finite: (limit: number) => import("@rcompat/error").TemplateError;
-    extend_key_collision: (key: string) => import("@rcompat/error").TemplateError;
-    union_at_least_two_members: () => import("@rcompat/error").TemplateError;
-    enum_invalid_key: (key: string) => import("@rcompat/error").TemplateError;
+    unique_subtype_not_primitive: (subtype: string) => import("@rcompat/error").CodeError<"unique_subtype_not_primitive">;
+    min_negative: (limit: number) => import("@rcompat/error").CodeError<"min_negative">;
+    max_negative: (limit: number) => import("@rcompat/error").CodeError<"max_negative">;
+    length_not_finite: (from: number, to: number) => import("@rcompat/error").CodeError<"length_not_finite">;
+    length_not_positive: (from: number, to: number) => import("@rcompat/error").CodeError<"length_not_positive">;
+    length_not_integer: (from: number, to: number) => import("@rcompat/error").CodeError<"length_not_integer">;
+    length_from_exceeds_to: (from: number, to: number) => import("@rcompat/error").CodeError<"length_from_exceeds_to">;
+    min_limit_not_finite: (limit: number) => import("@rcompat/error").CodeError<"min_limit_not_finite">;
+    min_limit_not_integer: (limit: number) => import("@rcompat/error").CodeError<"min_limit_not_integer">;
+    max_limit_not_finite: (limit: number) => import("@rcompat/error").CodeError<"max_limit_not_finite">;
+    max_limit_not_integer: (limit: number) => import("@rcompat/error").CodeError<"max_limit_not_integer">;
+    extend_key_collision: (key: string) => import("@rcompat/error").CodeError<"extend_key_collision">;
+    union_at_least_two_members: () => import("@rcompat/error").CodeError<"union_at_least_two_members">;
+    enum_invalid_key: (key: string) => import("@rcompat/error").CodeError<"enum_invalid_key">;
 };
 export type Code = keyof typeof errors;
 export declare const Code: { [K in Code]: K; };

package/lib/private/schema-errors.js

@@ -2,13 +2,16 @@ import error from "@rcompat/error";
 const t = error.template;
 const errors = error.coded({
     unique_subtype_not_primitive: (subtype) => t `unique: subtype ${subtype} must be primitive`,
-    min_negative: (limit) => t `min: ${limit} must be positive`,
-    max_negative: (limit) => t `max: ${limit} must be positive`,
+    min_negative: (limit) => t `min: ${limit} must be nonnegative`,
+    max_negative: (limit) => t `max: ${limit} must be nonnegative`,
     length_not_finite: (from, to) => t `length: ${from} and ${to} must be finite numbers`,
-    length_not_positive: (from, to) => t `length: ${from} and ${to} must be positive`,
-    length_from_exceeds_to: (from, to) => t `length: ${from} must be lower than ${to}`,
+    length_not_positive: (from, to) => t `length: ${from} and ${to} must be nonnegative`,
+    length_not_integer: (from, to) => t `length: ${from} and ${to} must be integers`,
+    length_from_exceeds_to: (from, to) => t `length: ${from} must not exceed ${to}`,
     min_limit_not_finite: (limit) => t `min: limit ${limit} must be a finite number`,
+    min_limit_not_integer: (limit) => t `min: limit ${limit} must be an integer`,
     max_limit_not_finite: (limit) => t `max: limit ${limit} must be a finite number`,
+    max_limit_not_integer: (limit) => t `max: limit ${limit} must be an integer`,
     extend_key_collision: (key) => t `extend: key ${key} already exists and cannot be overridden`,
     union_at_least_two_members: () => t `union type must have at least two members`,
     enum_invalid_key: (key) => t `enum: key ${key} must be SCREAMING_SNAKE_CASE`,

package/lib/private/test.d.ts

@@ -9,7 +9,7 @@ type IssueMatcher = {
 type Shortcuts = {
     [K in IssueType]: (inputs: unknown[], path?: JSONPointer) => void;
 };
-declare const _default: import("@rcompat/test/index").ExtendedTest<{
+declare const _default: import("@rcompat/test").ExtendedTest<{
     parse_issue: (type: IssueType, inputs: Input[]) => void;
     parse_issues(input: unknown, matchers: IssueMatcher[]): void;
 } & Shortcuts>;

package/lib/private/test.js

@@ -9,6 +9,7 @@ const issue_types = [
     "out_of_range",
     "not_in_set",
     "duplicate",
+    "unknown_property",
 ];
 export default test.extend((assert, subject) => {
     const parse_issue = (type, inputs) => {

package/lib/private/validator/length.js

@@ -1,14 +1,7 @@
 import E from "#errors";
-import S from "#schema-errors";
 import message from "#validator/message";
 import is from "@rcompat/is";
 export default function length(from, to, options) {
-    if (!is.finite(from) || !is.finite(to))
-        throw S.length_not_finite(from, to);
-    if (from < 0 || to < 0)
-        throw S.length_not_positive(from, to);
-    if (from > to)
-        throw S.length_from_exceeds_to(from, to);
     const format = message(options, () => "length out of range");
     return (x) => {
         if (!is.string(x) && !is.array(x)) {

package/lib/private/validator/message.js

@@ -1,6 +1,9 @@
 import is from "@rcompat/is";
 export default function message(options, fallback) {
     const option = is.dict(options) ? options.message : options;
+    // Preserve the generic callback signature; is.function narrows to
+    // UnknownFunction and loses the string return type.
+    // eslint-disable-next-line no-restricted-syntax
     return (value) => typeof option === "function"
         ? option(value)
         : option ?? fallback(value);

package/package.json

@@ -1,36 +1,14 @@
 {
-  "name": "pema",
-  "version": "0.11.0",
-  "description": "Primate schema validation",
-  "homepage": "https://primate.run/docs/validation",
   "bugs": "https://github.com/primate-run/primate/issues",
-  "type": "module",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/primate-run/primate",
-    "directory": "packages/pema"
-  },
-  "files": [
-    "/lib/**/*.js",
-    "/lib/**/*.d.ts",
-    "!/**/*.spec.*"
-  ],
   "dependencies": {
-    "@rcompat/assert": "^0.14.0",
-    "@rcompat/cli": "^0.25.1",
-    "@rcompat/error": "^0.9.0",
-    "@rcompat/is": "^0.12.2",
-    "@rcompat/symbol": "^0.3.0"
+    "@rcompat/assert": "^0.16.0",
+    "@rcompat/cli": "^0.28.0",
+    "@rcompat/error": "^0.11.0",
+    "@rcompat/is": "^0.14.0"
   },
+  "description": "Primate schema validation",
   "devDependencies": {
-    "@rcompat/type": "^0.18.0"
-  },
-  "imports": {
-    "#*": {
-      "@primate/source": "./src/private/*.ts",
-      "default": "./lib/private/*.js"
-    }
+    "@rcompat/type": "^0.19.0"
   },
   "exports": {
     ".": {
@@ -42,11 +20,33 @@
       "default": "./lib/public/*.js"
     }
   },
+  "files": [
+    "/lib/**/*.js",
+    "/lib/**/*.d.ts",
+    "!/**/*.spec.*"
+  ],
+  "homepage": "https://primate.run/docs/pema",
+  "imports": {
+    "#*": {
+      "@primate/source": "./src/private/*.ts",
+      "default": "./lib/private/*.js"
+    }
+  },
+  "license": "MIT",
+  "name": "pema",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/primate-run/primate",
+    "directory": "packages/pema"
+  },
   "scripts": {
-    "build": "pnpm run clean && tsc",
+    "build": "flog run clean && tsc",
     "clean": "rm -rf ./lib",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "test": "npx proby"
-  }
-}
+    "prepublishOnly": "flog run build",
+    "test": "proby"
+  },
+  "type": "module",
+  "version": "0.12.1"
+}