@telorun/cel 0.107.0 → 0.108.0

package/dist/checker.js

@@ -73,6 +73,9 @@ class Checker {
             this.scopes.pop();
         }
     }
+    typeOfPresence(node) {
+        return this.selectType(node, true);
+    }
     // --- the walk -----------------------------------------------------------
     typeOf(node) {
         switch (node.kind) {
@@ -87,7 +90,7 @@ class Checker {
             case "map":
                 return this.mapType(node);
             case "select":
-                return this.selectType(node);
+                return this.selectType(node, node.optional);
             case "index":
                 return this.indexType(node);
             case "unary":
@@ -191,7 +194,13 @@ class Checker {
         }
         return reduced;
     }
-    selectType(node) {
+    /**
+     * `presence` is whether the read asks whether the member is THERE — written `.?b`, or
+     * standing as the argument of `has()`. It decides nothing about a type that is known to
+     * hold no members, which both forms refuse; it decides what a UNION's member-less
+     * branches are, which is the absence case a presence-shaped read answers for.
+     */
+    selectType(node, presence) {
         const qualified = this.qualifiedVariableType(node);
         if (qualified)
             return qualified;
@@ -199,7 +208,7 @@ class Checker {
         if (node.field === "")
             return DYN;
         const guarded = this.checkNullable(node.operand, operand, `.${node.field}`, node.fieldRange);
-        const held = this.memberType(guarded, node.field, node.fieldRange);
+        const held = this.memberType(guarded, node.field, node.fieldRange, presence);
         // Reading through an optional answers an optional, whichever form the read is
         // written in: that is what makes a chain of reads over a value that may be absent
         // stay one expression instead of needing a guard at every step.
@@ -243,13 +252,14 @@ class Checker {
         return this.scopes.some((scope) => scope.has(name));
     }
     /** The type of a named member, reported against whatever the operand turned out to be. */
-    memberType(operand, field, range) {
+    memberType(operand, field, range, presence = false) {
         if (isDyn(operand) || operand.kind === "parameter")
             return DYN;
-        if (operand.kind === "optional")
-            return this.memberType(operand.value, field, range);
+        if (operand.kind === "optional") {
+            return this.memberType(operand.value, field, range, presence);
+        }
         if (operand.kind === "union") {
-            return unionOf(operand.members.map((member) => this.memberType(member, field, range)));
+            return unionOf(presenceBranches(operand, holdsMembers, presence).map((member) => this.memberType(member, field, range, presence)));
         }
         if (operand.kind === "record")
             return this.recordMemberType(operand, field, range);
@@ -277,16 +287,17 @@ class Checker {
         const operand = this.typeOf(node.operand);
         const index = this.typeOf(node.index);
         const guarded = this.checkNullable(node.operand, operand, "[…]", node.range);
-        const held = this.elementType(guarded, index, node);
+        const held = this.elementType(guarded, index, node, node.optional);
         return node.optional || guarded.kind === "optional" ? optionalOf(unwrapOptional(held)) : held;
     }
-    elementType(operand, index, node) {
+    elementType(operand, index, node, presence = false) {
         if (isDyn(operand) || operand.kind === "parameter")
             return DYN;
-        if (operand.kind === "optional")
-            return this.elementType(operand.value, index, node);
+        if (operand.kind === "optional") {
+            return this.elementType(operand.value, index, node, presence);
+        }
         if (operand.kind === "union") {
-            return unionOf(operand.members.map((member) => this.elementType(member, index, node)));
+            return unionOf(presenceBranches(operand, holdsElements, presence).map((member) => this.elementType(member, index, node, presence)));
         }
         if (operand.kind === "list") {
             if (!assignable(index, INT) && !isDyn(index)) {
@@ -471,7 +482,7 @@ class Checker {
     reportCallFailure(node, form, args, receiver, failure) {
         const written = `${node.name}(${describeArguments(args)})`;
         if (failure.reason === "unknown") {
-            this.report("CEL_UNKNOWN_FUNCTION", `no function named ${JSON.stringify(node.name)} is registered`, node.range, this.renameFix(node));
+            this.report("CEL_UNKNOWN_FUNCTION", `no function named ${JSON.stringify(node.name)} is registered${this.closestNames(node.name, form, args.length)}`, node.range, this.renameFix(node));
             return;
         }
         if (failure.reason === "wrong-form") {
@@ -487,6 +498,28 @@ class Checker {
         this.report(mismatch ? "CEL_TYPE_ARGUMENT_MISMATCH" : "CEL_TYPE_ERROR", mismatch ??
             `no overload of ${JSON.stringify(node.name)} takes ${form === "receiver" ? `${formatType(receiver ?? DYN)}.` : ""}${written}: ${describeCandidates(failure.candidates)}`, node.range);
     }
+    /**
+     * What a call on an unregistered name is offered instead: the registered names that
+     * accept its form and arity, nearest first, as a clause to hang off the refusal.
+     *
+     * **The alternatives belong in the MESSAGE, and the fix stays singular.** A reader of
+     * `no('x')` is one name away from the five functions that would have worked, and the
+     * engine this one replaces said so; losing it is a real loss of help. A list of five
+     * repairs, though, is not a repair — an editor applying one would be guessing which
+     * function the author meant — so the single rename fix is still offered only where
+     * exactly one name is a case-insensitive match.
+     *
+     * It names no command and no tool: which listing a host offers is the host's, and an
+     * engine embedded in one with no CLI would be pointing at nothing.
+     */
+    closestNames(name, form, arity) {
+        const candidates = this.context.registry.candidateNames(name, form, arity);
+        if (candidates.length === 0)
+            return "";
+        const written = arity === 0 ? "no arguments" : arity === 1 ? "1 argument" : `${arity} arguments`;
+        const shape = form === "receiver" ? `written on a value with ${written}` : `taking ${written}`;
+        return ` — the closest ${shape}: ${candidates.join(", ")}`;
+    }
     /** The one registered name this call might have meant, as a whole-source repair. */
     renameFix(node) {
         const wanted = node.name.toLowerCase();
@@ -550,6 +583,7 @@ class Checker {
                 namespace: node.namespace,
                 arity: args.length,
                 range: node.range,
+                argumentTypes: args.map((type) => formatType(withoutParameters(type))),
             });
             // An OPEN namespace declares only part of what it reaches, so a name it does not
             // carry is not this engine's to refuse — it is listed and left to the host.
@@ -565,12 +599,23 @@ class Checker {
             namespace: node.namespace,
             arity: args.length,
             range: node.range,
+            argumentTypes: args.map((type) => formatType(withoutParameters(type))),
             ...(declared.signature === undefined ? {} : { signature: declared.signature }),
             returns: formatType(withoutParameters(declared.returns)),
             deterministic: declared.deterministic ?? true,
             hostBacked: declared.hostBacked ?? false,
             ...(declared.throws ? { throws: declared.throws } : {}),
         });
+        // A type the host named and its own registry does not carry: the declaration stands,
+        // reads `dyn` where that type stood, and the disagreement is a verdict HERE — this is
+        // the only place the name has a range.
+        const unregistered = declared.unregisteredTypes ?? [];
+        if (unregistered.length > 0) {
+            const names = unregistered.map((name) => JSON.stringify(name)).join(", ");
+            this.report("CEL_TYPE_ERROR", unregistered.length === 1
+                ? `${qualified} is declared over the type ${names}, and no type is registered under that name`
+                : `${qualified} is declared over the types ${names}, and no type is registered under those names`, node.range);
+        }
         // Parameters withheld: the host judges arity and arguments against its own, richer
         // signature grammar, and this engine types the result and says nothing else.
         if (parameters === undefined)
@@ -598,6 +643,46 @@ function isNullTest(args) {
     const isNull = (type) => type.kind === "primitive" && type.name === "null";
     return (isNull(left) && admitsNull(right)) || (isNull(right) && admitsNull(left));
 }
+/**
+ * Which branches of a union a read is judged against.
+ *
+ * A **presence-shaped** read — `a.?b`, `a[?k]`, `has(a.b)` — asks whether the member is
+ * THERE, so a branch that can hold no member at all is the absence case it answers
+ * `optional.none()` / `false` for at runtime, not a mistake in the expression: that is how
+ * a two-shape field is discriminated without a type test. Where **no** branch can hold one
+ * the read is judged against them all, so an operand that is known to hold no members is
+ * still refused in the presence form exactly as in the plain one.
+ */
+function presenceBranches(union, holds, presence) {
+    if (!presence)
+        return union.members;
+    const holding = union.members.filter(holds);
+    return holding.length > 0 ? holding : union.members;
+}
+/** Whether a type can hold a named member at all — what `memberType` reads one of. */
+function holdsMembers(type) {
+    if (isDyn(type) || type.kind === "parameter")
+        return true;
+    if (type.kind === "record" || type.kind === "map")
+        return true;
+    if (type.kind === "optional")
+        return holdsMembers(type.value);
+    if (type.kind === "union")
+        return type.members.some(holdsMembers);
+    return false;
+}
+/** Whether a type can hold an element at all — what `elementType` reads one of. */
+function holdsElements(type) {
+    if (isDyn(type) || type.kind === "parameter")
+        return true;
+    if (type.kind === "record" || type.kind === "map" || type.kind === "list")
+        return true;
+    if (type.kind === "optional")
+        return holdsElements(type.value);
+    if (type.kind === "union")
+        return type.members.some(holdsElements);
+    return false;
+}
 /** An optional of an optional is one optional; a chain of reads does not nest them. */
 function unwrapOptional(type) {
     return type.kind === "optional" ? unwrapOptional(type.value) : type;

package/dist/closure-backend.js

@@ -138,7 +138,9 @@ class Compiler {
         }));
         const { range } = node;
         return (frame) => {
-            const pairs = [];
+            // Flat — key, value, key, value — so a literal of n entries costs one allocation
+            // rather than one per entry. The emitter writes the same call.
+            const flat = [];
             for (const entry of entries) {
                 const key = entry.key(frame);
                 if (isCelError(key))
@@ -147,16 +149,16 @@ class Compiler {
                 if (isCelError(value))
                     return value;
                 if (!entry.optional) {
-                    pairs.push([key, value]);
+                    flat.push(key, value);
                     continue;
                 }
                 const held = optionalEntry(value, range);
                 if (isCelError(held))
                     return held;
                 if (held.present)
-                    pairs.push([key, held.held]);
+                    flat.push(key, held.held);
             }
-            return celMapFromEntries(pairs, range);
+            return celMapFromEntries(flat, range);
         };
     }
     // --- member reads -------------------------------------------------------
@@ -243,21 +245,70 @@ class Compiler {
     }
     /**
      * One dispatch: evaluate the arguments, carry the first error out, then hand the values
-     * to the site, which resolves the overload on their own types.
+     * to the site **positionally**, which resolves the overload on their own types. The arity
+     * is the dispatch key's and known at compile time, so the step is chosen once here and no
+     * argument array is built per call — the same choice the emitter writes into its text.
      */
     callStep(name, form, args, range) {
         const site = callSiteOf(this.target, name, form, range);
-        const count = args.length;
-        return (frame) => {
-            const values = new Array(count);
-            for (let at = 0; at < count; at += 1) {
-                const value = args[at](frame);
-                if (isCelError(value))
-                    return value;
-                values[at] = value;
+        const [first, second, third, fourth] = args;
+        switch (args.length) {
+            case 0:
+                return () => site.call0();
+            case 1:
+                return (frame) => {
+                    const a = first(frame);
+                    return isCelError(a) ? a : site.call1(a);
+                };
+            case 2:
+                return (frame) => {
+                    const a = first(frame);
+                    if (isCelError(a))
+                        return a;
+                    const b = second(frame);
+                    return isCelError(b) ? b : site.call2(a, b);
+                };
+            case 3:
+                return (frame) => {
+                    const a = first(frame);
+                    if (isCelError(a))
+                        return a;
+                    const b = second(frame);
+                    if (isCelError(b))
+                        return b;
+                    const c = third(frame);
+                    return isCelError(c) ? c : site.call3(a, b, c);
+                };
+            case 4:
+                return (frame) => {
+                    const a = first(frame);
+                    if (isCelError(a))
+                        return a;
+                    const b = second(frame);
+                    if (isCelError(b))
+                        return b;
+                    const c = third(frame);
+                    if (isCelError(c))
+                        return c;
+                    const d = fourth(frame);
+                    return isCelError(d) ? d : site.call4(a, b, c, d);
+                };
+            default: {
+                // A call written wider than any signature may be. Its arguments are still evaluated
+                // in order, so an error in one carries out ahead of the refusal.
+                const count = args.length;
+                return (frame) => {
+                    const values = new Array(count);
+                    for (let at = 0; at < count; at += 1) {
+                        const held = args[at](frame);
+                        if (isCelError(held))
+                            return held;
+                        values[at] = held;
+                    }
+                    return site.call(values);
+                };
             }
-            return site.call(values);
-        };
+        }
     }
     qualifiedCallStep(node, scope) {
         const args = node.args.map((argument) => this.compile(argument, scope));

package/dist/duration-value.d.ts

@@ -42,6 +42,17 @@ export declare function durationNanos(value: CelDuration): bigint;
  * `ns`, `us`, `ms`, `s`, `m` and `h` (`1h30m`, `1.5s`, `-10m`).
  */
 export declare function parseDuration(text: string, range?: SourceRange): CelDuration | CelError;
+/**
+ * The same text as a TOTAL OF NANOSECONDS, with no range applied.
+ *
+ * The grammar and the range are separate questions, and a consumer outside CEL has the same
+ * grammar with a different range: protobuf's `google.protobuf.Duration` reaches ±10,000
+ * years, which **cannot be held in an int64 of nanoseconds at all**, so a reader that must
+ * carry one (a journal entry, a value off a transport) cannot go through `parseDuration` and
+ * would otherwise restate this grammar. It answers an unbounded `bigint`; applying a range
+ * is the caller's, and `celDurationFromNanos` is what applies CEL's.
+ */
+export declare function durationNanosFromText(text: string, range?: SourceRange): bigint | CelError;
 /** Seconds with an `s` suffix, the fraction trimmed to what it carries. */
 export declare function formatDuration(value: CelDuration): string;
 /** Which field of a duration a getter answers. */

package/dist/duration-value.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"duration-value.d.ts","sourceRoot":"","sources":["../src/duration-value.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAA4B,KAAK,WAAW,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC3F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,8EAA8E;AAC9E,eAAO,MAAM,kBAAkB,uBAA6B,CAAC;AAC7D,eAAO,MAAM,kBAAkB,wBAA8B,CAAC;AAI9D,kEAAkE;AAClE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,WAAW,GAAG,QAAQ,CAS/F;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,QAAQ,GAAG,SAAS,CAIhG;AAED,+EAA+E;AAC/E,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAExD;AAeD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,WAAW,GAAG,QAAQ,CA4BvF;AAED,2EAA2E;AAC3E,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAQzD;AAED,kDAAkD;AAClD,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,YAAY,GAAG,YAAY,GAAG,iBAAiB,CAAC;AAEzF;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,aAAa,GAAG,MAAM,CAY9E"}
+{"version":3,"file":"duration-value.d.ts","sourceRoot":"","sources":["../src/duration-value.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAwC,KAAK,WAAW,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACvG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,8EAA8E;AAC9E,eAAO,MAAM,kBAAkB,uBAA6B,CAAC;AAC7D,eAAO,MAAM,kBAAkB,wBAA8B,CAAC;AAI9D,kEAAkE;AAClE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,WAAW,GAAG,QAAQ,CAS/F;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,QAAQ,GAAG,SAAS,CAIhG;AAED,+EAA+E;AAC/E,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAExD;AAeD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,WAAW,GAAG,QAAQ,CAGvF;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,MAAM,GAAG,QAAQ,CA4B1F;AAED,2EAA2E;AAC3E,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAQzD;AAED,kDAAkD;AAClD,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,YAAY,GAAG,YAAY,GAAG,iBAAiB,CAAC;AAEzF;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,aAAa,GAAG,MAAM,CAY9E"}

package/dist/duration-value.js

@@ -22,7 +22,7 @@
  * It is written as seconds with an `s` suffix (`1000000s`, `-1.5s`), which is cel-spec's
  * own spelling, and the one plain encoding a duration has wherever it is written down.
  */
-import { celError, CEL_VALUE_TYPE } from "./cel-value.js";
+import { celError, CEL_VALUE_TYPE, isCelError } from "./cel-value.js";
 /** The widest and narrowest total a duration holds, in nanoseconds: int64. */
 export const MAX_DURATION_NANOS = 9223372036854775807n;
 export const MIN_DURATION_NANOS = -9223372036854775808n;
@@ -69,6 +69,20 @@ const PART = /([0-9]*)(?:\.([0-9]*))?(ns|us|µs|μs|ms|s|m|h)/g;
  * `ns`, `us`, `ms`, `s`, `m` and `h` (`1h30m`, `1.5s`, `-10m`).
  */
 export function parseDuration(text, range) {
+    const total = durationNanosFromText(text, range);
+    return isCelError(total) ? total : celDurationFromNanos(total, range);
+}
+/**
+ * The same text as a TOTAL OF NANOSECONDS, with no range applied.
+ *
+ * The grammar and the range are separate questions, and a consumer outside CEL has the same
+ * grammar with a different range: protobuf's `google.protobuf.Duration` reaches ±10,000
+ * years, which **cannot be held in an int64 of nanoseconds at all**, so a reader that must
+ * carry one (a journal entry, a value off a transport) cannot go through `parseDuration` and
+ * would otherwise restate this grammar. It answers an unbounded `bigint`; applying a range
+ * is the caller's, and `celDurationFromNanos` is what applies CEL's.
+ */
+export function durationNanosFromText(text, range) {
     const refuse = () => celError("invalid_conversion", `${JSON.stringify(text)} is not a duration`, range);
     let body = text;
     let negative = false;
@@ -77,7 +91,7 @@ export function parseDuration(text, range) {
         body = body.slice(1);
     }
     if (body === "0")
-        return celDurationFromNanos(0n, range);
+        return 0n;
     if (body === "")
         return refuse();
     PART.lastIndex = 0;
@@ -99,7 +113,7 @@ export function parseDuration(text, range) {
     }
     if (at !== body.length)
         return refuse();
-    return celDurationFromNanos(negative ? -total : total, range);
+    return negative ? -total : total;
 }
 /** Seconds with an `s` suffix, the fraction trimmed to what it carries. */
 export function formatDuration(value) {

package/dist/emitted-module.d.ts

@@ -65,7 +65,7 @@ import type { CelNode } from "./syntax-tree.js";
  * code the emitter writes for a corpus drawn from the package's own total enumerations, beside
  * this number, so a change to that text fails naming the bump it owes.
  */
-export declare const EMITTER_FORMAT_GENERATION = 1;
+export declare const EMITTER_FORMAT_GENERATION = 2;
 /**
  * What an emitted module declares about itself in its `integrity` export: its provenance and
  * its own key. These are the four a loaded module can be held to, because checking them needs

package/dist/emitted-module.js

@@ -72,7 +72,7 @@ import { sha256OfText } from "./sha256.js";
  * code the emitter writes for a corpus drawn from the package's own total enumerations, beside
  * this number, so a change to that text fails naming the bump it owes.
  */
-export const EMITTER_FORMAT_GENERATION = 1;
+export const EMITTER_FORMAT_GENERATION = 2;
 /** The prefix of the one line a stored module's header is read from. */
 const HEADER_PREFIX = "//@telo.cel ";
 // --- the key and the header ------------------------------------------------

package/dist/engine-version.d.ts

@@ -1,3 +1,3 @@
 /** This build of the CEL engine, as an emitted module names it. */
-export declare const ENGINE_VERSION = "0.107.0";
+export declare const ENGINE_VERSION = "0.108.0";
 //# sourceMappingURL=engine-version.d.ts.map

package/dist/engine-version.js

@@ -5,4 +5,4 @@
 // It is a component of every emitted module's cache key and a field of its
 // integrity header, so a module one build wrote is never run by another.
 /** This build of the CEL engine, as an emitted module names it. */
-export const ENGINE_VERSION = "0.107.0";
+export const ENGINE_VERSION = "0.108.0";

package/dist/environment.d.ts

@@ -134,6 +134,14 @@ export interface SchemaRegistrationReport {
  * by construction rather than by a flag: a declaration that carried parameters and asked for
  * them to be ignored would hold a list nothing reads, which no reader can tell from a list
  * that is simply wrong.
+ *
+ * **A type name this environment registers nothing under is accepted and reads `dyn`**, and
+ * every call to such a function carries a ranged `CEL_TYPE_ERROR` naming it. A declaration
+ * is a host's own data — a module function's declared result out of a manifest — so a typo
+ * in one is the host disagreeing with its own registry, which is reported where there is a
+ * range rather than thrown where there is none. A type registered AFTER a declaration naming
+ * it does not change that declaration: a declaration resolves its types once, when it is
+ * made.
  */
 export type NamespaceFunctionDeclaration = ({
     readonly signature: string;

package/dist/environment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../src/environment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAGpE,OAAO,KAAK,EAEV,aAAa,EACb,kBAAkB,EAClB,cAAc,EACd,mBAAmB,EACpB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAG7C,OAAO,KAAK,EAAE,WAAW,EAAqB,MAAM,cAAc,CAAC;AAGnE,OAAO,KAAK,EACV,gBAAgB,EAChB,cAAc,EACd,wBAAwB,EACxB,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,KAAK,EAAE,qBAAqB,EAAkB,MAAM,mBAAmB,CAAC;AAO/E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAOrE,MAAM,WAAW,qBAAqB;IACpC;;;;;;OAMG;IACH,QAAQ,CAAC,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAC3C;;;OAGG;IACH,QAAQ,CAAC,4BAA4B,CAAC,EAAE,OAAO,CAAC;IAChD,uFAAuF;IACvF,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IACvC;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,kBAAkB,CAAC;IAChD,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;IAC1C,iEAAiE;IACjE,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IACnC,4DAA4D;IAC5D,QAAQ,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAC;CACzC;AAED,MAAM,MAAM,eAAe,GACvB,MAAM,GACN,OAAO,GACP;IAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAA;CAAE,GAC/D;IACE,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC;CACpC,CAAC;AAEN,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,6EAA6E;IAC7E,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,6FAA6F;IAC7F,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,SAAS,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAClD,QAAQ,CAAC,SAAS,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAClD,QAAQ,CAAC,KAAK,EAAE,SAAS,qBAAqB,EAAE,CAAC;IACjD,QAAQ,CAAC,UAAU,EAAE,SAAS,gBAAgB,EAAE,CAAC;CAClD;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,wBAAwB;IACvC,iCAAiC;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACjD,yFAAyF;IACzF,QAAQ,CAAC,SAAS,EAAE,SAAS,wBAAwB,EAAE,CAAC;CACzD;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,4BAA4B,GAAG,CACvC;IAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,KAAK,CAAA;CAAE,GAC/E;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,KAAK,CAAA;CAAE,CAC5F,GAAG;IACF,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC,CAAC;AAEF,qDAAqD;AACrD,MAAM,WAAW,gBAAgB;IAC/B;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;CACzB;AAkBD,sFAAsF;AACtF,eAAO,MAAM,+BAA+B,MAAM,CAAC;AAEnD,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;IAC5C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA8B;IACxD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8B;IACpD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA8C;IACjF,+FAA+F;IAC/F,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAc;IAC7C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwB;IAClD,iEAAiE;IACjE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmC;IAC5D,QAAQ,CAAC,OAAO,EAAE,QAAQ,CACxB,IAAI,CACF,qBAAqB,EACrB,yBAAyB,GAAG,8BAA8B,GAAG,qBAAqB,CACnF,CACF,GACC,qBAAqB,CAAC;gBAEZ,OAAO,GAAE,qBAA0B,EAAE,SAAS,CAAC,EAAE,cAAc;IAuC3E,uEAAuE;IACvE,KAAK,CAAC,OAAO,GAAE,qBAA0B,GAAG,cAAc;IAM1D;;;;;;;OAOG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,EAAE,QAAQ,GAAE,gBAAqB,GAAG,IAAI;IAMzF,sFAAsF;IACtF,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,GAAG,OAAO;IAMzD,wEAAwE;IACxE,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAM1C,qFAAqF;IACrF,gBAAgB,CACd,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,gBAAqB,GAC9B,IAAI;IAcP,gBAAgB,CACd,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,eAAe,EAC5B,QAAQ,GAAE;QAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO,GAC/C,IAAI;IAcP,6EAA6E;IAC7E,gBAAgB,CACd,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,eAAe,EAC5B,QAAQ,GAAE;QAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO,GAC/C,IAAI;IAUP,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIlC;;;OAGG;IACH,aAAa,IAAI,SAAS,wBAAwB,EAAE;IAapD,sFAAsF;IACtF,YAAY,CAAC,UAAU,EAAE,qBAAqB,GAAG,IAAI;IAiCrD;;;;OAIG;IACH,iBAAiB,CACf,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,SAAS,CAAC,MAAM,GAAG,4BAA4B,CAAC,EAAO,EAClE,OAAO,GAAE,gBAAqB,GAC7B,IAAI;IA2CP,sDAAsD;IACtD,UAAU,IAAI,SAAS,MAAM,EAAE;IAM/B,iEAAiE;IACjE,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa;IAQpC;;;;OAIG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,WAAW;IAsBlD;;;;;;;OAOG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,UAAU;IASnD,6DAA6D;IAC7D,QAAQ,CACN,MAAM,EAAE,MAAM,GAAG,aAAa,EAC9B,UAAU,CAAC,EAAE,aAAa,EAC1B,OAAO,CAAC,EAAE,eAAe,GACxB,QAAQ;IAMX;;;;;;;;OAQG;IACH,IAAI,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,aAAa;IAI/C;;;;OAIG;IACH,aAAa,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,kBAAkB,GAAG,mBAAmB;IAYzF,yEAAyE;IACzE,cAAc,IAAI,cAAc;IAIhC;;;;OAIG;IACH,MAAM,IAAI,MAAM;IAIhB,OAAO,CAAC,aAAa;IAIrB,kFAAkF;IAClF,OAAO,CAAC,MAAM;IAUd;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAgBvB,OAAO,CAAC,oBAAoB;IAI5B;;;;OAIG;IACH,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO;IAKxC,mEAAmE;IACnE,WAAW,IAAI,WAAW;IA8C1B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAU9B;IAEF,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,WAAW;IAInB,iFAAiF;IACjF,OAAO,CAAC,MAAM;CA6Bf"}
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../src/environment.ts"],"names":[],"mappings":"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"}

package/dist/environment.js

@@ -23,7 +23,7 @@ import { compileExpression } from "./cel-program.js";
 import { emitModule, emitterRuntime, storedEmittedModule } from "./emitted-module.js";
 import { environmentDigest } from "./environment-digest.js";
 import { CEL_VALUE_KEYS } from "./cel-value.js";
-import { formatType } from "./cel-type.js";
+import { DYN, formatType } from "./cel-type.js";
 import { CelEngineError } from "./check-diagnostic.js";
 import { checkExpression } from "./checker.js";
 import { FunctionRegistry } from "./function-registry.js";
@@ -208,8 +208,23 @@ export class CelEnvironment {
                 ...(entry.hostBacked === undefined ? {} : { hostBacked: entry.hostBacked }),
                 ...(entry.throws === undefined ? {} : { throws: entry.throws }),
             };
+            // A name this environment registers no type under is RECORDED and read as `dyn`,
+            // never thrown: a namespace declaration is a host's own data — a module function's
+            // declared result out of a manifest — so a typo there would otherwise be a crash
+            // with no line, and the consumer that knows where it was written is the one that
+            // can anchor the diagnostic. The checker reports it at each call.
+            const unregistered = [];
+            const resolver = (named, args) => {
+                const resolved = this.nominalResolver(named, args);
+                if (resolved)
+                    return resolved;
+                if (!unregistered.includes(named))
+                    unregistered.push(named);
+                return DYN;
+            };
+            const recorded = () => (unregistered.length > 0 ? { unregisteredTypes: [...unregistered] } : {});
             if (entry.signature !== undefined) {
-                const signature = parseSignature(entry.signature, this.nominalResolver);
+                const signature = parseSignature(entry.signature, resolver);
                 if (signature.form !== "global") {
                     throw new CelTypeRegistrationError(`a namespaced function is declared without a receiver: ${JSON.stringify(entry.signature)}`);
                 }
@@ -218,15 +233,15 @@ export class CelEnvironment {
                     returns: signature.returns,
                     parameters: signature.parameters,
                     signature: formatSignature(signature),
+                    ...recorded(),
                     ...flags,
                 });
                 continue;
             }
             declared.set(entry.name, {
                 name: entry.name,
-                returns: typeof entry.returns === "string"
-                    ? parseTypeExpression(entry.returns, this.nominalResolver)
-                    : entry.returns,
+                returns: typeof entry.returns === "string" ? parseTypeExpression(entry.returns, resolver) : entry.returns,
+                ...recorded(),
                 ...flags,
             });
         }

package/dist/function-registry.d.ts

@@ -36,6 +36,15 @@ export type ResolutionFailure =
     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. */
@@ -54,11 +63,42 @@ export declare class FunctionRegistry {
     /** 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.

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

@@ -1 +1 @@
-{"version":3,"file":"function-registry.d.ts","sourceRoot":"","sources":["../src/function-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAG/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,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;IAUxE,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;;;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,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;AAED,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"}
+{"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"}