@telorun/cel 0.0.0-stage → 0.108.0

package/dist/function-registry.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Which functions an environment has, and which one a call resolves to.
+ *
+ * **Nothing here is privileged.** The standard library registers through exactly this
+ * surface, so a host can replace one of its signatures or remove it — the capability
+ * the whole package exists for. Registration is last-wins by dispatch key
+ * (`signature.ts`), removal is by the same key, and both are per environment: a
+ * clone inherits and may then diverge without touching its parent.
+ *
+ * **Resolution answers WHY it failed**, never just "no". A call on a name nothing
+ * registers, a call written in the wrong form, and a call whose arguments no overload
+ * takes are three different mistakes with three different repairs, and the engine
+ * being replaced reported one sentence for all three — which is why a separate
+ * classifier had to re-derive the cause after the fact. The checker decides it here,
+ * once, with the candidates it considered.
+ */
+import type { CelType } from "./cel-type.js";
+import type { CallForm, CelSignature, FunctionMetadata } from "./signature.js";
+export interface RegisteredFunction {
+    readonly signature: CelSignature;
+    readonly metadata: FunctionMetadata;
+}
+export type ResolutionFailure = 
+/** No function of that name is registered, in any form. */
+{
+    readonly reason: "unknown";
+    readonly candidates: readonly RegisteredFunction[];
+}
+/** The name is registered, but only in the other call form. */
+ | {
+    readonly reason: "wrong-form";
+    readonly candidates: readonly RegisteredFunction[];
+}
+/** The name and form are registered; no overload takes these arguments. */
+ | {
+    readonly reason: "no-overload";
+    readonly candidates: readonly RegisteredFunction[];
+};
+/**
+ * How many names a refused call may name as candidates.
+ *
+ * It is **declared** rather than left to a message's taste, because the conformance
+ * vectors pin that message byte for byte: a bound and an order a second engine cannot
+ * reproduce would be a row no port can pass. The order is edit distance then name, both
+ * over the name exactly as it was written.
+ */
+export declare const UNKNOWN_FUNCTION_CANDIDATES = 5;
+export interface Resolution {
+    readonly resolved: RegisteredFunction;
+    /** The return type with every type parameter substituted by what this call bound. */
+    readonly returns: CelType;
+}
+export declare class FunctionRegistry {
+    private readonly byName;
+    constructor(inherited?: FunctionRegistry);
+    /** Registers a function, replacing any registration answering the same call. */
+    register(signature: CelSignature, metadata?: FunctionMetadata): void;
+    /** Removes the one registration answering that call. Answers whether it was there. */
+    remove(signature: CelSignature): boolean;
+    /** Removes every registration of a name. Answers how many went. */
+    removeName(name: string): number;
+    has(name: string): boolean;
+    /** Every registration, in name order then registration order. */
+    list(): readonly RegisteredFunction[];
+    named(name: string): readonly RegisteredFunction[];
+    /**
+     * The names this environment registers that would accept a call of that form and
+     * arity, nearest first — what a call on a name nothing registers is offered instead.
+     *
+     * **Form and arity are a filter rather than a ranking**, because a nearer name a call
+     * cannot be written on is not a repair: `'a'.size()` is not helped by `size`. A name
+     * that is not a name is filtered for the same reason — the operators register under
+     * their own symbols (`!`, `-`, `+`), and `no(1)` offered `!` and `-` as its two
+     * nearest spellings, neither of which can be written as a call at all. Among what
+     * passes the filter the order is edit distance then name, and the list is cut at
+     * {@link UNKNOWN_FUNCTION_CANDIDATES} — a declared bound and a declared order, so the
+     * message is the same text on every engine. Distance is counted over the name as
+     * written, with no case folding: a port reproduces one rule and not a host language's
+     * notion of lower case.
+     */
+    candidateNames(wanted: string, form: CallForm, arity: number): readonly string[];
+    /**
+     * The function a call resolves to. `receiver` is the type the call is written on,
+     * absent for a global call.
+     */
+    resolve(name: string, form: CallForm, args: readonly CelType[], receiver?: CelType): Resolution | ResolutionFailure;
+    /**
+     * The loose pass: a `dyn` argument makes a candidate viable, and **where several become
+     * viable and they do not agree on a return type, the call answers `dyn`.**
+     *
+     * Taking the first one instead is a concrete type nothing established. `dyn('a') +
+     * dyn('b')` answered `int` — the first `+` overload — so a host that declares nothing
+     * about a name had `a + b` typed `int`, and a consumer comparing that against a declared
+     * `string` slot refused a manifest that runs correctly. The honest answer is the one the
+     * engine's own design already states: overloads are resolved per call site on the VALUES'
+     * own types, so a `dyn` operand is exactly the case where the static answer is unknown.
+     *
+     * The candidate is still carried for the caller that wants one (a listing, a flag), and a
+     * single viable overload still answers its own return type — `dyn` only where they differ.
+     */
+    private matchLoosely;
+    private match;
+    /**
+     * Whether an argument fits a parameter, binding type parameters as it goes.
+     *
+     * **A type parameter is bound by the first argument that mentions it**, and a later
+     * argument does not refine it: `[] + [3, 4]` is `list<T>`, because the empty list
+     * fixed the element type as "unknown" and the second argument cannot retroactively
+     * decide what the first one held.
+     */
+    private fits;
+}
+/** The type with every bound parameter replaced; an unbound one stays as it is. */
+export declare function substitute(type: CelType, bindings: ReadonlyMap<string, CelType>): CelType;
+/** How a resolution failure names what it looked at, for a message a human reads. */
+export declare function describeCandidates(candidates: readonly RegisteredFunction[]): string;
+export declare function describeArguments(args: readonly CelType[]): string;
+//# sourceMappingURL=function-registry.d.ts.map

package/dist/function-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-registry.d.ts","sourceRoot":"","sources":["../src/function-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAK/E,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;CACrC;AAED,MAAM,MAAM,iBAAiB;AAC3B,2DAA2D;AACzD;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,SAAS,kBAAkB,EAAE,CAAA;CAAE;AACpF,+DAA+D;GAC7D;IAAE,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,SAAS,kBAAkB,EAAE,CAAA;CAAE;AACvF,2EAA2E;GACzE;IAAE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,SAAS,kBAAkB,EAAE,CAAA;CAAE,CAAC;AAE3F;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAE7C,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;IACtC,qFAAqF;IACrF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoC;gBAE/C,SAAS,CAAC,EAAE,gBAAgB;IAOxC,gFAAgF;IAChF,QAAQ,CAAC,SAAS,EAAE,YAAY,EAAE,QAAQ,GAAE,gBAAqB,GAAG,IAAI;IAoBxE,sFAAsF;IACtF,MAAM,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO;IAWxC,mEAAmE;IACnE,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAOhC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B,iEAAiE;IACjE,IAAI,IAAI,SAAS,kBAAkB,EAAE;IAIrC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,kBAAkB,EAAE;IAIlD;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE;IAiBhF;;;OAGG;IACH,OAAO,CACL,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,SAAS,OAAO,EAAE,EACxB,QAAQ,CAAC,EAAE,OAAO,GACjB,UAAU,GAAG,iBAAiB;IAiBjC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,YAAY;IAgBpB,OAAO,CAAC,KAAK;IAiBb;;;;;;;OAOG;IACH,OAAO,CAAC,IAAI;CA8Cb;AAED,mFAAmF;AACnF,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAwBzF;AA6BD,qFAAqF;AACrF,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,SAAS,kBAAkB,EAAE,GAAG,MAAM,CAEpF;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,MAAM,CAElE"}

package/dist/function-registry.js

@@ -0,0 +1,292 @@
+/**
+ * Which functions an environment has, and which one a call resolves to.
+ *
+ * **Nothing here is privileged.** The standard library registers through exactly this
+ * surface, so a host can replace one of its signatures or remove it — the capability
+ * the whole package exists for. Registration is last-wins by dispatch key
+ * (`signature.ts`), removal is by the same key, and both are per environment: a
+ * clone inherits and may then diverge without touching its parent.
+ *
+ * **Resolution answers WHY it failed**, never just "no". A call on a name nothing
+ * registers, a call written in the wrong form, and a call whose arguments no overload
+ * takes are three different mistakes with three different repairs, and the engine
+ * being replaced reported one sentence for all three — which is why a separate
+ * classifier had to re-derive the cause after the fact. The checker decides it here,
+ * once, with the candidates it considered.
+ */
+import { CelEngineError } from "./check-diagnostic.js";
+import { assignable, DYN, formatType, isDyn, typesEqual } from "./cel-type.js";
+import { formatSignature, signatureKey } from "./signature.js";
+import { CALL_SITE_DIRECT_ARITY } from "./runtime-library.js";
+import { isIdentifierSpelling, isReservedWord } from "./reserved-words.js";
+/**
+ * How many names a refused call may name as candidates.
+ *
+ * It is **declared** rather than left to a message's taste, because the conformance
+ * vectors pin that message byte for byte: a bound and an order a second engine cannot
+ * reproduce would be a row no port can pass. The order is edit distance then name, both
+ * over the name exactly as it was written.
+ */
+export const UNKNOWN_FUNCTION_CANDIDATES = 5;
+export class FunctionRegistry {
+    byName;
+    constructor(inherited) {
+        this.byName = new Map();
+        if (inherited) {
+            for (const [name, entries] of inherited.byName)
+                this.byName.set(name, [...entries]);
+        }
+    }
+    /** Registers a function, replacing any registration answering the same call. */
+    register(signature, metadata = {}) {
+        // An implementation receives its arguments positionally, up to the bound, so a wider
+        // signature is refused HERE rather than resolved and then called with its tail dropped.
+        // A declared bound nothing enforces is the silent wrong answer it exists to prevent.
+        const arity = signature.parameters.length + (signature.form === "receiver" ? 1 : 0);
+        if (arity > CALL_SITE_DIRECT_ARITY) {
+            throw new CelEngineError("signature_too_wide", `${formatSignature(signature)} takes ${arity} values and an implementation receives at most ${CALL_SITE_DIRECT_ARITY}`);
+        }
+        const entries = this.byName.get(signature.name) ?? [];
+        const key = signatureKey(signature);
+        const at = entries.findIndex((entry) => signatureKey(entry.signature) === key);
+        const entry = { signature, metadata };
+        if (at === -1)
+            entries.push(entry);
+        else
+            entries[at] = entry;
+        this.byName.set(signature.name, entries);
+    }
+    /** Removes the one registration answering that call. Answers whether it was there. */
+    remove(signature) {
+        const entries = this.byName.get(signature.name);
+        if (!entries)
+            return false;
+        const key = signatureKey(signature);
+        const at = entries.findIndex((entry) => signatureKey(entry.signature) === key);
+        if (at === -1)
+            return false;
+        entries.splice(at, 1);
+        if (entries.length === 0)
+            this.byName.delete(signature.name);
+        return true;
+    }
+    /** Removes every registration of a name. Answers how many went. */
+    removeName(name) {
+        const entries = this.byName.get(name);
+        if (!entries)
+            return 0;
+        this.byName.delete(name);
+        return entries.length;
+    }
+    has(name) {
+        return this.byName.has(name);
+    }
+    /** Every registration, in name order then registration order. */
+    list() {
+        return [...this.byName.keys()].sort().flatMap((name) => this.byName.get(name));
+    }
+    named(name) {
+        return this.byName.get(name) ?? [];
+    }
+    /**
+     * The names this environment registers that would accept a call of that form and
+     * arity, nearest first — what a call on a name nothing registers is offered instead.
+     *
+     * **Form and arity are a filter rather than a ranking**, because a nearer name a call
+     * cannot be written on is not a repair: `'a'.size()` is not helped by `size`. A name
+     * that is not a name is filtered for the same reason — the operators register under
+     * their own symbols (`!`, `-`, `+`), and `no(1)` offered `!` and `-` as its two
+     * nearest spellings, neither of which can be written as a call at all. Among what
+     * passes the filter the order is edit distance then name, and the list is cut at
+     * {@link UNKNOWN_FUNCTION_CANDIDATES} — a declared bound and a declared order, so the
+     * message is the same text on every engine. Distance is counted over the name as
+     * written, with no case folding: a port reproduces one rule and not a host language's
+     * notion of lower case.
+     */
+    candidateNames(wanted, form, arity) {
+        const matching = [];
+        for (const [name, entries] of this.byName) {
+            if (name === wanted)
+                continue;
+            if (!isIdentifierSpelling(name) || isReservedWord(name))
+                continue;
+            const accepts = entries.some((entry) => entry.signature.form === form && entry.signature.parameters.length === arity);
+            if (accepts)
+                matching.push(name);
+        }
+        return matching
+            .map((name) => ({ name, distance: editDistance(wanted, name) }))
+            .sort((left, right) => left.distance - right.distance || compareNames(left.name, right.name))
+            .slice(0, UNKNOWN_FUNCTION_CANDIDATES)
+            .map((candidate) => candidate.name);
+    }
+    /**
+     * The function a call resolves to. `receiver` is the type the call is written on,
+     * absent for a global call.
+     */
+    resolve(name, form, args, receiver) {
+        const all = this.byName.get(name);
+        if (!all || all.length === 0)
+            return { reason: "unknown", candidates: [] };
+        const inForm = all.filter((entry) => entry.signature.form === form);
+        if (inForm.length === 0)
+            return { reason: "wrong-form", candidates: all };
+        const arity = inForm.filter((entry) => entry.signature.parameters.length === args.length);
+        const viable = arity.length === 0 ? inForm : arity;
+        // Exact first, then a candidate `dyn` makes viable, which is what keeps an
+        // unlisted variable from turning one mistake into two.
+        const exact = this.match(viable, args, receiver, false);
+        if (exact)
+            return exact;
+        const loose = this.matchLoosely(viable, args, receiver);
+        if (loose)
+            return loose;
+        return { reason: "no-overload", candidates: inForm };
+    }
+    /**
+     * The loose pass: a `dyn` argument makes a candidate viable, and **where several become
+     * viable and they do not agree on a return type, the call answers `dyn`.**
+     *
+     * Taking the first one instead is a concrete type nothing established. `dyn('a') +
+     * dyn('b')` answered `int` — the first `+` overload — so a host that declares nothing
+     * about a name had `a + b` typed `int`, and a consumer comparing that against a declared
+     * `string` slot refused a manifest that runs correctly. The honest answer is the one the
+     * engine's own design already states: overloads are resolved per call site on the VALUES'
+     * own types, so a `dyn` operand is exactly the case where the static answer is unknown.
+     *
+     * The candidate is still carried for the caller that wants one (a listing, a flag), and a
+     * single viable overload still answers its own return type — `dyn` only where they differ.
+     */
+    matchLoosely(candidates, args, receiver) {
+        const viable = [];
+        for (const candidate of candidates) {
+            const held = this.match([candidate], args, receiver, true);
+            if (held)
+                viable.push(held);
+        }
+        const first = viable[0];
+        if (!first)
+            return undefined;
+        const agree = viable.every((held) => typesEqual(held.returns, first.returns));
+        return agree ? first : { resolved: first.resolved, returns: DYN };
+    }
+    match(candidates, args, receiver, allowDyn) {
+        for (const candidate of candidates) {
+            const { signature } = candidate;
+            if (signature.parameters.length !== args.length)
+                continue;
+            const bindings = new Map();
+            if (signature.receiver && !this.fits(receiver ?? DYN, signature.receiver, bindings, allowDyn))
+                continue;
+            if (!signature.parameters.every((want, at) => this.fits(args[at], want, bindings, allowDyn)))
+                continue;
+            return { resolved: candidate, returns: substitute(signature.returns, bindings) };
+        }
+        return undefined;
+    }
+    /**
+     * Whether an argument fits a parameter, binding type parameters as it goes.
+     *
+     * **A type parameter is bound by the first argument that mentions it**, and a later
+     * argument does not refine it: `[] + [3, 4]` is `list<T>`, because the empty list
+     * fixed the element type as "unknown" and the second argument cannot retroactively
+     * decide what the first one held.
+     */
+    fits(argument, parameter, bindings, allowDyn) {
+        if (parameter.kind === "parameter") {
+            const bound = bindings.get(parameter.name);
+            if (!bound) {
+                bindings.set(parameter.name, argument);
+                return true;
+            }
+            // A binding that holds an unresolved parameter holds no information, so a later
+            // concrete argument refines it: `optional.none().orValue(42)` is an int.
+            if (bound.kind === "parameter" && argument.kind !== "parameter") {
+                bindings.set(parameter.name, argument);
+                return true;
+            }
+            if (bound.kind === "parameter" || argument.kind === "parameter")
+                return true;
+            return assignable(argument, bound) || (allowDyn && (isDyn(argument) || isDyn(bound)));
+        }
+        if (parameter.kind === "list" && argument.kind === "list") {
+            return this.fits(argument.element, parameter.element, bindings, allowDyn);
+        }
+        if (parameter.kind === "map" && argument.kind === "map") {
+            return (this.fits(argument.key, parameter.key, bindings, allowDyn) &&
+                this.fits(argument.value, parameter.value, bindings, allowDyn));
+        }
+        if (parameter.kind === "optional" && argument.kind === "optional") {
+            return this.fits(argument.value, parameter.value, bindings, allowDyn);
+        }
+        if (parameter.kind === "nominal" &&
+            argument.kind === "nominal" &&
+            parameter.name === argument.name &&
+            parameter.args.length === argument.args.length) {
+            // A named type's arguments are invariant, so they fit one for one — which is also
+            // where a signature written over `Self` binds its own type parameters.
+            return parameter.args.every((want, at) => this.fits(argument.args[at], want, bindings, allowDyn));
+        }
+        if (isDyn(argument))
+            return allowDyn || isDyn(parameter);
+        return assignable(argument, parameter);
+    }
+}
+/** The type with every bound parameter replaced; an unbound one stays as it is. */
+export function substitute(type, bindings) {
+    switch (type.kind) {
+        case "parameter":
+            return bindings.get(type.name) ?? type;
+        case "list": {
+            const element = substitute(type.element, bindings);
+            return element === type.element ? type : { kind: "list", element };
+        }
+        case "map": {
+            const key = substitute(type.key, bindings);
+            const value = substitute(type.value, bindings);
+            return key === type.key && value === type.value ? type : { kind: "map", key, value };
+        }
+        case "optional": {
+            const value = substitute(type.value, bindings);
+            return value === type.value ? type : { kind: "optional", value };
+        }
+        case "nominal": {
+            const args = type.args.map((argument) => substitute(argument, bindings));
+            return args.every((argument, at) => argument === type.args[at]) ? type : { ...type, args };
+        }
+        default:
+            return type;
+    }
+}
+/** Code-unit order, so a port orders two names without a locale. */
+function compareNames(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+/**
+ * Levenshtein distance in UTF-16 code units — one insertion, deletion or substitution
+ * each costing one, which is the whole rule a port needs to reproduce.
+ *
+ * Code units rather than code points for the same reason every range in this package is
+ * in them: it is the one unit both ends of the engine already count in, and a name is
+ * compared against a name rather than cut.
+ */
+function editDistance(from, to) {
+    let previous = Array.from({ length: to.length + 1 }, (ignored, at) => at);
+    for (let left = 1; left <= from.length; left += 1) {
+        const row = new Array(to.length + 1);
+        row[0] = left;
+        for (let right = 1; right <= to.length; right += 1) {
+            const substitution = previous[right - 1] + (from[left - 1] === to[right - 1] ? 0 : 1);
+            row[right] = Math.min(substitution, previous[right] + 1, row[right - 1] + 1);
+        }
+        previous = row;
+    }
+    return previous[to.length];
+}
+/** How a resolution failure names what it looked at, for a message a human reads. */
+export function describeCandidates(candidates) {
+    return candidates.map((candidate) => formatSignature(candidate.signature)).join(", ");
+}
+export function describeArguments(args) {
+    return args.map((type) => formatType(type)).join(", ");
+}

package/dist/index.d.ts

@@ -0,0 +1,93 @@
+/**
+ * `@telorun/cel` — the CEL language.
+ *
+ * This entry is the front end: reading an expression, the canonical tree it reads
+ * into, writing a tree back as source, and the two questions a consumer asks of a
+ * tree (what it reads, and which namespaced functions it calls). It reaches no
+ * runtime of its own and no host facility — nothing here touches a filesystem, a
+ * clock or a network, so it runs unchanged in a browser.
+ *
+ * It owns CEL and nothing above it: no host's type vocabulary, no host's function
+ * catalog. Those are registered onto the engine by whoever embeds it.
+ */
+export { parseExpression, resolvedUnder } from "./cel-expression.js";
+export type { CelExpression, ParseExpressionOptions } from "./cel-expression.js";
+export { MAX_INT, MAX_UINT, MIN_INT } from "./lexer.js";
+export { CelNamespaceError, namespaceSetsEqual, normalizeNamespaces, RESERVED_NAMESPACES, resolveNamespaces, } from "./namespace-resolution.js";
+export { DEFAULT_PARSE_LIMITS, resolveParseLimits } from "./parse-limits.js";
+export type { CelParseLimits } from "./parse-limits.js";
+export { parseSyntax } from "./parser.js";
+export type { ParseOptions, ParseResult } from "./parser.js";
+export { qualifiedCalls } from "./qualified-calls.js";
+export type { QualifiedCall } from "./qualified-calls.js";
+export { isIdentifierSpelling, isReservedWord, LITERAL_WORDS, OPERATOR_WORDS, RESERVED_WORDS, } from "./reserved-words.js";
+export { rootReferences } from "./root-references.js";
+export { splitDeclaredChain } from "./declared-chain.js";
+export type { DeclaredChain } from "./declared-chain.js";
+export { CelSerializeError, serializeTree } from "./serializer.js";
+export type { CelSyntaxCode, CelSyntaxDiagnostic } from "./syntax-diagnostic.js";
+export { childNodes, hasUnparsed, walkTree } from "./syntax-tree.js";
+export type { CelBinaryNode, CelBinaryOperator, CelCallNode, CelConditionalNode, CelIdentNode, CelIndexNode, CelListNode, CelLiteral, CelLiteralNode, CelMapEntry, CelMapNode, CelNode, CelQualifiedCallNode, CelReceiverCallNode, CelSelectNode, CelUnaryNode, CelUnaryOperator, CelUnparsedNode, SourceRange, } from "./syntax-tree.js";
+export { treesEqual } from "./tree-equality.js";
+export { admitsNull, assignable, BOOL, BYTES, DOUBLE, DURATION, DYN, formatType, INT, isDyn, isNumeric, listOf, mapOf, NULL, optionalOf, parameterOf, STRING, TIMESTAMP, TYPE, typesEqual, UINT, unify, unionOf, WELL_KNOWN_TYPE_NAMES, withoutNull, withoutParameters, } from "./cel-type.js";
+export type { CelType, DynType, ListType, MapType, NominalType, OptionalType, ParameterType, PrimitiveName, PrimitiveType, RecordType, UnionType, } from "./cel-type.js";
+export { CEL_CHECK_CODES, CelEngineError } from "./check-diagnostic.js";
+export type { CelCheckCode, CelCheckDiagnostic, CelDiagnosticFix, CelEngineErrorCode, } from "./check-diagnostic.js";
+export type { CheckResult, NamespaceFunction } from "./checker.js";
+export { CelEnvironment, DEFAULT_COMPILED_CACHE_CAPACITY } from "./environment.js";
+export type { CelEnvironmentOptions, Definitions, FunctionDefinition, NamespaceFunctionDeclaration, NamespaceListing, NamespaceOptions, SchemaRegistrationReport, TypeDeclaration, TypeDefinitionListing, VariableDefinition, } from "./environment.js";
+export { FunctionRegistry, UNKNOWN_FUNCTION_CANDIDATES } from "./function-registry.js";
+export type { RegisteredFunction, Resolution, ResolutionFailure } from "./function-registry.js";
+export { fieldMapType, schemaType, TYPE_CONSTRAINING_KEYWORDS, TYPE_KEYWORDS_READ, UNJUDGED_REASONS, } from "./json-schema-type.js";
+export type { FieldDeclaration, JsonSchemaDocument, JsonSchemaNode, NamedTypeLookup, RecursiveSchemaReference, SchemaConversion, SchemaTypeAnswer, SchemaTypeResolver, SchemaTypeResult, UnjudgedReason, UnjudgedSchemaNode, } from "./json-schema-type.js";
+export { CelTypeRegistrationError } from "./nominal-type.js";
+export type { NominalOperatorDeclaration, NominalTypeDefinition, RegisteredType, } from "./nominal-type.js";
+export type { ResolvedCall } from "./resolved-call.js";
+export { formatSignature, parseSignature, signatureKey } from "./signature.js";
+export type { CallForm, CelSignature, FunctionMetadata, LiteralArgumentCheck, } from "./signature.js";
+export { googleTypeNames, registerStandardLibrary, standardConstants, STANDARD_LIBRARY_GENERATION, standardLibrarySignatures, } from "./standard-library.js";
+export type { StandardConstant } from "./standard-library.js";
+export { catalogCategories, catalogSignatures, FUNCTION_CATALOG_GENERATION, functionCatalog, registerFunctionCatalog, } from "./function-catalog.js";
+export type { CatalogFunction, RegisterCatalogOptions } from "./function-catalog.js";
+export { catalogGuardedNames, catalogImplementation, catalogImplementedKeys, catalogLiteralCheck, } from "./catalog-runtime.js";
+export type { CatalogImplementation, CelCatalogHandlers } from "./catalog-runtime.js";
+export { scanJsonPrefix } from "./json-text-scan.js";
+export type { JsonRefusal } from "./json-text-scan.js";
+export { civilTimeIn, dateTextIn, daysInMonth, instantOfCivilTime, isoTextIn, knownTimeZone, } from "./zoned-calendar.js";
+export type { CivilTime } from "./zoned-calendar.js";
+export { CelTypeExpressionError, CelUnknownTypeNameError, parseTypeExpression, } from "./type-expression.js";
+export type { NominalResolver } from "./type-expression.js";
+export type { CelActivation } from "./activation.js";
+export { BoundedCache } from "./bounded-cache.js";
+export { celMapFromEntries, celMapKeys } from "./cel-map-value.js";
+export { CelEvaluationError, programOfStep } from "./cel-program.js";
+export type { CelProgram, EvaluateOptions } from "./cel-program.js";
+export { ENGINE_VERSION } from "./engine-version.js";
+export { EMITTER_FORMAT_GENERATION, emittedModuleIdentity, emittedModuleKey, emittedModuleRefusal, programsFromEmittedModule, readEmittedHeader, } from "./emitted-module.js";
+export type { EmittedFactory, EmittedHeader, EmittedIdentity, EmittedModule, EmittedModuleStore, EmittedRuntime, StoredEmittedModule, } from "./emitted-module.js";
+export { environmentDigest } from "./environment-digest.js";
+export type { DigestedEnvironment } from "./environment-digest.js";
+/** The whole contract between an emitted module and the runtime it is handed. */
+export { RUNTIME_BINDINGS } from "./js-emitter.js";
+export type { RuntimeBinding } from "./js-emitter.js";
+export { CEL_EVALUATION_CODES, CEL_VALUE_KEYS, CEL_VALUE_TYPE, celError, celNone, celSome, celTypeNameOf, celTypeValue, celUint, isCelBytes, isCelDuration, isCelError, isCelMap, isCelOptional, isCelRecord, isCelTimestamp, isCelTypeValue, isCelUint, literalValue, } from "./cel-value.js";
+export type { CelDuration, CelError, CelEvaluationCode, CelHostValue, CelMap, CelMapKey, CelMapValueEntry, CelOptional, CelRecord, CelTimestamp, CelTypeValue, CelUint, CelValue, CelValueKey, } from "./cel-value.js";
+export { compileTree } from "./closure-backend.js";
+export type { CompiledTree } from "./closure-backend.js";
+export { CALL_SITE_CACHE_CAPACITY, CelCompileError } from "./backend-runtime.js";
+export type { CelStep, CompileTarget, EvaluationFrame, NamespaceDispatch, NamespaceImplementation, } from "./backend-runtime.js";
+export { celAll, celExists, celExistsOne, celFilter, celMapComprehension, } from "./comprehension-runtime.js";
+export type { ComprehensionBody } from "./comprehension-runtime.js";
+export { celDurationFromNanos, durationField, durationNanos, durationNanosFromText, durationOutOfRange, formatDuration, MAX_DURATION_NANOS, MIN_DURATION_NANOS, parseDuration, } from "./duration-value.js";
+export { celHas, celIterable, celLookup, celRead, lookupAbsence, lookupError, MISSING, OUT_OF_RANGE, UNSUPPORTED_CONTAINER, UNSUPPORTED_KEY, } from "./member-read.js";
+export type { Lookup } from "./member-read.js";
+export { celMatches, PATTERN_CACHE_CAPACITY, RE2_FLAG_LETTERS, RE2_PATTERN_ERROR_KINDS, re2Pattern, } from "./regular-expression.js";
+export type { RE2Compiled, RE2PatternRefusal } from "./regular-expression.js";
+export { base64Text, celTypeValueOf, implementationOf, jsonAsCelValue, implementedKeys, optionalOfNonZero, standardConstantValues, typeValueName, } from "./runtime-library.js";
+export type { CelCallContext, CelImplementation } from "./runtime-library.js";
+export { CALL_SITE_DIRECT_ARITY } from "./runtime-library.js";
+export { celTimestamp, celTimestampFromMillis, formatTimestamp, MAX_TIMESTAMP_SECONDS, MIN_TIMESTAMP_SECONDS, parseTimestamp, timestampField, timestampNanos, zonedFields, } from "./timestamp-value.js";
+export { celCompare, celEqual } from "./value-equality.js";
+export { bytesToText, doubleText, textToBytes } from "./value-text.js";
+export { BINDING_FORMS, namespaceMacroBinding, receiverMacroBinding, type ComprehensionBinding, } from "./comprehension-bindings.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,65 @@
+/**
+ * `@telorun/cel` — the CEL language.
+ *
+ * This entry is the front end: reading an expression, the canonical tree it reads
+ * into, writing a tree back as source, and the two questions a consumer asks of a
+ * tree (what it reads, and which namespaced functions it calls). It reaches no
+ * runtime of its own and no host facility — nothing here touches a filesystem, a
+ * clock or a network, so it runs unchanged in a browser.
+ *
+ * It owns CEL and nothing above it: no host's type vocabulary, no host's function
+ * catalog. Those are registered onto the engine by whoever embeds it.
+ */
+export { parseExpression, resolvedUnder } from "./cel-expression.js";
+export { MAX_INT, MAX_UINT, MIN_INT } from "./lexer.js";
+export { CelNamespaceError, namespaceSetsEqual, normalizeNamespaces, RESERVED_NAMESPACES, resolveNamespaces, } from "./namespace-resolution.js";
+export { DEFAULT_PARSE_LIMITS, resolveParseLimits } from "./parse-limits.js";
+export { parseSyntax } from "./parser.js";
+export { qualifiedCalls } from "./qualified-calls.js";
+export { isIdentifierSpelling, isReservedWord, LITERAL_WORDS, OPERATOR_WORDS, RESERVED_WORDS, } from "./reserved-words.js";
+export { rootReferences } from "./root-references.js";
+export { splitDeclaredChain } from "./declared-chain.js";
+export { CelSerializeError, serializeTree } from "./serializer.js";
+export { childNodes, hasUnparsed, walkTree } from "./syntax-tree.js";
+export { treesEqual } from "./tree-equality.js";
+// --- the type system, the registry and the checker -------------------------
+export { admitsNull, assignable, BOOL, BYTES, DOUBLE, DURATION, DYN, formatType, INT, isDyn, isNumeric, listOf, mapOf, NULL, optionalOf, parameterOf, STRING, TIMESTAMP, TYPE, typesEqual, UINT, unify, unionOf, WELL_KNOWN_TYPE_NAMES, withoutNull, withoutParameters, } from "./cel-type.js";
+export { CEL_CHECK_CODES, CelEngineError } from "./check-diagnostic.js";
+export { CelEnvironment, DEFAULT_COMPILED_CACHE_CAPACITY } from "./environment.js";
+export { FunctionRegistry, UNKNOWN_FUNCTION_CANDIDATES } from "./function-registry.js";
+export { fieldMapType, schemaType, TYPE_CONSTRAINING_KEYWORDS, TYPE_KEYWORDS_READ, UNJUDGED_REASONS, } from "./json-schema-type.js";
+export { CelTypeRegistrationError } from "./nominal-type.js";
+export { formatSignature, parseSignature, signatureKey } from "./signature.js";
+export { googleTypeNames, registerStandardLibrary, standardConstants, STANDARD_LIBRARY_GENERATION, standardLibrarySignatures, } from "./standard-library.js";
+// --- the function catalog: the dialect, registered as a host registers one ------
+export { catalogCategories, catalogSignatures, FUNCTION_CATALOG_GENERATION, functionCatalog, registerFunctionCatalog, } from "./function-catalog.js";
+export { catalogGuardedNames, catalogImplementation, catalogImplementedKeys, catalogLiteralCheck, } from "./catalog-runtime.js";
+export { scanJsonPrefix } from "./json-text-scan.js";
+export { civilTimeIn, dateTextIn, daysInMonth, instantOfCivilTime, isoTextIn, knownTimeZone, } from "./zoned-calendar.js";
+export { CelTypeExpressionError, CelUnknownTypeNameError, parseTypeExpression, } from "./type-expression.js";
+export { BoundedCache } from "./bounded-cache.js";
+// `mapKeyIdentity` is deliberately NOT exported: what identifies an entry is the entries
+// map's own business, and publishing the rule is what let a consumer grow a second copy of
+// it. A host reads a map through the member-read seam and walks `entries` for the pairs.
+export { celMapFromEntries, celMapKeys } from "./cel-map-value.js";
+export { CelEvaluationError, programOfStep } from "./cel-program.js";
+// --- the emitter: JavaScript source, its key, and the one store seam --------
+export { ENGINE_VERSION } from "./engine-version.js";
+export { EMITTER_FORMAT_GENERATION, emittedModuleIdentity, emittedModuleKey, emittedModuleRefusal, programsFromEmittedModule, readEmittedHeader, } from "./emitted-module.js";
+export { environmentDigest } from "./environment-digest.js";
+/** The whole contract between an emitted module and the runtime it is handed. */
+export { RUNTIME_BINDINGS } from "./js-emitter.js";
+export { CEL_EVALUATION_CODES, CEL_VALUE_KEYS, CEL_VALUE_TYPE, celError, celNone, celSome, celTypeNameOf, celTypeValue, celUint, isCelBytes, isCelDuration, isCelError, isCelMap, isCelOptional, isCelRecord, isCelTimestamp, isCelTypeValue, isCelUint, literalValue, } from "./cel-value.js";
+export { compileTree } from "./closure-backend.js";
+export { CALL_SITE_CACHE_CAPACITY, CelCompileError } from "./backend-runtime.js";
+export { celAll, celExists, celExistsOne, celFilter, celMapComprehension, } from "./comprehension-runtime.js";
+export { celDurationFromNanos, durationField, durationNanos, durationNanosFromText, durationOutOfRange, formatDuration, MAX_DURATION_NANOS, MIN_DURATION_NANOS, parseDuration, } from "./duration-value.js";
+export { celHas, celIterable, celLookup, celRead, lookupAbsence, lookupError, MISSING, OUT_OF_RANGE, UNSUPPORTED_CONTAINER, UNSUPPORTED_KEY, } from "./member-read.js";
+export { celMatches, PATTERN_CACHE_CAPACITY, RE2_FLAG_LETTERS, RE2_PATTERN_ERROR_KINDS, re2Pattern, } from "./regular-expression.js";
+export { base64Text, celTypeValueOf, implementationOf, jsonAsCelValue, implementedKeys, optionalOfNonZero, standardConstantValues, typeValueName, } from "./runtime-library.js";
+// The bound a host writing an implementation is held to, and what the refusal names.
+export { CALL_SITE_DIRECT_ARITY } from "./runtime-library.js";
+export { celTimestamp, celTimestampFromMillis, formatTimestamp, MAX_TIMESTAMP_SECONDS, MIN_TIMESTAMP_SECONDS, parseTimestamp, timestampField, timestampNanos, zonedFields, } from "./timestamp-value.js";
+export { celCompare, celEqual } from "./value-equality.js";
+export { bytesToText, doubleText, textToBytes } from "./value-text.js";
+export { BINDING_FORMS, namespaceMacroBinding, receiverMacroBinding, } from "./comprehension-bindings.js";

package/dist/integer-arithmetic.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Integer arithmetic: 64-bit, checked, and **never wrapped**.
+ *
+ * CEL's `int` is a signed 64-bit integer and its `uint` an unsigned one. A result
+ * outside the range is an error, not a wrap: an engine that wraps answers a value no
+ * other engine answers, and a manifest that silently computes `-9223372036854775808`
+ * from a sum of positives is worse than one that fails. The vectors pin this as the
+ * domain-keeping answer where the engine being replaced returns a number beyond int64.
+ *
+ * Division truncates toward zero and the modulo takes the dividend's sign, which is
+ * what `BigInt` already does; division and modulo by zero are errors of their own, so a
+ * reader of the code knows which one happened.
+ */
+import { type CelError, type CelUint } from "./cel-value.js";
+import type { SourceRange } from "./syntax-tree.js";
+/** An int result, or the overflow it is outside the range. */
+export declare function intResult(value: bigint, range?: SourceRange): bigint | CelError;
+/** A uint result, or the overflow it is outside the range. */
+export declare function uintResult(value: bigint, range?: SourceRange): CelUint | CelError;
+export declare function intDivide(left: bigint, right: bigint, range?: SourceRange): bigint | CelError;
+export declare function intModulo(left: bigint, right: bigint, range?: SourceRange): bigint | CelError;
+export declare function uintDivide(left: bigint, right: bigint, range?: SourceRange): CelUint | CelError;
+export declare function uintModulo(left: bigint, right: bigint, range?: SourceRange): CelUint | CelError;
+/** Whether a magnitude fits a uint64 — used by the conversions. */
+export declare function fitsUint(value: bigint): boolean;
+export declare function fitsInt(value: bigint): boolean;
+//# sourceMappingURL=integer-arithmetic.d.ts.map

package/dist/integer-arithmetic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integer-arithmetic.d.ts","sourceRoot":"","sources":["../src/integer-arithmetic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAqB,KAAK,QAAQ,EAAE,KAAK,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAEhF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAQpD,8DAA8D;AAC9D,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,MAAM,GAAG,QAAQ,CAG/E;AAED,8DAA8D;AAC9D,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,OAAO,GAAG,QAAQ,CAGjF;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,MAAM,GAAG,QAAQ,CAG7F;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,MAAM,GAAG,QAAQ,CAG7F;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,OAAO,GAAG,QAAQ,CAG/F;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,OAAO,GAAG,QAAQ,CAG/F;AAED,mEAAmE;AACnE,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE/C;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE9C"}