@telorun/cel 0.107.0 → 0.109.0

package/dist/function-registry.js

@@ -14,8 +14,20 @@
  * classifier had to re-derive the cause after the fact. The checker decides it here,
  * once, with the candidates it considered.
  */
-import { assignable, DYN, formatType, isDyn } from "./cel-type.js";
+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) {
@@ -27,6 +39,13 @@ export class FunctionRegistry {
     }
     /** 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);
@@ -69,6 +88,38 @@ export class FunctionRegistry {
     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.
@@ -87,11 +138,38 @@ export class FunctionRegistry {
         const exact = this.match(viable, args, receiver, false);
         if (exact)
             return exact;
-        const loose = this.match(viable, args, receiver, true);
+        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;
@@ -180,6 +258,31 @@ export function substitute(type, bindings) {
             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(", ");

package/dist/index.d.ts

@@ -36,7 +36,7 @@ export type { CelCheckCode, CelCheckDiagnostic, CelDiagnosticFix, CelEngineError
 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 } from "./function-registry.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";
@@ -55,11 +55,11 @@ 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, parseTypeExpression } from "./type-expression.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, mapKeyIdentity } from "./cel-map-value.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";
@@ -71,21 +71,23 @@ export type { DigestedEnvironment } from "./environment-digest.js";
 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, CelMapValueEntry, CelOptional, CelRecord, CelTimestamp, CelTypeValue, CelUint, CelValue, CelValueKey, } 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, } 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, durationOutOfRange, formatDuration, MAX_DURATION_NANOS, MIN_DURATION_NANOS, parseDuration, } from "./duration-value.js";
-export { celHas, celIterable, celLookup, celRead, lookupError, MISSING, OUT_OF_RANGE, UNSUPPORTED_CONTAINER, UNSUPPORTED_KEY, } from "./member-read.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 { celTimestamp, formatTimestamp, MAX_TIMESTAMP_SECONDS, MIN_TIMESTAMP_SECONDS, parseTimestamp, timestampField, timestampNanos, zonedFields, } from "./timestamp-value.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

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

package/dist/index.js

@@ -26,7 +26,7 @@ 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 { CEL_CHECK_CODES, CelEngineError } from "./check-diagnostic.js";
 export { CelEnvironment, DEFAULT_COMPILED_CACHE_CAPACITY } from "./environment.js";
-export { FunctionRegistry } from "./function-registry.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";
@@ -36,9 +36,12 @@ export { catalogCategories, catalogSignatures, FUNCTION_CATALOG_GENERATION, func
 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, parseTypeExpression } from "./type-expression.js";
+export { CelTypeExpressionError, CelUnknownTypeNameError, parseTypeExpression, } from "./type-expression.js";
 export { BoundedCache } from "./bounded-cache.js";
-export { celMapFromEntries, celMapKeys, mapKeyIdentity } from "./cel-map-value.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";
@@ -50,10 +53,13 @@ export { CEL_EVALUATION_CODES, CEL_VALUE_KEYS, CEL_VALUE_TYPE, celError, celNone
 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, durationOutOfRange, formatDuration, MAX_DURATION_NANOS, MIN_DURATION_NANOS, parseDuration, } from "./duration-value.js";
-export { celHas, celIterable, celLookup, celRead, lookupError, MISSING, OUT_OF_RANGE, UNSUPPORTED_CONTAINER, UNSUPPORTED_KEY, } from "./member-read.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";
-export { celTimestamp, formatTimestamp, MAX_TIMESTAMP_SECONDS, MIN_TIMESTAMP_SECONDS, parseTimestamp, timestampField, timestampNanos, zonedFields, } from "./timestamp-value.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/js-emitter.d.ts

@@ -93,8 +93,9 @@ export declare class ModuleEmitter {
     private anyCall;
     /**
      * One dispatch: evaluate the arguments, carry the first error out, then hand the values to
-     * the site. The site is hoisted, so it is built once per loaded module and holds the
-     * overloads it resolved — exactly as a compiled closure's does.
+     * the site **positionally**. The site is hoisted, so it is built once per loaded module and
+     * holds the overloads it resolved — exactly as a compiled closure's does. The arity is the
+     * dispatch key's, so the entry point is chosen here and no argument array is built.
      */
     private call;
     private qualifiedCall;

package/dist/js-emitter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"js-emitter.d.ts","sourceRoot":"","sources":["../src/js-emitter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAI9B,OAAO,KAAK,EAAc,OAAO,EAA8B,MAAM,kBAAkB,CAAC;AAExF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,mYA0BnB,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AA2C/D;;;;;GAKG;AACH,qBAAa,aAAa;IAMZ,OAAO,CAAC,QAAQ,CAAC,MAAM;IALnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgB;IACxC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6B;IAC3D,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,QAAQ,CAAK;gBAEQ,MAAM,EAAE,aAAa;IAElD,sFAAsF;IACtF,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM;IAMnC,qFAAqF;IACrF,OAAO,CAAC,WAAW;IAQnB,4EAA4E;IAC5E,YAAY,IAAI,SAAS,MAAM,EAAE;IAIjC,OAAO,CAAC,KAAK;IASb,OAAO,CAAC,KAAK;IAIb;;;OAGG;IACH,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,IAAI;IA8BZ;;;;OAIG;IACH,OAAO,CAAC,OAAO;IAqBf,OAAO,CAAC,KAAK;IAQb;;;;;OAKG;IACH,OAAO,CAAC,KAAK;IAsBb,OAAO,CAAC,MAAM;IAYd,OAAO,CAAC,KAAK;IAiBb,OAAO,CAAC,IAAI;IA8BZ,OAAO,CAAC,GAAG;IA+BX;;;;;OAKG;IACH,OAAO,CAAC,MAAM;IA4Bd,OAAO,CAAC,WAAW;IAkBnB,OAAO,CAAC,OAAO;IAef;;;;OAIG;IACH,OAAO,CAAC,IAAI;IAaZ,OAAO,CAAC,aAAa;IA4BrB,OAAO,CAAC,KAAK;IAmBb,uFAAuF;IACvF,OAAO,CAAC,GAAG;IAkBX,OAAO,CAAC,OAAO;IA0Bf,4EAA4E;IAC5E,OAAO,CAAC,iBAAiB;IAczB,gFAAgF;IAChF,OAAO,CAAC,eAAe;IA8BvB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAuCrB,4FAA4F;IAC5F,OAAO,CAAC,IAAI;IAQZ;;;;;OAKG;IACH,OAAO,CAAC,QAAQ;CAYjB;AAgCD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoB/C"}
+{"version":3,"file":"js-emitter.d.ts","sourceRoot":"","sources":["../src/js-emitter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAK9B,OAAO,KAAK,EAAc,OAAO,EAA8B,MAAM,kBAAkB,CAAC;AAExF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,mYA0BnB,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AA2C/D;;;;;GAKG;AACH,qBAAa,aAAa;IAMZ,OAAO,CAAC,QAAQ,CAAC,MAAM;IALnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgB;IACxC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6B;IAC3D,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,QAAQ,CAAK;gBAEQ,MAAM,EAAE,aAAa;IAElD,sFAAsF;IACtF,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM;IAMnC,qFAAqF;IACrF,OAAO,CAAC,WAAW;IAQnB,4EAA4E;IAC5E,YAAY,IAAI,SAAS,MAAM,EAAE;IAIjC,OAAO,CAAC,KAAK;IASb,OAAO,CAAC,KAAK;IAIb;;;OAGG;IACH,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,IAAI;IA8BZ;;;;OAIG;IACH,OAAO,CAAC,OAAO;IAqBf,OAAO,CAAC,KAAK;IAQb;;;;;OAKG;IACH,OAAO,CAAC,KAAK;IAsBb,OAAO,CAAC,MAAM;IAYd,OAAO,CAAC,KAAK;IAiBb,OAAO,CAAC,IAAI;IA8BZ,OAAO,CAAC,GAAG;IA+BX;;;;;OAKG;IACH,OAAO,CAAC,MAAM;IA4Bd,OAAO,CAAC,WAAW;IAkBnB,OAAO,CAAC,OAAO;IAef;;;;;OAKG;IACH,OAAO,CAAC,IAAI;IAmBZ,OAAO,CAAC,aAAa;IA4BrB,OAAO,CAAC,KAAK;IAmBb,uFAAuF;IACvF,OAAO,CAAC,GAAG;IAkBX,OAAO,CAAC,OAAO;IA0Bf,4EAA4E;IAC5E,OAAO,CAAC,iBAAiB;IAczB,gFAAgF;IAChF,OAAO,CAAC,eAAe;IA8BvB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAuCrB,4FAA4F;IAC5F,OAAO,CAAC,IAAI;IAQZ;;;;;OAKG;IACH,OAAO,CAAC,QAAQ;CAYjB;AAgCD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoB/C"}

package/dist/js-emitter.js

@@ -30,6 +30,7 @@ import { CelCompileError, plainMemberChain, prefixCandidates, } from "./backend-
 import { namespaceMacroBinding, receiverMacroBinding } from "./comprehension-bindings.js";
 import { splitDeclaredChain } from "./declared-chain.js";
 import { isMacroCall } from "./macro-check.js";
+import { CALL_SITE_DIRECT_ARITY } from "./runtime-library.js";
 /**
  * The names an emitted module destructures from the runtime it is handed, in the order it
  * destructures them. It is the module's whole contract with the engine: `emitterRuntime`
@@ -291,8 +292,8 @@ export class ModuleEmitter {
             const kept = entry.optional ? fn.next() : undefined;
             const written = kept
                 ? `(${kept} = optionalEntry(${value}, ${at}), isCelError(${kept}) ? ${kept} : ` +
-                    `(${kept}.present && ${out}.push([${key}, ${kept}.held]), ${body}))`
-                : `(${out}.push([${key}, ${value}]), ${body})`;
+                    `(${kept}.present && ${out}.push(${key}, ${kept}.held), ${body}))`
+                : `(${out}.push(${key}, ${value}), ${body})`;
             body =
                 `(${key} = ${entry.key}, isCelError(${key}) ? ${key} : ` +
                     `(${value} = ${entry.value}, isCelError(${value}) ? ${value} : ${written}))`;
@@ -344,12 +345,17 @@ export class ModuleEmitter {
     }
     /**
      * One dispatch: evaluate the arguments, carry the first error out, then hand the values to
-     * the site. The site is hoisted, so it is built once per loaded module and holds the
-     * overloads it resolved — exactly as a compiled closure's does.
+     * the site **positionally**. The site is hoisted, so it is built once per loaded module and
+     * holds the overloads it resolved — exactly as a compiled closure's does. The arity is the
+     * dispatch key's, so the entry point is chosen here and no argument array is built.
      */
     call(name, form, args, range, fn) {
         const site = this.hoist(`callSite(${textSource(name)}, ${textSource(form)}, ${this.range(range)})`);
-        return this.carrying(args, fn, (values) => `${site}.call([${values.join(", ")}])`);
+        // A call written wider than the bound takes the array form — the arity is the SOURCE's,
+        // so a width no signature can declare is still something an author may write.
+        return this.carrying(args, fn, (values) => values.length <= CALL_SITE_DIRECT_ARITY
+            ? `${site}.call${values.length}(${values.join(", ")})`
+            : `${site}.call([${values.join(", ")}])`);
     }
     qualifiedCall(node, scope, fn) {
         const args = node.args.map((argument) => this.node(argument, scope, fn));

package/dist/macro-check.d.ts

@@ -21,6 +21,14 @@ export interface MacroHost {
     typeOf(node: CelNode): CelType;
     /** The type of a subexpression with extra names in scope. */
     typeOfBinding(node: CelNode, bindings: ReadonlyMap<string, CelType>): CelType;
+    /**
+     * The type of a select read as a question about PRESENCE — `has()`'s argument. It is
+     * the same reading `.?b` gets, which is what keeps the two forms of one question from
+     * answering differently about a union whose branches do not all hold the member.
+     */
+    typeOfPresence(node: Extract<CelNode, {
+        kind: "select";
+    }>): CelType;
     report(code: CelCheckCode, message: string, range: SourceRange): void;
 }
 /** Whether a call is a macro at all — asked before any overload is looked for. */

package/dist/macro-check.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"macro-check.d.ts","sourceRoot":"","sources":["../src/macro-check.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE7D,mDAAmD;AACnD,MAAM,WAAW,SAAS;IACxB,iEAAiE;IACjE,MAAM,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IAC/B,6DAA6D;IAC7D,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;IAC9E,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;CACvE;AAWD,kFAAkF;AAClF,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAQlD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAalE"}
+{"version":3,"file":"macro-check.d.ts","sourceRoot":"","sources":["../src/macro-check.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE7D,mDAAmD;AACnD,MAAM,WAAW,SAAS;IACxB,iEAAiE;IACjE,MAAM,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IAC/B,6DAA6D;IAC7D,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;IAC9E;;;;OAIG;IACH,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAA;KAAE,CAAC,GAAG,OAAO,CAAC;IACpE,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;CACvE;AAWD,kFAAkF;AAClF,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAQlD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAalE"}

package/dist/macro-check.js

@@ -83,7 +83,7 @@ function checkOptionalBinding(node, host) {
 function checkHas(node, host) {
     const argument = node.args[0];
     if (argument.kind === "select")
-        host.typeOf(argument);
+        host.typeOfPresence(argument);
     return BOOL;
 }
 /** `cel.bind(name, value, body)` — a name for one value, in scope in the body alone. */

package/dist/member-read.d.ts

@@ -16,6 +16,10 @@
  *
  * A key the value does not hold is the `no_such_key` **error value**, which
  * participates in short-circuit. Never `undefined` passed along.
+ *
+ * **What each of the four verdicts answers is written once here**, in `lookupAbsence`,
+ * and read by both presence callers — so the closure backend, the emitter and the
+ * `has()` macro cannot differ by construction.
  */
 import type { CelValue } from "./cel-value.js";
 import { type CelError } from "./cel-value.js";
@@ -39,14 +43,47 @@ export type Lookup = CelValue | typeof MISSING | typeof OUT_OF_RANGE | typeof UN
 export declare function celLookup(container: CelValue, key: CelValue): Lookup;
 /** The value at a key, or the error a failed lookup is. */
 export declare function celRead(container: CelValue, key: CelValue, range?: SourceRange): CelValue | CelError;
+/**
+ * Whether a lookup that found nothing answers **absence** rather than an error. This is
+ * the seam's contract, in the one place both backends and the emitter read it: they all
+ * reach a member read through `backend-runtime.ts`, which reaches the four verdicts
+ * through here.
+ *
+ * - A **presence-shaped** read — `a.?b`, `a[?k]` and `has(a.b)` — answers absence for
+ *   *missing*, *out of range* and *holds no members* alike, and the error only for an
+ *   **unusable key**. It asks whether a member is THERE, and a value that cannot hold one
+ *   has none to find. The authority is the optional library's own: it enters this engine
+ *   from cel-go whole, and cel-go's attribute qualification answers "not found" for a
+ *   receiver that is neither a mapper, a lister nor an indexer **whenever the read is a
+ *   presence test**, erroring only otherwise — the error reading being an explicitly named
+ *   opt-in (`EnableErrorOnBadPresenceTest`), which Telo does not carry, because a
+ *   per-environment switch over what an expression MEANS would let the analyzer and a
+ *   kernel disagree about one manifest.
+ * - A read **through a present optional, written in the ordinary form** — the `.c` of
+ *   `a.?b.c` — is not a presence question about `c`. It answers absence for a key the held
+ *   value does not hold (`optional.of({'c': {}}).c.missing` is absent, cel-spec's
+ *   `optional_chaining_5`) and the error for a held value that holds no members at all
+ *   (`{true: dyn(0)}[?true].absent` is cel-spec's error).
+ * - A **plain** read never asks: each of the four is the error `lookupError` words.
+ *
+ * An unusable key is the one refusal no form forgives: `[?3.1]` names an entry no
+ * container of that shape could hold, so it is a mistake in the READ rather than a member
+ * that happens to be absent.
+ */
+export declare function lookupAbsence(found: symbol, presence: boolean): boolean;
 /** The error a refused lookup is. */
 export declare function lookupError(found: symbol, key: CelValue, range?: SourceRange): CelError;
 /**
- * Whether a key is there — `has(a.b)`. It asks about presence, so a missing key is
- * `false` rather than the error a read would be; a container that holds no members at
- * all is still a mistake in the question.
+ * Whether a key is there — `has(a.b)`. The question is presence-shaped, so a value that
+ * holds no members answers `false` exactly as a missing key does: it has no member to
+ * find. Only an unusable key is a mistake in the question itself.
  */
 export declare function celHas(container: CelValue, key: CelValue, range?: SourceRange): boolean | CelError;
-/** The elements a comprehension ranges over: a list's items, a map's keys. */
-export declare function celIterable(container: CelValue, range?: SourceRange): CelValue[] | CelError;
+/**
+ * The elements a comprehension ranges over: a list's items, a map's keys. A list is handed
+ * over as it is — nothing in CEL mutates a value, and every comprehension reads its range —
+ * so copying it would cost the length of the list per comprehension to defend against a
+ * write no expression can perform.
+ */
+export declare function celIterable(container: CelValue, range?: SourceRange): readonly CelValue[] | CelError;
 //# sourceMappingURL=member-read.d.ts.map

package/dist/member-read.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"member-read.d.ts","sourceRoot":"","sources":["../src/member-read.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAA8C,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC3F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;GAKG;AACH,eAAO,MAAM,OAAO,eAA+B,CAAC;AACpD,eAAO,MAAM,YAAY,eAAkC,CAAC;AAC5D,eAAO,MAAM,qBAAqB,eAA4C,CAAC;AAC/E,eAAO,MAAM,eAAe,eAAsC,CAAC;AAEnE,MAAM,MAAM,MAAM,GACd,QAAQ,GACR,OAAO,OAAO,GACd,OAAO,YAAY,GACnB,OAAO,qBAAqB,GAC5B,OAAO,eAAe,CAAC;AAY3B;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,GAAG,MAAM,CAqBpE;AAED,2DAA2D;AAC3D,wBAAgB,OAAO,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAIpG;AAED,qCAAqC;AACrC,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,QAAQ,CASvF;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,OAAO,GAAG,QAAQ,CAKlG;AAED,8EAA8E;AAC9E,wBAAgB,WAAW,CAAC,SAAS,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,QAAQ,EAAE,GAAG,QAAQ,CAK3F"}
+{"version":3,"file":"member-read.d.ts","sourceRoot":"","sources":["../src/member-read.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAA8C,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC3F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;GAKG;AACH,eAAO,MAAM,OAAO,eAA+B,CAAC;AACpD,eAAO,MAAM,YAAY,eAAkC,CAAC;AAC5D,eAAO,MAAM,qBAAqB,eAA4C,CAAC;AAC/E,eAAO,MAAM,eAAe,eAAsC,CAAC;AAEnE,MAAM,MAAM,MAAM,GACd,QAAQ,GACR,OAAO,OAAO,GACd,OAAO,YAAY,GACnB,OAAO,qBAAqB,GAC5B,OAAO,eAAe,CAAC;AAY3B;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,GAAG,MAAM,CAqBpE;AAED,2DAA2D;AAC3D,wBAAgB,OAAO,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAIpG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAGvE;AAED,qCAAqC;AACrC,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,QAAQ,CASvF;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,OAAO,GAAG,QAAQ,CAKlG;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,SAAS,QAAQ,EAAE,GAAG,QAAQ,CAKpG"}

package/dist/member-read.js

@@ -16,6 +16,10 @@
  *
  * A key the value does not hold is the `no_such_key` **error value**, which
  * participates in short-circuit. Never `undefined` passed along.
+ *
+ * **What each of the four verdicts answers is written once here**, in `lookupAbsence`,
+ * and read by both presence callers — so the closure backend, the emitter and the
+ * `has()` macro cannot differ by construction.
  */
 import { celMapKeys, mapKeyIdentity } from "./cel-map-value.js";
 import { celError, isCelMap, isCelRecord, isCelUint } from "./cel-value.js";
@@ -79,6 +83,38 @@ export function celRead(container, key, range) {
         return found;
     return lookupError(found, key, range);
 }
+/**
+ * Whether a lookup that found nothing answers **absence** rather than an error. This is
+ * the seam's contract, in the one place both backends and the emitter read it: they all
+ * reach a member read through `backend-runtime.ts`, which reaches the four verdicts
+ * through here.
+ *
+ * - A **presence-shaped** read — `a.?b`, `a[?k]` and `has(a.b)` — answers absence for
+ *   *missing*, *out of range* and *holds no members* alike, and the error only for an
+ *   **unusable key**. It asks whether a member is THERE, and a value that cannot hold one
+ *   has none to find. The authority is the optional library's own: it enters this engine
+ *   from cel-go whole, and cel-go's attribute qualification answers "not found" for a
+ *   receiver that is neither a mapper, a lister nor an indexer **whenever the read is a
+ *   presence test**, erroring only otherwise — the error reading being an explicitly named
+ *   opt-in (`EnableErrorOnBadPresenceTest`), which Telo does not carry, because a
+ *   per-environment switch over what an expression MEANS would let the analyzer and a
+ *   kernel disagree about one manifest.
+ * - A read **through a present optional, written in the ordinary form** — the `.c` of
+ *   `a.?b.c` — is not a presence question about `c`. It answers absence for a key the held
+ *   value does not hold (`optional.of({'c': {}}).c.missing` is absent, cel-spec's
+ *   `optional_chaining_5`) and the error for a held value that holds no members at all
+ *   (`{true: dyn(0)}[?true].absent` is cel-spec's error).
+ * - A **plain** read never asks: each of the four is the error `lookupError` words.
+ *
+ * An unusable key is the one refusal no form forgives: `[?3.1]` names an entry no
+ * container of that shape could hold, so it is a mistake in the READ rather than a member
+ * that happens to be absent.
+ */
+export function lookupAbsence(found, presence) {
+    if (found === MISSING || found === OUT_OF_RANGE)
+        return true;
+    return presence && found === UNSUPPORTED_CONTAINER;
+}
 /** The error a refused lookup is. */
 export function lookupError(found, key, range) {
     if (found === MISSING)
@@ -92,22 +128,27 @@ export function lookupError(found, key, range) {
     return celError("unsupported_container", "this value holds no members", range);
 }
 /**
- * Whether a key is there — `has(a.b)`. It asks about presence, so a missing key is
- * `false` rather than the error a read would be; a container that holds no members at
- * all is still a mistake in the question.
+ * Whether a key is there — `has(a.b)`. The question is presence-shaped, so a value that
+ * holds no members answers `false` exactly as a missing key does: it has no member to
+ * find. Only an unusable key is a mistake in the question itself.
  */
 export function celHas(container, key, range) {
     const found = celLookup(container, key);
     if (typeof found !== "symbol")
         return true;
-    if (found === MISSING || found === OUT_OF_RANGE)
+    if (lookupAbsence(found, true))
         return false;
     return lookupError(found, key, range);
 }
-/** The elements a comprehension ranges over: a list's items, a map's keys. */
+/**
+ * The elements a comprehension ranges over: a list's items, a map's keys. A list is handed
+ * over as it is — nothing in CEL mutates a value, and every comprehension reads its range —
+ * so copying it would cost the length of the list per comprehension to defend against a
+ * write no expression can perform.
+ */
 export function celIterable(container, range) {
     if (Array.isArray(container))
-        return [...container];
+        return container;
     if (isCelMap(container))
         return celMapKeys(container);
     if (isCelRecord(container))

package/dist/resolved-call.d.ts

@@ -29,5 +29,18 @@ export interface ResolvedCall {
     readonly deterministic?: boolean;
     readonly hostBacked?: boolean;
     readonly throws?: readonly string[];
+    /**
+     * Each argument's own type, for a NAMESPACED call only.
+     *
+     * The host judges such a call against its own, richer signature grammar — a JSON Schema
+     * per parameter, an optional trailing parameter — so it needs what was actually passed.
+     * It cannot re-derive it: checking an argument's subtree on its own loses whatever the
+     * expression bound around it, so an argument inside a comprehension (`xs.map(i,
+     * Billing.total(i))`) would type as `dyn` and the host's argument check would silently
+     * stop asking. Here the types come from the same pass that typed the call.
+     *
+     * Absent for a call the registry resolved: its parameter types are the signature's.
+     */
+    readonly argumentTypes?: readonly string[];
 }
 //# sourceMappingURL=resolved-call.d.ts.map

package/dist/resolved-call.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolved-call.d.ts","sourceRoot":"","sources":["../src/resolved-call.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,WAAW,YAAY;IAC3B,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,sCAAsC;IACtC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,mEAAmE;IACnE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,wEAAwE;IACxE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,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"}
+{"version":3,"file":"resolved-call.d.ts","sourceRoot":"","sources":["../src/resolved-call.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,WAAW,YAAY;IAC3B,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,sCAAsC;IACtC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,mEAAmE;IACnE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,wEAAwE;IACxE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,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;IACpC;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5C"}

package/dist/runtime-library.d.ts

@@ -22,7 +22,18 @@ export interface CelCallContext {
     /** The span of the call, carried into any error value it produces. */
     readonly range?: SourceRange;
 }
-export type CelImplementation = (args: readonly CelValue[], ctx: CelCallContext) => CelValue;
+/**
+ * What an implementation IS: its call context, then its arguments **positionally**.
+ *
+ * The dispatch key fixes each overload's arity, so there is never a count to carry and
+ * never an array to build — a call's cost is the call. `CALL_SITE_DIRECT_ARITY` is the
+ * bound, and it is the widest arity any registration declares; a trailing argument an
+ * overload does not take is `undefined`, which no CEL value ever is, so an absent one is
+ * unambiguous. In a port the same contract is a context plus a slice.
+ */
+export type CelImplementation = (ctx: CelCallContext, a?: CelValue, b?: CelValue, c?: CelValue, d?: CelValue) => CelValue;
+/** The widest arity a registration declares, and so the number of direct parameters. */
+export declare const CALL_SITE_DIRECT_ARITY = 4;
 /** The name a type value carries. A null's type and an optional's are named apart. */
 export declare function typeValueName(typeName: string): string;
 /** The type value of any value — `type()` must answer for anything, including `dyn`. */
@@ -52,5 +63,5 @@ export declare function standardConstantValues(optionalTypes: boolean): Readonly
  * `optional.ofNonZeroValue(v)`: present unless the value is its type's zero — which is
  * what makes it different from `optional.of`, and what three of the vectors' rows read.
  */
-export declare function optionalOfNonZero(value: CelValue): CelOptional;
+export declare function optionalOfNonZero(held: CelValue): CelOptional;
 //# sourceMappingURL=runtime-library.d.ts.map

package/dist/runtime-library.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-library.d.ts","sourceRoot":"","sources":["../src/runtime-library.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAGV,WAAW,EAEX,QAAQ,EACT,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAaL,KAAK,QAAQ,EACb,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAC;AAqBxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAGnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAYpD,mEAAmE;AACnE,MAAM,WAAW,cAAc;IAC7B,sEAAsE;IACtE,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;CAC9B;AAED,MAAM,MAAM,iBAAiB,GAAG,CAAC,IAAI,EAAE,SAAS,QAAQ,EAAE,EAAE,GAAG,EAAE,cAAc,KAAK,QAAQ,CAAC;AA6E7F,sFAAsF;AACtF,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGtD;AAED,wFAAwF;AACxF,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,YAAY,GAAG,QAAQ,CAM5F;AAMD,8DAA8D;AAC9D,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAYpD;AAQD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,QAAQ,CAQxD;AAwVD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,YAAY,GAAG,iBAAiB,GAAG,SAAS,CAEvF;AAED,0EAA0E;AAC1E,wBAAgB,eAAe,IAAI,SAAS,MAAM,EAAE,CAEnD;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,OAAO,GAAG,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,CAc5F;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,QAAQ,GAAG,WAAW,CAE9D"}
+{"version":3,"file":"runtime-library.d.ts","sourceRoot":"","sources":["../src/runtime-library.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAGV,WAAW,EAEX,QAAQ,EACT,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAaL,KAAK,QAAQ,EACb,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAC;AAqBxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAGnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAYpD,mEAAmE;AACnE,MAAM,WAAW,cAAc;IAC7B,sEAAsE;IACtE,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;CAC9B;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC9B,GAAG,EAAE,cAAc,EACnB,CAAC,CAAC,EAAE,QAAQ,EACZ,CAAC,CAAC,EAAE,QAAQ,EACZ,CAAC,CAAC,EAAE,QAAQ,EACZ,CAAC,CAAC,EAAE,QAAQ,KACT,QAAQ,CAAC;AAEd,wFAAwF;AACxF,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAkFxC,sFAAsF;AACtF,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGtD;AAED,wFAAwF;AACxF,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,YAAY,GAAG,QAAQ,CAM5F;AAMD,8DAA8D;AAC9D,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAYpD;AAQD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,QAAQ,CAQxD;AAyVD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,YAAY,GAAG,iBAAiB,GAAG,SAAS,CAEvF;AAED,0EAA0E;AAC1E,wBAAgB,eAAe,IAAI,SAAS,MAAM,EAAE,CAEnD;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,OAAO,GAAG,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,CAc5F;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,GAAG,WAAW,CAE7D"}