@telorun/cel 0.0.0-stage → 0.107.0

package/dist/cel-expression.d.ts

@@ -0,0 +1,32 @@
+/**
+ * One CEL expression, read and resolved.
+ *
+ * This is the front end's whole answer: the source as written, the canonical tree,
+ * the namespace set the tree was resolved under, and at most one syntax diagnostic.
+ * **Every expression this module hands out is already resolved** — there is no way
+ * to obtain an unresolved tree and then forget to resolve it, and `namespaces`
+ * records what it was resolved under so a consumer checking it against a different
+ * set can refuse rather than quietly answer the wrong question.
+ *
+ * Reading an expression never throws: a source it cannot read gives a tree for the
+ * longest prefix it could, plus the diagnostic saying where it stopped.
+ */
+import type { ParseOptions } from "./parser.js";
+import type { CelSyntaxDiagnostic } from "./syntax-diagnostic.js";
+import type { CelNode } from "./syntax-tree.js";
+export interface CelExpression {
+    readonly source: string;
+    readonly root: CelNode;
+    /** The namespace set the tree was resolved under, in canonical order. */
+    readonly namespaces: readonly string[];
+    /** At most one entry; one exactly when the source could not be read whole. */
+    readonly diagnostics: readonly CelSyntaxDiagnostic[];
+}
+export interface ParseExpressionOptions extends ParseOptions {
+    /** The names that denote namespaces rather than values at this site. */
+    readonly namespaces?: Iterable<string>;
+}
+export declare function parseExpression(source: string, options?: ParseExpressionOptions): CelExpression;
+/** Whether the expression was resolved under exactly these namespaces. */
+export declare function resolvedUnder(expression: CelExpression, namespaces: Iterable<string>): boolean;
+//# sourceMappingURL=cel-expression.d.ts.map

package/dist/cel-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cel-expression.d.ts","sourceRoot":"","sources":["../src/cel-expression.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAOH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAEhD,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,yEAAyE;IACzE,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,8EAA8E;IAC9E,QAAQ,CAAC,WAAW,EAAE,SAAS,mBAAmB,EAAE,CAAC;CACtD;AAED,MAAM,WAAW,sBAAuB,SAAQ,YAAY;IAC1D,wEAAwE;IACxE,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;CACxC;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB,GAAG,aAAa,CAS/F;AAED,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,UAAU,EAAE,aAAa,EAAE,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,OAAO,CAE9F"}

package/dist/cel-expression.js

@@ -0,0 +1,29 @@
+/**
+ * One CEL expression, read and resolved.
+ *
+ * This is the front end's whole answer: the source as written, the canonical tree,
+ * the namespace set the tree was resolved under, and at most one syntax diagnostic.
+ * **Every expression this module hands out is already resolved** — there is no way
+ * to obtain an unresolved tree and then forget to resolve it, and `namespaces`
+ * records what it was resolved under so a consumer checking it against a different
+ * set can refuse rather than quietly answer the wrong question.
+ *
+ * Reading an expression never throws: a source it cannot read gives a tree for the
+ * longest prefix it could, plus the diagnostic saying where it stopped.
+ */
+import { namespaceSetsEqual, normalizeNamespaces, resolveNamespaces, } from "./namespace-resolution.js";
+import { parseSyntax } from "./parser.js";
+export function parseExpression(source, options) {
+    const namespaces = normalizeNamespaces(options?.namespaces ?? []);
+    const parsed = parseSyntax(source, options);
+    return {
+        source,
+        root: resolveNamespaces(parsed.root, namespaces),
+        namespaces,
+        diagnostics: parsed.diagnostics,
+    };
+}
+/** Whether the expression was resolved under exactly these namespaces. */
+export function resolvedUnder(expression, namespaces) {
+    return namespaceSetsEqual(expression.namespaces, normalizeNamespaces(namespaces));
+}

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

@@ -0,0 +1,34 @@
+/**
+ * Building a CEL map, and the one identity a key has.
+ *
+ * A map's entries live in a `Map` keyed by the **canonical text** of each key, never by
+ * a property name. Two consequences, both load-bearing:
+ *
+ * - A map holds CEL's four key types (int, uint, bool, string) in one container, and an
+ *   int key and a uint key of the same number are **one** key, because CEL equality
+ *   makes them equal — so a literal writing both is a duplicate rather than two entries.
+ * - Nothing a key spells can reach a prototype, a method or an inherited member. A map
+ *   built from `{'__proto__': 1}` holds `__proto__` as data and reads it back as data;
+ *   dropping such a key would be swallowing what the author wrote.
+ */
+import type { CelMap, CelMapValueEntry, CelValue } from "./cel-value.js";
+import { type CelError } from "./cel-value.js";
+import type { SourceRange } from "./syntax-tree.js";
+/**
+ * The text that identifies a key. `n` covers the numeric types together: CEL equality
+ * makes `1`, `1u` and `1.0` one key, so a map carrying two of them is not a map and a
+ * lookup by any of the three finds the entry — which is what
+ * `{1u: 1.0, 2: 2.0, 3u: 3.0}[?3.0]` reads. A double that is not whole identifies
+ * nothing, since no entry can hold it.
+ */
+export declare function mapKeyIdentity(key: CelValue): string | undefined;
+/** An empty map, for a literal with no entries. */
+export declare function celMapOf(entries: ReadonlyMap<string, CelMapValueEntry>): CelMap;
+/**
+ * A map from its entries in written order, or the error that stops it: a key of a type
+ * no map is keyed by, or two keys CEL equality makes one.
+ */
+export declare function celMapFromEntries(pairs: readonly (readonly [CelValue, CelValue])[], range?: SourceRange): CelMap | CelError;
+/** Every key of a map, in insertion order — what a comprehension ranges over. */
+export declare function celMapKeys(map: CelMap): CelValue[];
+//# sourceMappingURL=cel-map-value.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cel-map-value.d.ts","sourceRoot":"","sources":["../src/cel-map-value.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAOhE;AAED,mDAAmD;AACnD,wBAAgB,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAAG,MAAM,CAE/E;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,SAAS,CAAC,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,EAAE,EACjD,KAAK,CAAC,EAAE,WAAW,GAClB,MAAM,GAAG,QAAQ,CAsBnB;AAQD,iFAAiF;AACjF,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,EAAE,CAElD"}

package/dist/cel-map-value.js

@@ -0,0 +1,74 @@
+/**
+ * Building a CEL map, and the one identity a key has.
+ *
+ * A map's entries live in a `Map` keyed by the **canonical text** of each key, never by
+ * a property name. Two consequences, both load-bearing:
+ *
+ * - A map holds CEL's four key types (int, uint, bool, string) in one container, and an
+ *   int key and a uint key of the same number are **one** key, because CEL equality
+ *   makes them equal — so a literal writing both is a duplicate rather than two entries.
+ * - Nothing a key spells can reach a prototype, a method or an inherited member. A map
+ *   built from `{'__proto__': 1}` holds `__proto__` as data and reads it back as data;
+ *   dropping such a key would be swallowing what the author wrote.
+ */
+import { CEL_VALUE_TYPE, celError, isCelError, isCelUint, } from "./cel-value.js";
+/**
+ * The text that identifies a key. `n` covers the numeric types together: CEL equality
+ * makes `1`, `1u` and `1.0` one key, so a map carrying two of them is not a map and a
+ * lookup by any of the three finds the entry — which is what
+ * `{1u: 1.0, 2: 2.0, 3u: 3.0}[?3.0]` reads. A double that is not whole identifies
+ * nothing, since no entry can hold it.
+ */
+export function mapKeyIdentity(key) {
+    if (typeof key === "string")
+        return `s${key}`;
+    if (typeof key === "boolean")
+        return `b${key}`;
+    if (typeof key === "bigint")
+        return `n${key}`;
+    if (isCelUint(key))
+        return `n${key.value}`;
+    if (typeof key === "number" && Number.isInteger(key))
+        return `n${BigInt(key)}`;
+    return undefined;
+}
+/** An empty map, for a literal with no entries. */
+export function celMapOf(entries) {
+    return { [CEL_VALUE_TYPE]: "map", entries };
+}
+/**
+ * A map from its entries in written order, or the error that stops it: a key of a type
+ * no map is keyed by, or two keys CEL equality makes one.
+ */
+export function celMapFromEntries(pairs, range) {
+    const entries = new Map();
+    for (const [key, value] of pairs) {
+        if (isCelError(key))
+            return key;
+        if (isCelError(value))
+            return value;
+        // A map is **built** with an int, uint, bool or string key: a double is not a key
+        // type, even one that is whole. It still LOOKS one up, because `{1u: …}[?1.0]` reads
+        // the entry — equality across the numeric types holds for a key as for a value.
+        const identity = typeof key === "number" ? undefined : mapKeyIdentity(key);
+        if (identity === undefined) {
+            return celError("unsupported_key_type", "a map is keyed by an int, a uint, a bool or a string", range);
+        }
+        if (entries.has(identity)) {
+            return celError("duplicate_map_key", `the key ${describeKey(key)} is written twice`, range);
+        }
+        entries.set(identity, { key, value });
+    }
+    return celMapOf(entries);
+}
+function describeKey(key) {
+    if (typeof key === "string")
+        return JSON.stringify(key);
+    if (isCelUint(key))
+        return `${key.value}u`;
+    return String(key);
+}
+/** Every key of a map, in insertion order — what a comprehension ranges over. */
+export function celMapKeys(map) {
+    return [...map.entries.values()].map((entry) => entry.key);
+}

package/dist/cel-program.d.ts

@@ -0,0 +1,44 @@
+/**
+ * A compiled expression, and what happens at the top of an evaluation.
+ *
+ * An error is a **value** throughout evaluation, so that `false && <missing key>` is
+ * `false`. At the top there is nothing left to short-circuit, so a surviving error
+ * becomes a thrown failure carrying its code — the one place the engine throws about an
+ * expression's own data, and the only form a caller can be expected to handle.
+ */
+import type { CelActivation } from "./activation.js";
+import type { CelStep, CompileTarget, NamespaceDispatch } from "./backend-runtime.js";
+import type { CelEvaluationCode, CelValue } from "./cel-value.js";
+import type { CelExpression } from "./cel-expression.js";
+import type { SourceRange } from "./syntax-tree.js";
+/** A failure an evaluation could not carry any further. */
+export declare class CelEvaluationError extends Error {
+    readonly code: CelEvaluationCode;
+    readonly range?: SourceRange;
+    constructor(code: CelEvaluationCode, message: string, range?: SourceRange);
+}
+export interface EvaluateOptions {
+    /**
+     * What a namespaced call (`Alias.fn(x)`) is dispatched through. A host binds it per
+     * evaluation, because which functions a scope reaches is the host's own question; a
+     * call nothing binds is `unbound_function`.
+     */
+    readonly namespaceFunction?: NamespaceDispatch;
+}
+export interface CelProgram {
+    readonly source: string;
+    /** The value, or a throw carrying the code of the error that survived to the top. */
+    evaluate(activation?: CelActivation, options?: EvaluateOptions): CelValue;
+    /** The value or the error value, for a caller that carries errors itself. */
+    evaluateToValue(activation?: CelActivation, options?: EvaluateOptions): CelValue;
+}
+export declare function compileExpression(expression: CelExpression, target: CompileTarget): CelProgram;
+/**
+ * A program over a step a backend already built — what an emitted module's function
+ * becomes. The top of an evaluation is the same either way: the thenable backstop, and a
+ * surviving error turning into a throw. A second implementation of that top would be a
+ * second answer to "what does a caller see", which is the one thing two backends may not
+ * disagree about.
+ */
+export declare function programOfStep(source: string, step: CelStep, slots?: number): CelProgram;
+//# sourceMappingURL=cel-program.d.ts.map

package/dist/cel-program.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cel-program.d.ts","sourceRoot":"","sources":["../src/cel-program.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAEtF,OAAO,KAAK,EAAY,iBAAiB,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE5E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,2DAA2D;AAC3D,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;gBAEjB,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,WAAW;CAM1E;AAED,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;CAChD;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,qFAAqF;IACrF,QAAQ,CAAC,UAAU,CAAC,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,QAAQ,CAAC;IAC1E,6EAA6E;IAC7E,eAAe,CAAC,UAAU,CAAC,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,QAAQ,CAAC;CAClF;AAeD,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,GAAG,UAAU,CAG9F;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,SAAI,GAAG,UAAU,CAElF"}

package/dist/cel-program.js

@@ -0,0 +1,72 @@
+/**
+ * A compiled expression, and what happens at the top of an evaluation.
+ *
+ * An error is a **value** throughout evaluation, so that `false && <missing key>` is
+ * `false`. At the top there is nothing left to short-circuit, so a surviving error
+ * becomes a thrown failure carrying its code — the one place the engine throws about an
+ * expression's own data, and the only form a caller can be expected to handle.
+ */
+import { compileTree } from "./closure-backend.js";
+import { celError, isCelError, isThenable } from "./cel-value.js";
+/** A failure an evaluation could not carry any further. */
+export class CelEvaluationError extends Error {
+    code;
+    range;
+    constructor(code, message, range) {
+        super(message);
+        this.name = "CelEvaluationError";
+        this.code = code;
+        if (range)
+            this.range = range;
+    }
+}
+/** The refusal a thenable surviving to the top is, spanning the whole expression. */
+function asyncRefused(source) {
+    return celError("async_value_unsupported", "a value that must be awaited reached evaluation, and CEL evaluates synchronously", [0, source.length]);
+}
+const NO_ACTIVATION = Object.freeze(Object.create(null));
+/** A frame that binds nothing needs no slots, and allocating none is measurable. */
+const NO_SLOTS = [];
+export function compileExpression(expression, target) {
+    const compiled = compileTree(expression.root, target);
+    return new Program(expression.source, compiled.step, compiled.slots);
+}
+/**
+ * A program over a step a backend already built — what an emitted module's function
+ * becomes. The top of an evaluation is the same either way: the thenable backstop, and a
+ * surviving error turning into a throw. A second implementation of that top would be a
+ * second answer to "what does a caller see", which is the one thing two backends may not
+ * disagree about.
+ */
+export function programOfStep(source, step, slots = 0) {
+    return new Program(source, step, slots);
+}
+class Program {
+    source;
+    step;
+    slots;
+    constructor(source, step, slots) {
+        this.source = source;
+        this.step = step;
+        this.slots = slots;
+    }
+    evaluateToValue(activation = NO_ACTIVATION, options = {}) {
+        // One shape, every time: a frame built two ways is two shapes, and every step that
+        // reads one would see both.
+        const value = this.step({
+            activation,
+            slots: this.slots === 0 ? NO_SLOTS : new Array(this.slots),
+            namespaceFunction: options.namespaceFunction,
+        });
+        // The backstop, one check per evaluation: every door refuses a thenable where the value
+        // enters, and this is what catches a door nobody has thought of yet rather than handing a
+        // promise to a caller as though it were a value.
+        return isThenable(value) ? asyncRefused(this.source) : value;
+    }
+    evaluate(activation, options) {
+        const value = this.evaluateToValue(activation, options);
+        if (isCelError(value))
+            throw new CelEvaluationError(value.code, value.message, value.range);
+        return value;
+    }
+}

package/dist/cel-type.d.ts

@@ -0,0 +1,131 @@
+/**
+ * CEL's types.
+ *
+ * The domain is deliberately richer than the one an expression can spell, because
+ * the checker's whole value is in what it can be *told*: a variable typed from a
+ * JSON Schema carries its nested objects, its element types and its unions, and a
+ * typo two levels down is then a type error rather than something only a running
+ * request discovers.
+ *
+ * Four shapes exist for that reason and have no syntax of their own:
+ *
+ * - `record` — an object with named fields, each typed in turn; `open` says whether
+ *   a field it does not declare is unjudged (a schema with no `properties`) or
+ *   undeclared (a closed schema).
+ * - `union` — carried as a union rather than collapsed to `dyn`, so `int|null` keeps
+ *   both the arithmetic and the null that makes a dereference worth reporting.
+ * - `nominal` — a named type over a base, with invariant arguments: the mechanism a
+ *   host registers its own vocabulary through. **A nominal is not its base**: it
+ *   accepts only what is registered for it, which is what makes a slot expecting one
+ *   refuse a plain value of the base. (The vectors pin this: an operator the base
+ *   accepts is refused on the named type.)
+ * - `parameter` — a type variable in a signature, unified per call and invariant.
+ *
+ * `dyn` is the top: it is assignable both ways, which is what keeps an unlisted
+ * variable or an unknown call result from cascading into a second error.
+ */
+export type PrimitiveName = "int" | "uint" | "double" | "bool" | "string" | "bytes" | "null" | "type" | "timestamp" | "duration";
+export interface DynType {
+    readonly kind: "dyn";
+}
+export interface PrimitiveType {
+    readonly kind: "primitive";
+    readonly name: PrimitiveName;
+}
+export interface ListType {
+    readonly kind: "list";
+    readonly element: CelType;
+}
+export interface MapType {
+    readonly kind: "map";
+    readonly key: CelType;
+    readonly value: CelType;
+}
+export interface OptionalType {
+    readonly kind: "optional";
+    readonly value: CelType;
+}
+export interface RecordType {
+    readonly kind: "record";
+    readonly name?: string;
+    readonly fields: ReadonlyMap<string, CelType>;
+    /** A field the record does not declare is unjudged when open, undeclared when closed. */
+    readonly open: boolean;
+}
+export interface UnionType {
+    readonly kind: "union";
+    readonly members: readonly CelType[];
+}
+export interface NominalType {
+    readonly kind: "nominal";
+    readonly name: string;
+    readonly base: CelType;
+    readonly args: readonly CelType[];
+}
+export interface ParameterType {
+    readonly kind: "parameter";
+    readonly name: string;
+}
+export type CelType = DynType | PrimitiveType | ListType | MapType | OptionalType | RecordType | UnionType | NominalType | ParameterType;
+export declare const DYN: DynType;
+export declare const INT: PrimitiveType;
+export declare const UINT: PrimitiveType;
+export declare const DOUBLE: PrimitiveType;
+export declare const BOOL: PrimitiveType;
+export declare const STRING: PrimitiveType;
+export declare const BYTES: PrimitiveType;
+export declare const NULL: PrimitiveType;
+export declare const TYPE: PrimitiveType;
+export declare const TIMESTAMP: PrimitiveType;
+export declare const DURATION: PrimitiveType;
+export declare const listOf: (element: CelType) => ListType;
+export declare const mapOf: (key: CelType, value: CelType) => MapType;
+export declare const optionalOf: (value: CelType) => OptionalType;
+export declare const parameterOf: (name: string) => ParameterType;
+/** A union of its distinct members; one member is that member, none is `dyn`. */
+export declare function unionOf(members: readonly CelType[]): CelType;
+/** The names the timestamp and duration types are written and printed under. */
+export declare const WELL_KNOWN_TYPE_NAMES: Readonly<Record<string, PrimitiveName>>;
+export declare function isDyn(type: CelType): boolean;
+export declare function typesEqual(left: CelType, right: CelType): boolean;
+/**
+ * How a type is written. `top` collapses a list or map of `dyn` to its bare name,
+ * which is how the whole type of an expression is reported.
+ */
+export declare function formatType(type: CelType, top?: boolean): string;
+export declare function isNumeric(type: CelType): boolean;
+/**
+ * The type with every unresolved type parameter replaced by `dyn` — the last step before a
+ * type is REPORTED.
+ *
+ * cel-spec's rule is that an unresolved parameter behaves as `dyn` wherever it is used, and
+ * the type handed out is a use like any other: a consumer that reads `list<T>` has to know
+ * what `T` means to this engine, and the answer is "nothing — it was never resolved". A
+ * parameter survives only where it is DECLARED: a signature's text, a nominal type's
+ * parameter list.
+ */
+export declare function withoutParameters(type: CelType): CelType;
+/** Whether `type` admits a null value — a null, or a union holding one. */
+export declare function admitsNull(type: CelType): boolean;
+/** The type with every null taken out of it; `dyn` and a bare null are unchanged. */
+export declare function withoutNull(type: CelType): CelType;
+/**
+ * Whether a value of `from` may stand where `to` is wanted.
+ *
+ * `dyn` passes both ways; a nominal type accepts only itself (its base is a
+ * different type); a union passes where every member does, and accepts a value any
+ * member accepts. Numeric types do **not** convert implicitly — CEL's cross-type
+ * arithmetic and comparison are declared overloads, not coercions.
+ */
+export declare function assignable(from: CelType, to: CelType): boolean;
+/**
+ * The one type both arms can be. Unlike assignability this is symmetric, and it is
+ * what an aggregate literal's elements and a ternary's branches are reduced through:
+ * nothing in common is `dyn`, which is CEL's own reading of a heterogeneous literal.
+ *
+ * **An unresolved parameter yields to the other side**, so the element type of
+ * `[[[[]]]], [], [[[]]]]` is the deepest list rather than `dyn`: an empty aggregate
+ * says nothing about its elements and must not erase what a sibling does say.
+ */
+export declare function unify(left: CelType, right: CelType): CelType;
+//# sourceMappingURL=cel-type.d.ts.map

package/dist/cel-type.d.ts.map

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