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

package/dist/v1/language/class/unique.js

@@ -0,0 +1,264 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { ClassKey } from '../../addressing/class-key.js';
+import { compareUnicode } from '../../addressing/ordering.js';
+import { PropertyKey } from '../../addressing/property-key.js';
+/** The kinds of key fields, in canonical order: the endpoints, the slug, then the Properties. */
+const KINDS = Object.freeze([
+    'source',
+    'target',
+    'slug',
+    'property',
+]);
+/** The canonical order of forms: kind by kind, a form before every form it prefixes. */
+const compareForms = compareSequences(compareKinds);
+/**
+ * Every form a key tuple may take, in canonical order: each nonempty set of field kinds. A Property
+ * kind stands for one Property or more, whatever their keys.
+ */
+export const EDGE_UNIQUE_FORMS = Object.freeze(Array.from({ length: (1 << KINDS.length) - 1 }, (_, index) => Object.freeze(KINDS.filter((_, kind) => ((index + 1) & (1 << kind)) !== 0))).sort(compareForms));
+/** The one form a Node key tuple takes: its fields are Properties, whatever their keys. */
+export const NODE_UNIQUE_FORMS = Object.freeze([
+    Object.freeze(['property']),
+]);
+/** Every form of every kind, which a backend enforcing any key tuple announces. */
+export const UNIQUE_FORMS = Object.freeze({
+    edge: EDGE_UNIQUE_FORMS,
+    node: NODE_UNIQUE_FORMS,
+});
+/** No form of either kind: a backend that announces none enforces no key tuple. */
+export const NO_UNIQUE_FORMS = Object.freeze({
+    edge: Object.freeze([]),
+    node: Object.freeze([]),
+});
+/** The kind of `field`. */
+function kindOf(field) {
+    return typeof field === 'string' ? field : 'property';
+}
+function compareKinds(left, right) {
+    return KINDS.indexOf(left) - KINDS.indexOf(right);
+}
+/** The canonical order of fields: source, target, slug, then Properties by key. */
+export function compareEdgeUniqueFields(left, right) {
+    return (compareKinds(kindOf(left), kindOf(right)) ||
+        (typeof left === 'string' || typeof right === 'string'
+            ? 0
+            : compareUnicode(left.property, right.property)));
+}
+/** The canonical order of tuples: field by field, a tuple before every tuple it prefixes. */
+export const compareEdgeUniqueTuples = compareSequences(compareEdgeUniqueFields);
+/** The field `value` spells, detached, or undefined when it spells none. */
+function edgeUniqueField(value) {
+    if (value === 'source' || value === 'target' || value === 'slug')
+        return value;
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const keys = Object.keys(value);
+    const property = value.property;
+    return keys.length === 1 && keys[0] === 'property' && PropertyKey.is(property)
+        ? Object.freeze({ property })
+        : undefined;
+}
+/**
+ * The tuple `value` spells, detached, or undefined when it spells none: a nonempty list of fields,
+ * distinct and in canonical order, so one set of fields has one spelling.
+ */
+export function edgeUniqueTuple(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    const fields = [];
+    for (const item of value) {
+        const field = edgeUniqueField(item);
+        if (field === undefined)
+            return undefined;
+        if (fields.length > 0 && compareEdgeUniqueFields(fields.at(-1), field) >= 0)
+            return undefined;
+        fields.push(field);
+    }
+    return Object.freeze(fields);
+}
+/**
+ * The tuple the endpoints and slug `named` holds spell, in canonical order, or undefined when it
+ * holds none: the key a selector names an Edge by. A selector names no Property.
+ */
+export function namedEdgeUniqueTuple(named) {
+    return edgeUniqueTuple(['source', 'target', 'slug'].filter((field) => named[field] !== undefined));
+}
+/** The canonical order of Node tuples: Property by Property, a tuple before every one it prefixes. */
+export const compareNodeUniqueTuples = compareSequences(compareUnicode);
+/**
+ * The Node tuple `value` spells, detached, or undefined when it spells none: a nonempty list of
+ * Property keys, distinct and in code-point order, so one set of Properties has one spelling.
+ */
+export function nodeUniqueTuple(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    const keys = [];
+    for (const key of value) {
+        if (!PropertyKey.is(key))
+            return undefined;
+        if (keys.length > 0 && compareUnicode(keys.at(-1), key) >= 0)
+            return undefined;
+        keys.push(key);
+    }
+    return Object.freeze(keys);
+}
+/** The form of `NODE_UNIQUE_FORMS` that `value` spells, or undefined when it spells none. */
+export function nodeUniqueForm(value) {
+    return Array.isArray(value) && value.length === 1 && value[0] === 'property'
+        ? NODE_UNIQUE_FORMS[0]
+        : undefined;
+}
+/**
+ * Whether a backend announcing `forms` for Nodes enforces the Node tuple `value` spells: every
+ * Node tuple has the one Node form. False when `value` spells no tuple.
+ */
+export function enforcesNodeUniqueTuple(forms, value) {
+    return forms.length > 0 && nodeUniqueTuple(value) !== undefined;
+}
+/** The form of `tuple`: the kinds of its fields, each once. */
+export function edgeUniqueFormOf(tuple) {
+    const kinds = new Set(tuple.map(kindOf));
+    return EDGE_UNIQUE_FORMS.find((form) => form.length === kinds.size && form.every((kind) => kinds.has(kind)));
+}
+/** The form of `EDGE_UNIQUE_FORMS` that `value` spells, or undefined when it spells none. */
+export function edgeUniqueForm(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return EDGE_UNIQUE_FORMS.find((form) => form.length === value.length && form.every((kind, index) => kind === value[index]));
+}
+/**
+ * Whether a backend announcing `forms` enforces the tuple `value` spells: its form is one of them.
+ * False when `value` spells no tuple, so a tuple is never taken as enforced by mistake.
+ */
+export function enforcesEdgeUniqueTuple(forms, value) {
+    const tuple = edgeUniqueTuple(value);
+    if (tuple === undefined)
+        return false;
+    const form = edgeUniqueFormOf(tuple);
+    return forms.some((candidate) => compareForms(candidate, form) === 0);
+}
+/**
+ * Whether a Property may be a key field (D-S1): a single-kind scalar by its ordering facet, a
+ * string, number, boolean or instant, that no automatic program writes.
+ */
+export function keyableProperty(ordering, auto) {
+    return ordering !== undefined && auto === undefined;
+}
+/**
+ * The values of the fields of `tuple` on `edge`, in order, or undefined when one of them is absent,
+ * so that an Edge without a slug or without a Property never collides.
+ */
+export function edgeUniqueValues(tuple, edge) {
+    return keyValues(tuple, (field) => typeof field === 'string' ? edge[field] : propertyOf(edge.props, field.property));
+}
+/**
+ * The value `edge` takes under `tuple`, the canonical JSON of the values of its fields, or
+ * undefined when one of them is absent: two distinct Edges of the Classes a tuple covers collide
+ * exactly when they take one value. Endpoints compare by NodeId, slugs by exact text and
+ * Properties by canonical Value.
+ */
+export function edgeUniqueValue(tuple, edge) {
+    return serialized(edgeUniqueValues(tuple, edge));
+}
+/**
+ * The values of the Properties of `tuple` on `node`, in order, or undefined when one of them is
+ * absent, so that a Node without one of them never collides, like NULL in an SQL UNIQUE.
+ */
+export function nodeUniqueValues(tuple, node) {
+    return keyValues(tuple, (key) => propertyOf(node.props, key));
+}
+/**
+ * The value `node` takes under `tuple`, the canonical JSON of the values of its Properties, or
+ * undefined when one of them is absent: two distinct Nodes of the Classes a tuple covers collide
+ * exactly when they take one value. Properties compare by canonical Value, nothing normalized.
+ */
+export function nodeUniqueValue(tuple, node) {
+    return serialized(nodeUniqueValues(tuple, node));
+}
+/**
+ * The tuples covering `candidate`: those it and each of its ancestors declare, each with the Class
+ * declaring it, ancestors found by `resolve`. A descendant never restates them.
+ */
+export function coveringEdgeUniqueTuples(candidate, resolve) {
+    return coveringTuples(candidate, resolve);
+}
+/**
+ * The Node tuples covering `candidate`: those it and each of its ancestors declare, each with the
+ * Class declaring it, ancestors found by `resolve`. A descendant never restates them.
+ */
+export function coveringNodeUniqueTuples(candidate, resolve) {
+    return coveringTuples(candidate, resolve);
+}
+/**
+ * The keys `edge` holds: its value under each tuple of `tuples`, tagged by the Class declaring the
+ * tuple, so two Edges collide exactly when they hold one key.
+ */
+export function edgeUniqueKeys(tuples, edge) {
+    return heldKeys(tuples, (fields) => edgeUniqueValue(fields, edge));
+}
+/**
+ * The keys `node` holds: its value under each tuple of `tuples`, tagged by the Class declaring the
+ * tuple, so two Nodes collide exactly when they hold one key.
+ */
+export function nodeUniqueKeys(tuples, node) {
+    return heldKeys(tuples, (fields) => nodeUniqueValue(fields, node));
+}
+/** The values `read` gives the fields of `tuple`, in order, or undefined when one is absent. */
+function keyValues(tuple, read) {
+    const values = [];
+    for (const field of tuple) {
+        const value = read(field);
+        if (value === undefined)
+            return undefined;
+        values.push(value);
+    }
+    return Object.freeze(values);
+}
+/** The value of the Property `key` in `props`, or undefined when it is absent. */
+function propertyOf(props, key) {
+    return Object.hasOwn(props, key) ? props[key] : undefined;
+}
+/** The canonical JSON of a key's values, or undefined when it has none. */
+function serialized(values) {
+    return values === undefined ? undefined : json.serializeAdmitted(values);
+}
+/**
+ * The tuples `candidate` and its ancestors declare, each with its declarer. Only ancestors of the
+ * candidate's kind are visited, so every tuple is of that kind.
+ */
+function coveringTuples(candidate, resolve) {
+    const tuples = [];
+    const seen = new Set();
+    const visit = (value) => {
+        if (seen.has(value) || value.kind !== candidate.kind)
+            return;
+        seen.add(value);
+        for (const fields of value.unique ?? [])
+            tuples.push(Object.freeze({ class: ClassKey.of(value.ref), fields }));
+        for (const ref of value.extends) {
+            const parent = resolve(ref);
+            if (parent !== undefined)
+                visit(parent);
+        }
+    };
+    visit(candidate);
+    return Object.freeze(tuples);
+}
+/** The keys a fact holds under `tuples`, its value under each tagged by the declaring Class. */
+function heldKeys(tuples, valueOf) {
+    return tuples.flatMap(({ class: declaring, fields }) => {
+        const value = valueOf(fields);
+        return value === undefined ? [] : [JSON.stringify([declaring, fields, value])];
+    });
+}
+/** The lexicographic order of sequences by `compare`, a sequence before every one it prefixes. */
+function compareSequences(compare) {
+    return (left, right) => {
+        for (let index = 0; index < Math.min(left.length, right.length); index += 1) {
+            const order = compare(left[index], right[index]);
+            if (order !== 0)
+                return order;
+        }
+        return left.length - right.length;
+    };
+}

package/dist/v1/language/core/facts.d.ts

@@ -0,0 +1,85 @@
+import type { ClassRef } from '../../addressing/index.js';
+import type { EdgeContract, EdgeCount, EdgeEndpointBase, IncidentEndpoint } from '../class/model/edge.js';
+/**
+ * The Class of the owning Domain's Node: every Domain principal is a Node of the final Kernel
+ * `Domain` Class, so a Core Edge that names the Domain must accept that Class at that endpoint.
+ */
+export declare const DOMAIN_ENDPOINT_CLASS: ClassRef;
+/** One endpoint of a Core Edge: a Core Node, a projected member or the owning Domain. */
+export interface CoreFactEndpoint {
+    readonly key: string;
+    /**
+     * Set on a projected member and on the owning Domain: the Kernel Class it is a Node of, and where
+     * a breach of its degree is reported.
+     */
+    readonly member?: {
+        readonly class: ClassRef;
+        readonly pointer: string;
+    };
+}
+/** One Core Edge whose endpoints satisfy its exact Class. */
+export interface CoreFactEdge<Edge> {
+    readonly edge: Edge;
+    /** The exact Class's key, as `CoreEdgeSet.classes` names it. */
+    readonly class: string;
+    readonly contract: EdgeContract;
+    readonly source: CoreFactEndpoint;
+    readonly target: CoreFactEndpoint;
+}
+/** One declared Core Node. It proves its own complete degree, so both bounds hold. */
+export interface CoreDegreeSubject {
+    readonly key: string;
+    readonly class: ClassRef;
+    readonly pointer: string;
+}
+export interface CoreEdgeSet<Edge> {
+    readonly edges: readonly CoreFactEdge<Edge>[];
+    /** The local Edge Classes, in the order their slices are checked. */
+    readonly classes: readonly {
+        readonly key: string;
+        readonly contract: EdgeContract & {
+            readonly abstract: boolean;
+        };
+    }[];
+    readonly nodes: readonly CoreDegreeSubject[];
+    readonly satisfies: (ref: ClassRef, accepts: readonly ClassRef[]) => boolean;
+    /** The keys an Edge holds under the tuples covering its Class. */
+    readonly keys: (edge: CoreFactEdge<Edge>) => readonly string[];
+    /** Whether an undirected Edge's two endpoints state one contract, counted once. */
+    readonly sameIncident: (left: IncidentEndpoint, right: IncidentEndpoint) => boolean;
+    readonly report: (issue: CoreEdgeIssue<Edge>) => void;
+}
+export type CoreEdgeIssue<Edge> = {
+    readonly kind: 'identity';
+    readonly edge: Edge;
+    readonly previous: Edge;
+} | {
+    readonly kind: 'no-self';
+    readonly edge: Edge;
+} | {
+    readonly kind: 'key';
+    readonly edge: Edge;
+    readonly previous: Edge;
+} | {
+    readonly kind: 'acyclic';
+    readonly class: string;
+} | {
+    readonly kind: 'degree';
+    readonly pointer: string;
+    readonly endpoint: EdgeEndpointBase;
+    readonly count: EdgeCount;
+    readonly degree: number;
+};
+/** Whether the endpoints satisfy the contract: in order when directed, in either order when not. */
+export declare function coreEndpointsSatisfy<Endpoint>(contract: EdgeContract, source: Endpoint, target: Endpoint, satisfies: (endpoint: Endpoint, accepts: readonly ClassRef[]) => boolean): boolean;
+/**
+ * Report each fact that holds a key an earlier fact holds, with the first holder of that key. Core
+ * facts have no slug, so only tuples of endpoints and Properties bind them (DV-NODE-UNIQUE,
+ * DV-EDGE-UNIQUE); Activation checks them against stored data.
+ */
+export declare function checkHeldKeys<Fact>(facts: Iterable<Fact>, keys: (fact: Fact) => readonly string[], report: (fact: Fact, previous: Fact) => void): void;
+/**
+ * Check normalized Edge identity, noSelf, keys, and the acyclicity and Core degrees of each exact
+ * concrete Edge Class over its own Edges.
+ */
+export declare function checkCoreEdgeSet<Edge>(set: CoreEdgeSet<Edge>): void;

package/dist/v1/language/core/facts.js

@@ -0,0 +1,116 @@
+import { compareUnicode } from '../../addressing/ordering.js';
+import { countBounds, hasDirectedCycle, KERNEL_ORIGIN } from '../class/inheritance.js';
+/*
+ * The Core fact rules that authored and compiled admission share. Each admission resolves its own
+ * Core Nodes and Edges, then reports every issue under its own codes, messages and pointers.
+ */
+/**
+ * The Class of the owning Domain's Node: every Domain principal is a Node of the final Kernel
+ * `Domain` Class, so a Core Edge that names the Domain must accept that Class at that endpoint.
+ */
+export const DOMAIN_ENDPOINT_CLASS = Object.freeze({
+    origin: KERNEL_ORIGIN,
+    kind: 'class',
+    name: 'Domain',
+});
+/** Whether the endpoints satisfy the contract: in order when directed, in either order when not. */
+export function coreEndpointsSatisfy(contract, source, target, satisfies) {
+    if (contract.orientation === 'directed') {
+        const { endpoints } = contract;
+        return (satisfies(source, endpoints.source.accepts) && satisfies(target, endpoints.target.accepts));
+    }
+    const [first, second] = contract.endpoints;
+    return ((satisfies(source, first.accepts) && satisfies(target, second.accepts)) ||
+        (satisfies(source, second.accepts) && satisfies(target, first.accepts)));
+}
+/**
+ * Report each fact that holds a key an earlier fact holds, with the first holder of that key. Core
+ * facts have no slug, so only tuples of endpoints and Properties bind them (DV-NODE-UNIQUE,
+ * DV-EDGE-UNIQUE); Activation checks them against stored data.
+ */
+export function checkHeldKeys(facts, keys, report) {
+    const holders = new Map();
+    for (const fact of facts) {
+        const held = keys(fact);
+        const holder = held.find((key) => holders.has(key));
+        if (holder !== undefined)
+            report(fact, holders.get(holder));
+        for (const key of held)
+            if (!holders.has(key))
+                holders.set(key, fact);
+    }
+}
+/**
+ * Check normalized Edge identity, noSelf, keys, and the acyclicity and Core degrees of each exact
+ * concrete Edge Class over its own Edges.
+ */
+export function checkCoreEdgeSet(set) {
+    const identities = new Map();
+    const slices = new Map(set.classes.map(({ key }) => [key, []]));
+    for (const fact of set.edges) {
+        const [source, target] = fact.contract.orientation === 'undirected' &&
+            compareUnicode(fact.source.key, fact.target.key) > 0
+            ? [fact.target.key, fact.source.key]
+            : [fact.source.key, fact.target.key];
+        const identity = `${fact.class}\u0000${source}\u0000${target}`;
+        const previous = identities.get(identity);
+        if (previous !== undefined)
+            set.report({ kind: 'identity', edge: fact.edge, previous });
+        else
+            identities.set(identity, fact.edge);
+        slices.get(fact.class)?.push(fact);
+        if (fact.contract.constraints.noSelf === true && fact.source.key === fact.target.key)
+            set.report({ kind: 'no-self', edge: fact.edge });
+    }
+    checkHeldKeys(set.edges, set.keys, (fact, previous) => set.report({ kind: 'key', edge: fact.edge, previous: previous.edge }));
+    for (const { key, contract } of set.classes) {
+        // No Edge is of an abstract Class exactly, so it bounds no degree and closes no cycle of its
+        // own: each concrete descendant carries the counts it refines, over its own Edges.
+        if (contract.abstract)
+            continue;
+        const slice = slices.get(key);
+        if (contract.constraints.acyclic === true && hasDirectedCycle(slice))
+            set.report({ kind: 'acyclic', class: key });
+        checkDegrees(set, contract, slice);
+    }
+}
+function checkDegrees(set, contract, slice) {
+    for (const subject of degreeSubjects(set.nodes, slice)) {
+        const check = (endpoint, count, degree) => {
+            const [minimum, maximum] = countBounds(count);
+            if (degree > maximum || (degree < minimum && subject.minimum))
+                set.report({ kind: 'degree', pointer: subject.pointer, endpoint, count, degree });
+        };
+        if (contract.orientation === 'directed') {
+            const { source, target } = contract.endpoints;
+            if (set.satisfies(subject.class, source.accepts))
+                check(source, source.outgoing, slice.filter((edge) => edge.source.key === subject.key).length);
+            if (set.satisfies(subject.class, target.accepts))
+                check(target, target.incoming, slice.filter((edge) => edge.target.key === subject.key).length);
+            continue;
+        }
+        const [first, second] = contract.endpoints;
+        const degree = slice.filter((edge) => edge.source.key === subject.key || edge.target.key === subject.key).length;
+        if (set.satisfies(subject.class, first.accepts))
+            check(first, first.incident, degree);
+        if (!set.sameIncident(first, second) && set.satisfies(subject.class, second.accepts))
+            check(second, second.incident, degree);
+    }
+}
+/**
+ * Every declared Core Node proves its own complete degree, so both bounds hold. A projected member,
+ * and the owning Domain, is only named by the Edges that reach it: the Domain may also create
+ * ordinary Edges of the same Class against it, so a minimum is unprovable here and only the maximum
+ * is enforced.
+ */
+function degreeSubjects(nodes, slice) {
+    const subjects = new Map(nodes.map((node) => [node.key, { ...node, minimum: true }]));
+    for (const edge of slice) {
+        for (const { key, member } of [edge.source, edge.target]) {
+            if (member === undefined || subjects.has(key))
+                continue;
+            subjects.set(key, { key, class: member.class, pointer: member.pointer, minimum: false });
+        }
+    }
+    return subjects.values();
+}

package/dist/v1/language/definition/metadata.d.ts

@@ -18,3 +18,8 @@ export declare const name: Readonly<{
 }>;
 /** The common source and compiled grammar for a name displayed exactly as authored. */
 export declare function isDomainNameText(value: string): boolean;
+/**
+ * The same grammar as a portable pattern: no control character, and neither first nor last a
+ * character `trim` removes, spelled out since `\s` differs between regular expression engines.
+ */
+export declare const DOMAIN_NAME_TEXT_PATTERN: RegExp;

package/dist/v1/language/definition/metadata.js

@@ -22,3 +22,10 @@ const DOMAIN_NAME_CONTROL = /[\u0000-\u001f\u007f-\u009f\u2028\u2029]/u;
 export function isDomainNameText(value) {
     return value.trim() === value && !DOMAIN_NAME_CONTROL.test(value);
 }
+/**
+ * The same grammar as a portable pattern: no control character, and neither first nor last a
+ * character `trim` removes, spelled out since `\s` differs between regular expression engines.
+ */
+export const DOMAIN_NAME_TEXT_PATTERN = 
+// oxlint-disable-next-line no-control-regex
+/^(?:[^\u0000-\u001f\u007f-\u009f\u0020\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff](?:[^\u0000-\u001f\u007f-\u009f\u2028\u2029]*[^\u0000-\u001f\u007f-\u009f\u0020\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff])?)?$/u;

package/dist/v1/language/freeze.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Freeze `value` and every object it reaches, in place. An object already frozen is taken as frozen
+ * through, so a value built from frozen parts is frozen without walking them again.
+ */
+export declare function deepFreeze<T>(value: T): Readonly<T>;

package/dist/v1/{schema/canonical → language}/freeze.js

@@ -1,3 +1,7 @@
+/**
+ * Freeze `value` and every object it reaches, in place. An object already frozen is taken as frozen
+ * through, so a value built from frozen parts is frozen without walking them again.
+ */
 export function deepFreeze(value) {
     if (value === null || typeof value !== 'object' || Object.isFrozen(value)) {
         return value;

package/dist/v1/language/index.d.ts

@@ -1,3 +1,4 @@
+export { admissionInputFields, isAdmissionMaxAge, MAXIMUM_ADMISSION_AGE_SECONDS, } from './callable/admission.js';
 export { isMethodExecutable } from './callable/executable.js';
 export { isBinaryInput } from './callable/model/callable.js';
 export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, FunctionRef, MethodKey, PolicyRef, PropertyKey, ViewRef, } from '../addressing/index.js';
@@ -6,6 +7,7 @@ export type { JsonSchema as ValueSchema, JsonSchemaObject as ValueSchemaObject,
 export type { OrderingKind } from './value/ordering.js';
 export type { ValueProgram } from './value/compile/model.js';
 export { valueProgramIncludes } from './value/inclusion/includes.js';
+export { isInstantValue } from './value/model/instant.js';
 export { stateMachine } from './state/index.js';
 export type { EventOf, StateMachine, StateOf, StateTopology } from './state/index.js';
 export type * from './callable/model/callable.js';
@@ -13,8 +15,11 @@ export type * from './callable/resolved.js';
 export type * from './class/model/class.js';
 export type { DataDefinition, DataFacet, MediaType } from './class/model/data.js';
 export type * from './class/model/edge.js';
-export { edgeLifetimes } from './class/lifetime.js';
-export type { EdgeLifetime } from './class/lifetime.js';
+export { admitsForeignSubclass, inheritanceOf } from './class/inheritance.js';
+export { edgeLifetimes, lifetimeScope } from './class/lifetime.js';
+export type { LifetimeScope } from './class/lifetime.js';
+export { EDGE_UNIQUE_FORMS, NODE_UNIQUE_FORMS, NO_UNIQUE_FORMS, UNIQUE_FORMS, compareEdgeUniqueFields, compareEdgeUniqueTuples, compareNodeUniqueTuples, coveringEdgeUniqueTuples, coveringNodeUniqueTuples, edgeUniqueForm, edgeUniqueFormOf, edgeUniqueKeys, edgeUniqueTuple, edgeUniqueValue, edgeUniqueValues, enforcesEdgeUniqueTuple, enforcesNodeUniqueTuple, keyableProperty, namedEdgeUniqueTuple, nodeUniqueForm, nodeUniqueKeys, nodeUniqueTuple, nodeUniqueValue, nodeUniqueValues, } from './class/unique.js';
+export type { DeclaredEdgeUniqueTuple, DeclaredNodeUniqueTuple, EdgeUniqueFacts, NodeUniqueFacts, UniqueForms, } from './class/unique.js';
 export type * from './class/model/property.js';
 export type * from './class/resolved.js';
 export type * from './class/facets.js';

package/dist/v1/language/index.js

@@ -1,7 +1,11 @@
+export { admissionInputFields, isAdmissionMaxAge, MAXIMUM_ADMISSION_AGE_SECONDS, } from './callable/admission.js';
 export { isMethodExecutable } from './callable/executable.js';
 export { isBinaryInput } from './callable/model/callable.js';
 export { valueProgramIncludes } from './value/inclusion/includes.js';
+export { isInstantValue } from './value/model/instant.js';
 export { stateMachine } from './state/index.js';
-export { edgeLifetimes } from './class/lifetime.js';
+export { admitsForeignSubclass, inheritanceOf } from './class/inheritance.js';
+export { edgeLifetimes, lifetimeScope } from './class/lifetime.js';
+export { EDGE_UNIQUE_FORMS, NODE_UNIQUE_FORMS, NO_UNIQUE_FORMS, UNIQUE_FORMS, compareEdgeUniqueFields, compareEdgeUniqueTuples, compareNodeUniqueTuples, coveringEdgeUniqueTuples, coveringNodeUniqueTuples, edgeUniqueForm, edgeUniqueFormOf, edgeUniqueKeys, edgeUniqueTuple, edgeUniqueValue, edgeUniqueValues, enforcesEdgeUniqueTuple, enforcesNodeUniqueTuple, keyableProperty, namedEdgeUniqueTuple, nodeUniqueForm, nodeUniqueKeys, nodeUniqueTuple, nodeUniqueValue, nodeUniqueValues, } from './class/unique.js';
 export { PropertyValues } from './class/property-values.js';
 export { isClassRuleChecks, policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, projectedMemberClass, } from './policy/model/policy.js';

package/dist/v1/language/limits.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The limits of the V1 language, each defined once: every check of a source Schema, a Bundle or a
+ * compiled closure reads its bound here. Every limit is inclusive: a count equal to it is
+ * accepted, one more is refused. `schema.limits` publishes this object, and each rule of
+ * `schema.RULES` and `schema.values.RULES` that enforces some of them names them in `limits`.
+ */
+export declare const limits: Readonly<{
+    /** Bounds of the dependency graph of one Domain (`DV_DEPENDENCY_LIMITS`). */
+    dependency: Readonly<{
+        /** Direct dependencies one Domain declares. */
+        direct: 32;
+        /** Domains of a dependency closure, the Domain itself included. */
+        closure: 256;
+        /** Dependencies on the longest chain from a Domain: a direct dependency is at depth 1. */
+        depth: 32;
+    }>;
+    /** Bounds of one I-Regexp in a value schema (`VS_REGEX_PORTABLE`), as RFC 9485 §8 allows. */
+    regexp: Readonly<{
+        /** Code points of one source. */
+        maxCodePoints: 4096;
+        /** Groups nested in one another in one source. */
+        maxNesting: 32;
+        /** The greatest bound of a counted repetition `{n}` or `{n,m}`. */
+        maxRepeat: 1000;
+        /** States of one compiled machine; the counted-run form never expands and is not bounded. */
+        maxStates: 10000;
+    }>;
+    /**
+     * Bounds of the Policy language. A named Policy is measured once normalized and once each
+     * composition is expanded into the Policies it names; a check tree, the checks of a callable or
+     * of a Node Class rule, once normalized (`PL_BUDGET`). The structure bounds the others
+     * (`STRUCTURE_MAXIMUM`).
+     */
+    policy: Readonly<{
+        /**
+         * Levels of a Policy pattern: an Edge or sameNode is one, and each allOf, anyOf, exists and
+         * composition adds one.
+         */
+        patternDepth: 4;
+        /**
+         * Branches of a Policy's normal form: an anyOf adds those of its operands, an allOf multiplies
+         * them.
+         */
+        normalizedBranches: 8;
+        /** Nodes one exists declares. */
+        variablesPerExists: 4;
+        /** Graph predicates, Edges and sameNode equalities, of one normalized branch. */
+        edgePredicates: 6;
+        /** The greatest bound of a repeated Edge. */
+        repetition: 3;
+        /** Domains a Policy names: its own, and the origin of every Class and object it references. */
+        referencedDomains: 4;
+        /** Levels of a check tree: a check or sameNode is one, and each allOf and anyOf adds one. */
+        checkDepth: 4;
+        /** Branches of a check tree: an anyOf adds those of its operands, an allOf multiplies them. */
+        checkBranches: 8;
+        /** Checks and sameNode equalities of a check tree. */
+        checkLeaves: 8;
+    }>;
+}>;
+/** A limit by its key in `limits`, `<group>.<name>`: `policy.patternDepth`. */
+export type LimitKey = {
+    readonly [Group in keyof typeof limits & string]: `${Group}.${keyof (typeof limits)[Group] & string}`;
+}[keyof typeof limits & string];