@astrale-os/kernel-dsl 1.0.0-beta.2 → 1.0.0-beta.20

package/dist/v1/language/value/inclusion/keywords.d.ts

@@ -0,0 +1,5 @@
+import type { JsonSchema } from '../model/schema.js';
+/** Keywords the evaluator never asserts. */
+export declare const INERT: ReadonlySet<string>;
+/** Whether a schema asserts nothing. */
+export declare function isTop(schema: JsonSchema): boolean;

package/dist/v1/language/value/inclusion/keywords.js

@@ -0,0 +1,31 @@
+/** Keywords the evaluator never asserts. */
+export const INERT = new Set([
+    '$anchor',
+    '$comment',
+    '$defs',
+    '$id',
+    '$schema',
+    'contentEncoding',
+    'contentMediaType',
+    'contentSchema',
+    'default',
+    'deprecated',
+    'description',
+    'examples',
+    'format',
+    'readOnly',
+    'title',
+    'writeOnly',
+    'x-astrale-path',
+]);
+/** Whether a schema asserts nothing. */
+export function isTop(schema) {
+    if (schema === true)
+        return true;
+    if (schema === false)
+        return false;
+    return Object.keys(schema).every((keyword) => INERT.has(keyword) ||
+        ((keyword === 'then' || keyword === 'else') && !Object.hasOwn(schema, 'if')) ||
+        ((keyword === 'minContains' || keyword === 'maxContains') &&
+            !Object.hasOwn(schema, 'contains')));
+}

package/dist/v1/language/value/inclusion/kinds.d.ts

@@ -0,0 +1,17 @@
+import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+/** Bit masks over the JSON kinds a schema may admit; integers and fractions split `number`. */
+export declare const NULL = 1;
+export declare const BOOLEAN = 2;
+export declare const OBJECT = 4;
+export declare const ARRAY = 8;
+export declare const STRING = 16;
+export declare const INTEGER = 32;
+export declare const FRACTION = 64;
+export declare const NUMBER: number;
+export declare const ANY: number;
+/** The kinds a `type` keyword value admits; an absent `type` admits every kind. */
+export declare function typeMask(type: JsonValue | undefined): number;
+/** The single kind of one JSON value. */
+export declare function kindOf(value: JsonValue): number;
+/** The finite value set of a kind mask made only of null and booleans. */
+export declare function finiteKinds(kinds: number): readonly JsonValue[] | undefined;

package/dist/v1/language/value/inclusion/kinds.js

@@ -0,0 +1,57 @@
+/** Bit masks over the JSON kinds a schema may admit; integers and fractions split `number`. */
+export const NULL = 1;
+export const BOOLEAN = 2;
+export const OBJECT = 4;
+export const ARRAY = 8;
+export const STRING = 16;
+export const INTEGER = 32;
+export const FRACTION = 64;
+export const NUMBER = INTEGER | FRACTION;
+export const ANY = NULL | BOOLEAN | OBJECT | ARRAY | STRING | NUMBER;
+/** The kinds a `type` keyword value admits; an absent `type` admits every kind. */
+export function typeMask(type) {
+    if (type === undefined)
+        return ANY;
+    const names = typeof type === 'string' ? [type] : Array.isArray(type) ? type : [];
+    return names.reduce((mask, name) => {
+        switch (name) {
+            case 'null':
+                return mask | NULL;
+            case 'boolean':
+                return mask | BOOLEAN;
+            case 'object':
+                return mask | OBJECT;
+            case 'array':
+                return mask | ARRAY;
+            case 'string':
+                return mask | STRING;
+            case 'integer':
+                return mask | INTEGER;
+            case 'number':
+                return mask | NUMBER;
+            default:
+                return mask;
+        }
+    }, 0);
+}
+/** The single kind of one JSON value. */
+export function kindOf(value) {
+    if (value === null)
+        return NULL;
+    if (typeof value === 'boolean')
+        return BOOLEAN;
+    if (typeof value === 'string')
+        return STRING;
+    if (typeof value === 'number')
+        return Number.isInteger(value) ? INTEGER : FRACTION;
+    return Array.isArray(value) ? ARRAY : OBJECT;
+}
+/** The finite value set of a kind mask made only of null and booleans. */
+export function finiteKinds(kinds) {
+    if ((kinds & ~(NULL | BOOLEAN)) !== 0)
+        return undefined;
+    return [
+        ...((kinds & NULL) !== 0 ? [null] : []),
+        ...((kinds & BOOLEAN) !== 0 ? [true, false] : []),
+    ];
+}

package/dist/v1/language/value/inclusion/location.d.ts

@@ -0,0 +1,24 @@
+import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import type { ValueProgram } from '../compile/model.js';
+import type { JsonSchema } from '../model/schema.js';
+/** One schema location inside one admitted program. */
+export interface At {
+    readonly program: ValueProgram;
+    readonly index: number;
+}
+/** The location `index` of `program`. */
+export declare function at(program: ValueProgram, index: number): At;
+/** The schema written at a location. */
+export declare function schemaOf(location: At): JsonSchema;
+/** The subschema under `keyword`, or under its `member`, when the program compiled one. */
+export declare function childOf(location: At, keyword: string, member?: string | number): At | undefined;
+/** The subschemas of an array-valued `keyword`, in order. */
+export declare function childrenOf(location: At, keyword: string): readonly At[];
+/** The resolved `$ref` target of a location. */
+export declare function referenceOf(location: At): At | undefined;
+/** The location with its `$ref` targets and `allOf` branches; admission makes this acyclic. */
+export declare function conjunctsOf(location: At): readonly At[];
+/** Whether `name` matches `pattern` under the program's regular-expression dialect. */
+export declare function matches(location: At, pattern: string, name: string): boolean;
+/** Whether the V1 evaluator accepts `value` at a location. */
+export declare function accepts(location: At, value: JsonValue): boolean;

package/dist/v1/language/value/inclusion/location.js

@@ -0,0 +1,63 @@
+import { loadValueProgram } from '../compile/load.js';
+import { evaluateInstance } from '../evaluate/evaluator.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { appendPointer } from '../syntax/pointer.js';
+/** The location `index` of `program`. */
+export function at(program, index) {
+    return { program, index };
+}
+/** The schema written at a location. */
+export function schemaOf(location) {
+    const node = location.program.nodes[location.index];
+    if (node === undefined)
+        throw new TypeError('Value program location is absent.');
+    return node.schema;
+}
+/** The subschema under `keyword`, or under its `member`, when the program compiled one. */
+export function childOf(location, keyword, member) {
+    const base = appendPointer('', keyword);
+    const key = (member === undefined ? base : appendPointer(base, member)).slice(1);
+    const index = location.program.nodes[location.index]?.children[key];
+    return index === undefined ? undefined : at(location.program, index);
+}
+/** The subschemas of an array-valued `keyword`, in order. */
+export function childrenOf(location, keyword) {
+    const schema = schemaOf(location);
+    if (!isJsonObject(schema) || !Array.isArray(schema[keyword]))
+        return [];
+    return schema[keyword].flatMap((_, index) => {
+        const child = childOf(location, keyword, index);
+        return child === undefined ? [] : [child];
+    });
+}
+/** The resolved `$ref` target of a location. */
+export function referenceOf(location) {
+    const index = location.program.nodes[location.index]?.reference;
+    return index === undefined ? undefined : at(location.program, index);
+}
+/** The location with its `$ref` targets and `allOf` branches; admission makes this acyclic. */
+export function conjunctsOf(location) {
+    const seen = new Set();
+    const conjuncts = [];
+    const visit = (current) => {
+        if (seen.has(current.index))
+            return;
+        seen.add(current.index);
+        conjuncts.push(current);
+        const reference = referenceOf(current);
+        if (reference !== undefined)
+            visit(reference);
+        for (const branch of childrenOf(current, 'allOf'))
+            visit(branch);
+    };
+    visit(location);
+    return conjuncts;
+}
+/** Whether `name` matches `pattern` under the program's regular-expression dialect. */
+export function matches(location, pattern, name) {
+    return loadValueProgram(location.program).matcher(pattern).test(name);
+}
+/** Whether the V1 evaluator accepts `value` at a location. */
+export function accepts(location, value) {
+    return evaluateInstance(loadValueProgram(location.program, location.index), value).valid;
+}

package/dist/v1/language/value/inclusion/numbers.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from './assertions.js';
+/** Rules for the numeric bound and divisibility keywords. */
+export declare const numberRules: ReadonlyMap<string, Rule>;

package/dist/v1/language/value/inclusion/numbers.js

@@ -0,0 +1,41 @@
+import { isMultipleOf } from '../evaluate/assertions.js';
+import { has } from './evidence.js';
+import { FRACTION, NUMBER } from './kinds.js';
+/** Rules for the numeric bound and divisibility keywords. */
+export const numberRules = new Map([
+    [
+        'maximum',
+        ({ value, evidence }) => typeof value !== 'number' ||
+            !has(evidence, NUMBER) ||
+            (evidence.upper !== undefined && evidence.upper.value <= value),
+    ],
+    [
+        'exclusiveMaximum',
+        ({ value, evidence }) => typeof value !== 'number' ||
+            !has(evidence, NUMBER) ||
+            (evidence.upper !== undefined &&
+                (evidence.upper.value < value ||
+                    (evidence.upper.exclusive && evidence.upper.value <= value))),
+    ],
+    [
+        'minimum',
+        ({ value, evidence }) => typeof value !== 'number' ||
+            !has(evidence, NUMBER) ||
+            (evidence.lower !== undefined && evidence.lower.value >= value),
+    ],
+    [
+        'exclusiveMinimum',
+        ({ value, evidence }) => typeof value !== 'number' ||
+            !has(evidence, NUMBER) ||
+            (evidence.lower !== undefined &&
+                (evidence.lower.value > value ||
+                    (evidence.lower.exclusive && evidence.lower.value >= value))),
+    ],
+    [
+        'multipleOf',
+        ({ value, evidence }) => typeof value !== 'number' ||
+            !has(evidence, NUMBER) ||
+            evidence.multipleOf.some((divisor) => isMultipleOf(divisor, value)) ||
+            (!has(evidence, FRACTION) && isMultipleOf(1, value)),
+    ],
+]);

package/dist/v1/language/value/inclusion/objects.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from './assertions.js';
+/** Rules for the object size, required-name and property-subschema keywords. */
+export declare const objectRules: ReadonlyMap<string, Rule>;

package/dist/v1/language/value/inclusion/objects.js

@@ -0,0 +1,190 @@
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { has } from './evidence.js';
+import { isTop } from './keywords.js';
+import { OBJECT } from './kinds.js';
+import { accepts, childOf, matches, schemaOf } from './location.js';
+/** Rules for the object size, required-name and property-subschema keywords. */
+export const objectRules = new Map([
+    [
+        'maxProperties',
+        ({ inclusion, value, evidence }) => typeof value !== 'number' ||
+            !has(evidence, OBJECT) ||
+            (evidence.maxProperties !== undefined && evidence.maxProperties <= value) ||
+            evidence.conjuncts.some((conjunct) => {
+                const names = closedNames(inclusion, conjunct);
+                return names !== undefined && names.length <= value;
+            }),
+    ],
+    [
+        'minProperties',
+        ({ value, evidence }) => typeof value !== 'number' ||
+            !has(evidence, OBJECT) ||
+            value <= 0 ||
+            evidence.minProperties >= value ||
+            evidence.required.size >= value,
+    ],
+    [
+        'required',
+        ({ value, evidence }) => !Array.isArray(value) ||
+            !has(evidence, OBJECT) ||
+            value.every((name) => typeof name !== 'string' || evidence.required.has(name)),
+    ],
+    ['dependentRequired', dependentRequiredHolds],
+    ['properties', propertiesHold],
+    ['patternProperties', patternPropertiesHold],
+    ['additionalProperties', additionalHolds],
+    ['propertyNames', propertyNamesHold],
+    ['dependentSchemas', dependentSchemasHold],
+]);
+function dependentRequiredHolds({ inclusion, value, evidence }) {
+    return (!isJsonObject(value) ||
+        !has(evidence, OBJECT) ||
+        Object.entries(value).every(([name, dependencies]) => !Array.isArray(dependencies) ||
+            forbids(inclusion, evidence, name) ||
+            dependencies.every((dependency) => typeof dependency !== 'string' ||
+                evidence.required.has(dependency) ||
+                evidence.dependentRequired.get(name)?.has(dependency) === true)));
+}
+function propertiesHold({ inclusion, value, outer, evidence }) {
+    return (!isJsonObject(value) ||
+        !has(evidence, OBJECT) ||
+        Object.keys(value).every((name) => {
+            const member = childOf(outer, 'properties', name);
+            return (member === undefined ||
+                isTop(schemaOf(member)) ||
+                memberConstraints(evidence, name).some((constraint) => inclusion.includes(member, constraint)));
+        }));
+}
+function patternPropertiesHold({ inclusion, value, outer, evidence }) {
+    return (!isJsonObject(value) ||
+        !has(evidence, OBJECT) ||
+        Object.keys(value).every((pattern) => {
+            const member = childOf(outer, 'patternProperties', pattern);
+            if (member === undefined || isTop(schemaOf(member)))
+                return true;
+            return evidence.conjuncts.some((conjunct) => {
+                const same = childOf(conjunct, 'patternProperties', pattern);
+                if (same !== undefined && inclusion.includes(member, same))
+                    return true;
+                return coversNames(inclusion, conjunct, member, (name) => matches(outer, pattern, name));
+            });
+        }));
+}
+function additionalHolds({ inclusion, outer, schema, evidence }) {
+    const additional = childOf(outer, 'additionalProperties');
+    if (additional === undefined || isTop(schemaOf(additional)) || !has(evidence, OBJECT)) {
+        return true;
+    }
+    const declared = isJsonObject(schema.properties) ? schema.properties : {};
+    const patterns = isJsonObject(schema.patternProperties)
+        ? Object.keys(schema.patternProperties)
+        : [];
+    const isAdditional = (name) => !Object.hasOwn(declared, name) && !patterns.some((pattern) => matches(outer, pattern, name));
+    return evidence.conjuncts.some((conjunct) => coversNames(inclusion, conjunct, additional, isAdditional, patterns));
+}
+function propertyNamesHold({ inclusion, outer, evidence }) {
+    const names = childOf(outer, 'propertyNames');
+    if (names === undefined || isTop(schemaOf(names)) || !has(evidence, OBJECT))
+        return true;
+    return evidence.conjuncts.some((conjunct) => {
+        const own = childOf(conjunct, 'propertyNames');
+        if (own !== undefined && inclusion.includes(names, own))
+            return true;
+        const closed = closedNames(inclusion, conjunct);
+        return closed !== undefined && closed.every((name) => accepts(names, name));
+    });
+}
+function dependentSchemasHold({ inclusion, value, outer, evidence }) {
+    return (!isJsonObject(value) ||
+        !has(evidence, OBJECT) ||
+        Object.keys(value).every((name) => {
+            const dependent = childOf(outer, 'dependentSchemas', name);
+            if (dependent === undefined || isTop(schemaOf(dependent)))
+                return true;
+            if (forbids(inclusion, evidence, name))
+                return true;
+            if (evidence.conjuncts.some((conjunct) => inclusion.includes(dependent, conjunct))) {
+                return true;
+            }
+            return evidence.conjuncts.some((conjunct) => {
+                const own = childOf(conjunct, 'dependentSchemas', name);
+                return own !== undefined && inclusion.includes(dependent, own);
+            });
+        }));
+}
+/**
+ * Whether every property of a `conjunct`-admitted object whose name is `relevant` satisfies
+ * `required`. Names matching a pattern in `settled` are never relevant.
+ */
+function coversNames(inclusion, conjunct, required, relevant, settled = []) {
+    const schema = schemaOf(conjunct);
+    if (!isJsonObject(schema))
+        return false;
+    const rest = childOf(conjunct, 'additionalProperties');
+    if (rest === undefined || !inclusion.includes(required, rest))
+        return false;
+    const declared = isJsonObject(schema.properties) ? Object.keys(schema.properties) : [];
+    const patterns = isJsonObject(schema.patternProperties)
+        ? Object.keys(schema.patternProperties)
+        : [];
+    return (declared.every((name) => {
+        if (!relevant(name))
+            return true;
+        const member = childOf(conjunct, 'properties', name);
+        return member !== undefined && inclusion.includes(required, member);
+    }) &&
+        patterns.every((pattern) => {
+            if (settled.includes(pattern))
+                return true;
+            const member = childOf(conjunct, 'patternProperties', pattern);
+            return member !== undefined && inclusion.includes(required, member);
+        }));
+}
+/** Locations one conjunct applies to the value of property `name`. */
+function memberConstraints(evidence, name) {
+    return evidence.conjuncts.flatMap((conjunct) => {
+        const schema = schemaOf(conjunct);
+        if (!isJsonObject(schema))
+            return [];
+        const constraints = [];
+        const declared = isJsonObject(schema.properties) && Object.hasOwn(schema.properties, name);
+        if (declared) {
+            const member = childOf(conjunct, 'properties', name);
+            if (member !== undefined)
+                constraints.push(member);
+        }
+        let matched = false;
+        if (isJsonObject(schema.patternProperties)) {
+            for (const pattern of Object.keys(schema.patternProperties)) {
+                if (!matches(conjunct, pattern, name))
+                    continue;
+                matched = true;
+                const member = childOf(conjunct, 'patternProperties', pattern);
+                if (member !== undefined)
+                    constraints.push(member);
+            }
+        }
+        if (!declared && !matched) {
+            const rest = childOf(conjunct, 'additionalProperties');
+            if (rest !== undefined)
+                constraints.push(rest);
+        }
+        return constraints;
+    });
+}
+/** Whether an admitted object never has property `name`. */
+function forbids(inclusion, evidence, name) {
+    return memberConstraints(evidence, name).some((constraint) => inclusion.evidence(constraint).kinds === 0);
+}
+/** The complete property-name set of a closed object conjunct, when it is one. */
+function closedNames(inclusion, conjunct) {
+    const schema = schemaOf(conjunct);
+    if (!isJsonObject(schema))
+        return undefined;
+    if (isJsonObject(schema.patternProperties) && Object.keys(schema.patternProperties).length > 0)
+        return undefined;
+    const rest = childOf(conjunct, 'additionalProperties');
+    if (rest === undefined || inclusion.evidence(rest).kinds !== 0)
+        return undefined;
+    return isJsonObject(schema.properties) ? Object.keys(schema.properties) : [];
+}

package/dist/v1/language/value/inclusion/strings.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from './assertions.js';
+/** Rules for the string length and pattern keywords. */
+export declare const stringRules: ReadonlyMap<string, Rule>;

package/dist/v1/language/value/inclusion/strings.js

@@ -0,0 +1,29 @@
+import { has } from './evidence.js';
+import { STRING } from './kinds.js';
+/** Rules for the string length and pattern keywords. */
+export const stringRules = new Map([
+    [
+        'maxLength',
+        ({ value, evidence }) => typeof value !== 'number' ||
+            !has(evidence, STRING) ||
+            (evidence.maxLength !== undefined && evidence.maxLength <= value),
+    ],
+    [
+        'minLength',
+        ({ value, evidence }) => typeof value !== 'number' ||
+            !has(evidence, STRING) ||
+            value <= 0 ||
+            evidence.minLength >= value,
+    ],
+    [
+        'pattern',
+        ({ value, evidence }) => typeof value !== 'string' ||
+            !has(evidence, STRING) ||
+            evidence.patterns.has(value) ||
+            evidence.fullMatches.has(value),
+    ],
+    [
+        'fullMatch',
+        ({ value, evidence }) => typeof value !== 'string' || !has(evidence, STRING) || evidence.fullMatches.has(value),
+    ],
+]);

package/dist/v1/language/value/inclusion/types.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from './assertions.js';
+/** Rules for the keywords that restrict the kind or the exact value. */
+export declare const typeRules: ReadonlyMap<string, Rule>;

package/dist/v1/language/value/inclusion/types.js

@@ -0,0 +1,11 @@
+import { typeMask } from './kinds.js';
+/** Rules for the keywords that restrict the kind or the exact value. */
+export const typeRules = new Map([
+    ['type', ({ value, evidence }) => (evidence.kinds & ~typeMask(value)) === 0],
+    ['const', () => false],
+    ['enum', () => false],
+    [
+        'x-astrale-value-kind',
+        ({ value, evidence }) => typeof value === 'string' && evidence.valueKinds.has(value),
+    ],
+]);

package/dist/v1/language/value/ordering.d.ts

@@ -1,3 +1,4 @@
+import type { ValueKind } from '@astrale-os/kernel-dsl/value';
 import type { ValueProgram } from './compile/model.js';
 import type { CompiledInstanceSchema } from './evaluate/types.js';
 import type { JsonSchema } from './model/schema.js';
@@ -13,3 +14,16 @@ export declare function classifyOrdering(contract: JsonSchema, registry: ValueSc
 /** Recompute the scalar ordering classification from one admitted portable value program. */
 export declare function classifyValueProgramOrdering(program: ValueProgram): OrderingKind | undefined;
 export declare function classifyPreparedOrdering(compiled: CompiledInstanceSchema): OrderingKind | undefined;
+/**
+ * Every value kind `classifyValueKind` returns, frozen, in the order `ValueKind` names them. A kind
+ * added to `ValueKind` does not compile until it is listed here.
+ */
+export declare const VALUE_KINDS: readonly ValueKind[];
+/**
+ * The value kind of a property schema (page "Fondations Query v7", § Atoms et value kinds, Y4):
+ * the one kind its non-null values admit, `null` being a point of every kind. An annotated
+ * instant is `instant`, a finite set of strings `enum`, an array of unique items `set`; an
+ * ambiguous union, an object, an array with repetitions or a domain without values is `json`.
+ */
+export declare function classifyValueKind(contract: JsonSchema, registry: ValueSchemaRegistry): ValueKind;
+export declare function classifyPreparedValueKind(compiled: CompiledInstanceSchema): ValueKind;

package/dist/v1/language/value/ordering.js

@@ -25,7 +25,8 @@ export function classifyValueProgramOrdering(program) {
     return classifyPreparedOrdering(loadValueProgram(program));
 }
 export function classifyPreparedOrdering(compiled) {
-    const candidates = new OrderingClassifier(compiled).classify(compiled.root);
+    // An enum orders as the strings it lists; a set is an array.
+    const candidates = new Set([...new OrderingClassifier(compiled).classify(compiled.root)].map((kind) => kind === 'enum' ? 'string' : kind === 'set' ? 'array' : kind));
     if (candidates.size !== 1)
         return undefined;
     const [kind] = candidates;
@@ -33,6 +34,51 @@ export function classifyPreparedOrdering(compiled) {
         ? kind
         : undefined;
 }
+const valueKinds = {
+    text: true,
+    number: true,
+    instant: true,
+    enum: true,
+    boolean: true,
+    set: true,
+    json: true,
+};
+/**
+ * Every value kind `classifyValueKind` returns, frozen, in the order `ValueKind` names them. A kind
+ * added to `ValueKind` does not compile until it is listed here.
+ */
+export const VALUE_KINDS = Object.freeze(Object.keys(valueKinds));
+/**
+ * The value kind of a property schema (page "Fondations Query v7", § Atoms et value kinds, Y4):
+ * the one kind its non-null values admit, `null` being a point of every kind. An annotated
+ * instant is `instant`, a finite set of strings `enum`, an array of unique items `set`; an
+ * ambiguous union, an object, an array with repetitions or a domain without values is `json`.
+ */
+export function classifyValueKind(contract, registry) {
+    const prepared = prepareValueSchema(contract, registry, '');
+    if (!prepared.compiled)
+        return 'json';
+    return classifyPreparedValueKind(prepared.value);
+}
+export function classifyPreparedValueKind(compiled) {
+    const candidates = new Set(new OrderingClassifier(compiled).classify(compiled.root));
+    candidates.delete('null');
+    if (candidates.size !== 1)
+        return 'json';
+    const [kind] = candidates;
+    switch (kind) {
+        case 'string':
+            return 'text';
+        case 'number':
+        case 'boolean':
+        case 'instant':
+        case 'enum':
+        case 'set':
+            return kind;
+        default:
+            return 'json';
+    }
+}
 class OrderingClassifier {
     compiled;
     active = new Set();
@@ -72,6 +118,9 @@ class OrderingClassifier {
         const declaredTypes = typesOf(schema.type);
         if (declaredTypes !== undefined)
             candidates = intersect(candidates, declaredTypes);
+        if (schema.uniqueItems === true) {
+            candidates = new Set([...candidates].map((kind) => (kind === 'array' ? 'set' : kind)));
+        }
         if (Object.hasOwn(schema, 'const')) {
             candidates = intersect(candidates, new Set([kindOfValue(schema.const)]));
         }
@@ -130,6 +179,7 @@ function typeSet(types) {
     }
     return result;
 }
+/** The kind of one listed value: a listed string belongs to a finite set of strings. */
 function kindOfValue(value) {
     if (value === null)
         return 'null';
@@ -141,18 +191,35 @@ function kindOfValue(value) {
         return 'boolean';
     if (typeof value === 'number')
         return 'number';
-    return 'string';
+    return 'enum';
 }
+/** The kind both admit: equal kinds, or the narrower of a kind and one of its subsets. */
+function meet(left, right) {
+    if (left === right)
+        return left;
+    for (const [narrow, wide] of NARROWER) {
+        if ((left === narrow && right === wide) || (left === wide && right === narrow))
+            return narrow;
+    }
+    return undefined;
+}
+/**
+ * The narrower kind of two that meet: a subset and its kind, and an enum of instants, which
+ * orders as instants.
+ */
+const NARROWER = [
+    ['instant', 'string'],
+    ['enum', 'string'],
+    ['instant', 'enum'],
+    ['set', 'array'],
+];
 function intersect(left, right) {
     const result = new Set();
     for (const leftKind of left) {
         for (const rightKind of right) {
-            if (leftKind === rightKind)
-                result.add(leftKind);
-            else if ((leftKind === 'string' && rightKind === 'instant') ||
-                (leftKind === 'instant' && rightKind === 'string')) {
-                result.add('instant');
-            }
+            const kind = meet(leftKind, rightKind);
+            if (kind !== undefined)
+                result.add(kind);
         }
     }
     return normalize(result);
@@ -160,9 +227,19 @@ function intersect(left, right) {
 function union(left, right) {
     return normalize(new Set([...left, ...right]));
 }
+/** A kind absorbs its subsets; strings of two subsets are strings. */
 function normalize(input) {
-    if (input.has('string'))
+    if (input.has('enum') && input.has('instant')) {
+        input.delete('enum');
         input.delete('instant');
+        input.add('string');
+    }
+    if (input.has('string')) {
+        input.delete('instant');
+        input.delete('enum');
+    }
+    if (input.has('array'))
+        input.delete('set');
     return input;
 }
 function schemaList(input) {