@telorun/cel 0.0.0-stage → 0.108.0

package/dist/cel-type.js

@@ -0,0 +1,293 @@
+/**
+ * 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 const DYN = { kind: "dyn" };
+const primitive = (name) => ({ kind: "primitive", name });
+export const INT = primitive("int");
+export const UINT = primitive("uint");
+export const DOUBLE = primitive("double");
+export const BOOL = primitive("bool");
+export const STRING = primitive("string");
+export const BYTES = primitive("bytes");
+export const NULL = primitive("null");
+export const TYPE = primitive("type");
+export const TIMESTAMP = primitive("timestamp");
+export const DURATION = primitive("duration");
+export const listOf = (element) => ({ kind: "list", element });
+export const mapOf = (key, value) => ({ kind: "map", key, value });
+export const optionalOf = (value) => ({ kind: "optional", value });
+export const parameterOf = (name) => ({ kind: "parameter", name });
+/** A union of its distinct members; one member is that member, none is `dyn`. */
+export function unionOf(members) {
+    const flat = [];
+    for (const member of members) {
+        for (const part of member.kind === "union" ? member.members : [member]) {
+            if (!flat.some((held) => typesEqual(held, part)))
+                flat.push(part);
+        }
+    }
+    if (flat.length === 0)
+        return DYN;
+    if (flat.length === 1)
+        return flat[0];
+    if (flat.some((member) => member.kind === "dyn"))
+        return DYN;
+    return { kind: "union", members: flat };
+}
+/** The names the timestamp and duration types are written and printed under. */
+export const WELL_KNOWN_TYPE_NAMES = {
+    "google.protobuf.Timestamp": "timestamp",
+    "google.protobuf.Duration": "duration",
+};
+const PRIMITIVE_PRINTED = {
+    int: "int",
+    uint: "uint",
+    double: "double",
+    bool: "bool",
+    string: "string",
+    bytes: "bytes",
+    null: "null",
+    type: "type",
+    timestamp: "google.protobuf.Timestamp",
+    duration: "google.protobuf.Duration",
+};
+export function isDyn(type) {
+    return type.kind === "dyn";
+}
+export function typesEqual(left, right) {
+    if (left.kind !== right.kind)
+        return false;
+    switch (left.kind) {
+        case "dyn":
+            return true;
+        case "primitive":
+            return left.name === right.name;
+        case "list":
+            return typesEqual(left.element, right.element);
+        case "map": {
+            const other = right;
+            return typesEqual(left.key, other.key) && typesEqual(left.value, other.value);
+        }
+        case "optional":
+            return typesEqual(left.value, right.value);
+        case "record": {
+            const other = right;
+            if (left.name !== other.name || left.open !== other.open || left.fields.size !== other.fields.size) {
+                return false;
+            }
+            for (const [field, type] of left.fields) {
+                const held = other.fields.get(field);
+                if (!held || !typesEqual(type, held))
+                    return false;
+            }
+            return true;
+        }
+        case "union": {
+            const other = right;
+            return (left.members.length === other.members.length &&
+                left.members.every((member, at) => typesEqual(member, other.members[at])));
+        }
+        case "nominal": {
+            const other = right;
+            return (left.name === other.name &&
+                left.args.length === other.args.length &&
+                left.args.every((argument, at) => typesEqual(argument, other.args[at])));
+        }
+        case "parameter":
+            return left.name === right.name;
+    }
+}
+/**
+ * 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 function formatType(type, top = false) {
+    switch (type.kind) {
+        case "dyn":
+            return "dyn";
+        case "primitive":
+            return PRIMITIVE_PRINTED[type.name];
+        case "list":
+            return top && isDyn(type.element) ? "list" : `list<${formatType(type.element)}>`;
+        case "map":
+            return top && isDyn(type.key) && isDyn(type.value)
+                ? "map"
+                : `map<${formatType(type.key)}, ${formatType(type.value)}>`;
+        case "optional":
+            return `optional<${formatType(type.value)}>`;
+        case "record":
+            // An unnamed record is the shape a map has at runtime, and that is how a
+            // message names it; its fields are what a diagnostic lists, not its type.
+            return type.name ?? "map";
+        case "union":
+            return type.members.map((member) => formatType(member)).join("|");
+        case "nominal":
+            return type.args.length === 0
+                ? type.name
+                : `${type.name}<${type.args.map((argument) => formatType(argument)).join(", ")}>`;
+        case "parameter":
+            return type.name;
+    }
+}
+/** The numeric types, over which CEL compares and converts across type. */
+const NUMERIC = new Set(["int", "uint", "double"]);
+export function isNumeric(type) {
+    return type.kind === "primitive" && NUMERIC.has(type.name);
+}
+/**
+ * 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 function withoutParameters(type) {
+    switch (type.kind) {
+        case "parameter":
+            return DYN;
+        case "list": {
+            const element = withoutParameters(type.element);
+            return element === type.element ? type : listOf(element);
+        }
+        case "map": {
+            const key = withoutParameters(type.key);
+            const value = withoutParameters(type.value);
+            return key === type.key && value === type.value ? type : mapOf(key, value);
+        }
+        case "optional": {
+            const value = withoutParameters(type.value);
+            return value === type.value ? type : optionalOf(value);
+        }
+        case "union":
+            return unionOf(type.members.map(withoutParameters));
+        case "nominal": {
+            const args = type.args.map(withoutParameters);
+            return args.every((argument, at) => argument === type.args[at]) ? type : { ...type, args };
+        }
+        case "record": {
+            let moved = false;
+            const fields = new Map();
+            for (const [name, held] of type.fields) {
+                const replaced = withoutParameters(held);
+                if (replaced !== held)
+                    moved = true;
+                fields.set(name, replaced);
+            }
+            return moved ? { ...type, fields } : type;
+        }
+        default:
+            return type;
+    }
+}
+/** Whether `type` admits a null value — a null, or a union holding one. */
+export function admitsNull(type) {
+    if (type.kind === "primitive")
+        return type.name === "null";
+    if (type.kind === "union")
+        return type.members.some(admitsNull);
+    return false;
+}
+/** The type with every null taken out of it; `dyn` and a bare null are unchanged. */
+export function withoutNull(type) {
+    if (type.kind !== "union")
+        return type;
+    const members = type.members.filter((member) => !admitsNull(member));
+    return members.length === 0 ? type : unionOf(members);
+}
+/**
+ * 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 function assignable(from, to) {
+    if (isDyn(from) || isDyn(to))
+        return true;
+    // An unresolved parameter is an unknown type: it stands where anything is wanted and
+    // accepts anything, exactly as `dyn` does. What it does NOT have is members — asking
+    // for one has no answer, and the checker refuses there rather than here.
+    if (to.kind === "parameter" || from.kind === "parameter")
+        return true;
+    if (from.kind === "union")
+        return from.members.every((member) => assignable(member, to));
+    if (to.kind === "union")
+        return to.members.some((member) => assignable(from, member));
+    if (from.kind === "nominal" || to.kind === "nominal")
+        return typesEqual(from, to);
+    switch (to.kind) {
+        case "list":
+            return from.kind === "list" && assignable(from.element, to.element);
+        case "map":
+            return ((from.kind === "map" && assignable(from.key, to.key) && assignable(from.value, to.value)) ||
+                // A record is a map with named keys, so it stands where a string-keyed map does.
+                (from.kind === "record" && assignable(STRING, to.key) && recordValuesAssignable(from, to.value)));
+        case "optional":
+            return from.kind === "optional" && assignable(from.value, to.value);
+        case "record":
+            return from.kind === "record" && typesEqual(from, to);
+        default:
+            return typesEqual(from, to);
+    }
+}
+function recordValuesAssignable(record, to) {
+    if (isDyn(to))
+        return true;
+    if (record.open)
+        return false;
+    return [...record.fields.values()].every((type) => assignable(type, to));
+}
+/**
+ * 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 function unify(left, right) {
+    if (typesEqual(left, right))
+        return left;
+    if (left.kind === "parameter")
+        return right;
+    if (right.kind === "parameter")
+        return left;
+    if (isDyn(left) || isDyn(right))
+        return DYN;
+    if (left.kind === "list" && right.kind === "list")
+        return listOf(unify(left.element, right.element));
+    if (left.kind === "map" && right.kind === "map") {
+        return mapOf(unify(left.key, right.key), unify(left.value, right.value));
+    }
+    if (left.kind === "optional" && right.kind === "optional")
+        return optionalOf(unify(left.value, right.value));
+    return DYN;
+}

package/dist/cel-value.d.ts

@@ -0,0 +1,166 @@
+/**
+ * The CEL value domain, and how a value says what it is.
+ *
+ * **Identity is a string type key under `Symbol.for("telo.cel.value")`, never
+ * `instanceof`.** Two copies of this engine loaded independently are two sets of
+ * classes, so a constructor check would make a `uint` built by one copy not a uint to
+ * the other — `+`, `type()` and every overload would refuse it. A symbol from the
+ * global registry is the same symbol in both, so the key is readable across copies,
+ * and because a symbol-keyed member cannot appear in parsed JSON an inbound request
+ * body cannot forge a duration. A plain object carrying a *string*-keyed look-alike
+ * (`{"telo.cel.value": "uint"}`) is therefore data: it reads as a map, as it must.
+ *
+ * What is **plain** carries no key, because the host platform already represents it
+ * one way and only one: `null`, a boolean, a string, a double (`number`), an int
+ * (`bigint`), bytes (`Uint8Array`), a list (an array) and a map whose keys are all
+ * strings (a plain object, which is how a host hands one over). What has no faithful
+ * plain form carries the key: a `uint` (a `bigint` is already an int), a timestamp and
+ * a duration (both nanosecond-precise, which no host date type holds), a type value,
+ * an optional, a map with typed keys, and a CEL error. A host's own named type
+ * registers its own key, checked against this set at registration.
+ *
+ * The keys are a **closed set** (`CEL_VALUE_KEYS`); a new one is a change here.
+ */
+import type { CelLiteral, SourceRange } from "./syntax-tree.js";
+export declare const CEL_VALUE_TYPE: unique symbol;
+/** The type keys this engine owns. A host-registered type may not reuse one. */
+export declare const CEL_VALUE_KEYS: readonly ["uint", "google.protobuf.Timestamp", "google.protobuf.Duration", "type", "optional", "map", "error"];
+export type CelValueKey = (typeof CEL_VALUE_KEYS)[number];
+interface Branded<Key extends string> {
+    readonly [CEL_VALUE_TYPE]: Key;
+}
+/** An unsigned 64-bit integer. A `bigint` alone is already CEL's `int`. */
+export interface CelUint extends Branded<"uint"> {
+    readonly value: bigint;
+}
+/**
+ * An instant: whole seconds since the epoch plus nanoseconds in `[0, 1e9)`, so a
+ * negative instant is still `seconds` floored and `nanos` non-negative. Nanosecond
+ * precision is required of the domain — `string(timestamp('…999999999Z'))` is a row.
+ */
+export interface CelTimestamp extends Branded<"google.protobuf.Timestamp"> {
+    readonly seconds: bigint;
+    readonly nanos: number;
+}
+/** A span: seconds and nanoseconds of the **same sign**, `|nanos| < 1e9`. */
+export interface CelDuration extends Branded<"google.protobuf.Duration"> {
+    readonly seconds: bigint;
+    readonly nanos: number;
+}
+/** A type as a value — what `type(x)` answers and what `int` denotes. */
+export interface CelTypeValue extends Branded<"type"> {
+    readonly name: string;
+}
+/** `optional.of(v)` and `optional.none()`. */
+export interface CelOptional extends Branded<"optional"> {
+    readonly present: boolean;
+    readonly held?: CelValue;
+}
+/** One entry of a map, keyed by the canonical text of its key (`cel-map-value.ts`). */
+export interface CelMapValueEntry {
+    readonly key: CelValue;
+    readonly value: CelValue;
+}
+/**
+ * What identifies a key inside a map's entries. A `Map` distinguishes its own keys **by
+ * type**, so the four CEL key types collapse onto three JS ones with no namespace to
+ * separate by hand: a string key is itself, a bool is itself, and an int, a uint and a
+ * whole double are all the `bigint` CEL equality makes them.
+ */
+export type CelMapKey = string | bigint | boolean;
+/**
+ * A map. Entries live in a `Map` keyed by each key's own `CelMapKey`, so the map holds
+ * int, uint, bool and string keys alike and **no key is ever a property name**:
+ * `__proto__`, `constructor` and `prototype` are data here, as they are in any map.
+ */
+export interface CelMap extends Branded<"map"> {
+    readonly entries: ReadonlyMap<CelMapKey, CelMapValueEntry>;
+}
+/** Every evaluation failure this engine names. A code is never derived from a message. */
+export declare const CEL_EVALUATION_CODES: readonly ["no_such_key", "no_such_variable", "index_out_of_range", "no_matching_overload", "unsupported_container", "unsupported_key_type", "duplicate_map_key", "numeric_overflow", "division_by_zero", "modulo_by_zero", "invalid_conversion", "invalid_argument", "invalid_regular_expression", "optional_value_missing", "unbound_function", "async_value_unsupported"];
+export type CelEvaluationCode = (typeof CEL_EVALUATION_CODES)[number];
+/**
+ * A failure as a **value**. It is not thrown: `false && <error>` is `false`, so every
+ * operator, comprehension step and conditional carries an error-valued operand
+ * through, and only the top of an evaluation turns a surviving one into a throw
+ * (`cel-program.ts`). Throwing from the operator that found it would make the
+ * short-circuit rules unimplementable.
+ */
+export interface CelError extends Branded<"error"> {
+    readonly code: CelEvaluationCode;
+    readonly message: string;
+    readonly range?: SourceRange;
+}
+/** A value of a host-registered named type: its own key, outside `CEL_VALUE_KEYS`. */
+export interface CelHostValue {
+    readonly [CEL_VALUE_TYPE]: string;
+}
+/** A map whose keys are all strings, as a host hands one over. */
+export interface CelRecord {
+    readonly [key: string]: CelValue;
+}
+export type CelValue = null | boolean | string | number | bigint | Uint8Array | readonly CelValue[] | CelUint | CelTimestamp | CelDuration | CelTypeValue | CelOptional | CelMap | CelError | CelHostValue | CelRecord;
+export declare function celUint(value: bigint): CelUint;
+export declare function celTypeValue(name: string): CelTypeValue;
+export declare function celNone(): CelOptional;
+export declare function celSome(held: CelValue): CelOptional;
+export declare function celError(code: CelEvaluationCode, message: string, range?: SourceRange): CelError;
+export declare function isCelError(value: unknown): value is CelError;
+export declare function isCelOptional(value: unknown): value is CelOptional;
+export declare function isCelUint(value: unknown): value is CelUint;
+export declare function isCelMap(value: unknown): value is CelMap;
+export declare function isCelTimestamp(value: unknown): value is CelTimestamp;
+export declare function isCelDuration(value: unknown): value is CelDuration;
+export declare function isCelTypeValue(value: unknown): value is CelTypeValue;
+/**
+ * Whether a value is bytes. `Object.prototype.toString` rather than `instanceof`, so a
+ * buffer built in another realm is still bytes — the same reason the brand is a
+ * registered symbol.
+ */
+export declare function isCelBytes(value: unknown): value is Uint8Array;
+/**
+ * Whether a value is a map a host handed over: a plain object, not a branded one.
+ *
+ * The prototype decides, which is why nothing else needs checking: an array, a buffer and
+ * a class instance all have a prototype of their own, so none of them is a record. It is
+ * also the cheapest test there is, and this runs on every member read.
+ */
+export declare function isCelRecord(value: unknown): value is CelRecord;
+/**
+ * The name of a value's CEL type, or nothing when the value is of no CEL type. It is
+ * what `type()` answers and what an overload is dispatched on, so it must answer for
+ * **any** value — `type()` has no `dyn` overload to fall back on.
+ */
+export declare function celTypeNameOf(value: unknown): string | undefined;
+/**
+ * A thenable reaching evaluation is refused, never passed along: evaluation is
+ * synchronous, and a promise flowing through an expression would be an invocation in
+ * disguise — invisible to a journal, absent from a trace, and unrepresentable as a
+ * step.
+ *
+ * The check is made at every **door** a host value comes through — an activation read, a
+ * registered implementation's result, a member read, an element entering a comprehension
+ * body, the value a name is bound to — and the list of them is in the package guide, which
+ * is where completeness is argued. `asyncValueRefused` is the one error they all answer
+ * with, so the code and the wording cannot drift between doors.
+ */
+export declare function isThenable(value: unknown): boolean;
+/**
+ * The refusal a value that must be awaited becomes, or nothing where it is an ordinary
+ * value.
+ *
+ * **A container is NOT walked**, and that is deliberate rather than a gap: a thenable inside
+ * a host list or map is refused when it becomes a value the engine reasons about — read by
+ * index, read as a member, or bound into a body — so every element costs one `typeof` when it
+ * is actually used, instead of every read costing a walk of what it returned.
+ */
+export declare function asyncValueRefused(value: unknown, range?: SourceRange): CelError | undefined;
+/**
+ * The value a literal node denotes. A tagged literal is not a bare host value — `1` and
+ * `1u` are different expressions — so the one reading of a tag lives here, where both
+ * backends and the checker's literal-argument guard reach it rather than each keeping a
+ * switch of its own.
+ */
+export declare function literalValue(literal: CelLiteral): CelValue;
+export {};
+//# sourceMappingURL=cel-value.d.ts.map

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

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