@telorun/cel 0.0.0-stage → 0.108.0

package/dist/environment.d.ts

@@ -0,0 +1,291 @@
+/**
+ * An environment: what names, functions and types an expression is read against.
+ *
+ * **Everything is registered the same way, including the standard library.** There is
+ * no privileged door: a host can replace `duration(string)` with its own, or remove a
+ * standard function so a call to it is refused, because the library came in through the
+ * same `registerFunction` a host uses. An engine with a built-in library behind a
+ * private registration is an engine whose library cannot be changed — which is the
+ * concrete thing this package exists to fix.
+ *
+ * `clone()` inherits everything and then diverges: registering or removing on the clone
+ * leaves the parent as it was. That is what lets one base environment be built once and
+ * specialised per site.
+ *
+ * **Two seams, and only two, let a host's vocabulary in**: `registerType`, for a named
+ * type over a base with its own operators and members, and `resolveSchemaType`, asked at
+ * every node of a JSON Schema before the structural rules. Nothing in this package knows
+ * any host's type names.
+ */
+import type { CelActivation } from "./activation.js";
+import type { CelExpression } from "./cel-expression.js";
+import type { CelProgram, EvaluateOptions } from "./cel-program.js";
+import type { EmittedModule, EmittedModuleStore, EmittedRuntime, StoredEmittedModule } from "./emitted-module.js";
+import type { CelValue } from "./cel-value.js";
+import type { CelType } from "./cel-type.js";
+import type { CheckResult } from "./checker.js";
+import type { FieldDeclaration, JsonSchemaNode, RecursiveSchemaReference, SchemaTypeResolver, UnjudgedSchemaNode } from "./json-schema-type.js";
+import type { NominalTypeDefinition } from "./nominal-type.js";
+import type { CelParseLimits } from "./parse-limits.js";
+import type { CelSignature, FunctionMetadata } from "./signature.js";
+export interface CelEnvironmentOptions {
+    /**
+     * Whether a name nothing declares reads as `dyn` instead of being reported.
+     *
+     * The default is CEL's own answer — report it. A host that types only part of what an
+     * expression may read turns it on, and a host that declares everything legal at a site
+     * leaves it off so a misspelled name is caught.
+     */
+    readonly unlistedVariablesAreDyn?: boolean;
+    /**
+     * Whether a list or map literal must hold one type. The default is off, which is
+     * CEL's: a heterogeneous literal is a `list<dyn>`, not a mistake.
+     */
+    readonly homogeneousAggregateLiterals?: boolean;
+    /** Whether `.?`, `[?]` and the `optional` members exist. Off by default, as in CEL. */
+    readonly enableOptionalTypes?: boolean;
+    /**
+     * Asked at every schema node, with the document the node belongs to, before its
+     * structure is read. It answers a registered type name with its arguments, or the
+     * document to read in place of the node — which is how a reference leaving the document
+     * is resolved, the host owning what a reference outside this document is based on.
+     */
+    readonly resolveSchemaType?: SchemaTypeResolver;
+    readonly limits?: Partial<CelParseLimits>;
+    /** Whether the standard library is registered. On by default. */
+    readonly standardLibrary?: boolean;
+    /** How many compiled expressions this environment keeps. */
+    readonly compiledCacheCapacity?: number;
+}
+export type TypeDeclaration = string | CelType | {
+    readonly fields: Readonly<Record<string, FieldDeclaration>>;
+} | {
+    readonly schema: JsonSchemaNode;
+    /**
+     * The document the schema belongs to — what a `#/…` reference inside it resolves
+     * against. Absent where the schema **is** the document, which is the common case.
+     */
+    readonly document?: JsonSchemaNode;
+};
+export interface VariableDefinition {
+    readonly name: string;
+    readonly type: CelType;
+    readonly typeName: string;
+    readonly description?: string;
+    readonly constant: boolean;
+}
+export interface FunctionDefinition {
+    readonly name: string;
+    readonly signature: string;
+    /** How the call is written: the receiver type, or null for a global call. */
+    readonly receiverType: string | null;
+    readonly parameters: readonly string[];
+    readonly returns: string;
+    readonly deterministic: boolean;
+    readonly hostBacked: boolean;
+    readonly throws?: readonly string[];
+    readonly description?: string;
+    readonly origin?: string;
+}
+export interface TypeDefinitionListing {
+    readonly name: string;
+    readonly base: string;
+    readonly parameters: readonly string[];
+    readonly description?: string;
+}
+export interface NamespaceListing {
+    readonly name: string;
+    readonly functions: readonly string[];
+    /** Whether names beyond the listed ones are reachable; see {@link NamespaceOptions.open}. */
+    readonly open: boolean;
+}
+export interface Definitions {
+    readonly variables: readonly VariableDefinition[];
+    readonly functions: readonly FunctionDefinition[];
+    readonly types: readonly TypeDefinitionListing[];
+    readonly namespaces: readonly NamespaceListing[];
+}
+/**
+ * What converting one registration's schema could not judge.
+ *
+ * A schema node this engine has no rule for is reported rather than refused: the schema
+ * is usually a third party's data, so throwing at registration would turn someone else's
+ * schema into a crash, and typing it `dyn` quietly is the hole the report exists to close.
+ * The consumer that knows where the schema was written is the one that can anchor a
+ * diagnostic at it.
+ */
+export interface SchemaRegistrationReport {
+    /** The name registered under. */
+    readonly name: string;
+    readonly unjudged: readonly UnjudgedSchemaNode[];
+    /** Every reference re-entered on the descent: a recursive schema, deliberately `dyn`. */
+    readonly recursive: readonly RecursiveSchemaReference[];
+}
+/**
+ * A namespaced function a host declares, in one of two forms.
+ *
+ * **`signature`** declares it whole, in global form (`total(double, int): double`), and this
+ * engine judges the call's arity and its argument types against it.
+ *
+ * **`name` + `returns`** declares the function's identity and its RESULT and **withholds the
+ * parameter list**, so arity and arguments are judged by nobody here. A host whose own
+ * signature grammar is richer than CEL's — an optional trailing parameter, a declared JSON
+ * Schema per parameter — judges them itself and strictly better. The two forms are exclusive
+ * 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;
+    readonly name?: never;
+    readonly returns?: never;
+} | {
+    readonly name: string;
+    readonly returns: string | CelType;
+    readonly signature?: never;
+}) & {
+    readonly deterministic?: boolean;
+    readonly hostBacked?: boolean;
+    readonly throws?: readonly string[];
+};
+/** What a host says about a namespace as a whole. */
+export interface NamespaceOptions {
+    /**
+     * Whether names beyond the declared ones are reachable through it. **Open** means a name
+     * this namespace did not declare types `dyn` and is reported by nobody: the host resolves
+     * it against vocabulary this engine does not hold — an export gate, a capability, a
+     * re-export chain — and words that verdict itself. Closed (the default) makes such a name
+     * `FUNCTION_UNRESOLVED`.
+     */
+    readonly open?: boolean;
+}
+/** How many compiled expressions an environment keeps when nothing says otherwise. */
+export declare const DEFAULT_COMPILED_CACHE_CAPACITY = 256;
+export declare class CelEnvironment {
+    private readonly registry;
+    private readonly variables;
+    private readonly types;
+    private readonly namespaceFunctions;
+    /** Namespaces that declare only part of what they reach; see {@link NamespaceOptions.open}. */
+    private readonly openNamespaces;
+    private readonly constants;
+    /** Bounded: a source text is a key an author's input decides. */
+    private readonly compiled;
+    readonly options: Required<Pick<CelEnvironmentOptions, "unlistedVariablesAreDyn" | "homogeneousAggregateLiterals" | "enableOptionalTypes">> & CelEnvironmentOptions;
+    constructor(options?: CelEnvironmentOptions, inherited?: CelEnvironment);
+    /** A new environment inheriting everything, which may then diverge. */
+    clone(options?: CelEnvironmentOptions): CelEnvironment;
+    /**
+     * Registers a function, **replacing** any registration answering the same call.
+     *
+     * Every registration forgets what this environment compiled: a program holds the
+     * overloads its call sites resolved to, so serving a cached one after the library
+     * changed would run the function that was replaced — the precise failure the
+     * replaceable library exists to avoid.
+     */
+    registerFunction(signature: string | CelSignature, metadata?: FunctionMetadata): this;
+    /** Removes the one registration answering that call. Answers whether it was there. */
+    removeFunction(signature: string | CelSignature): boolean;
+    /** Removes every registration of a name, so a call to it is unknown. */
+    removeFunctionsNamed(name: string): number;
+    /** Registers an operator over the types given, replacing one over the same types. */
+    registerOperator(operator: string, parameters: readonly string[], returns: string, metadata?: FunctionMetadata): this;
+    registerVariable(name: string, declaration: TypeDeclaration, metadata?: {
+        readonly description?: string;
+    }): this;
+    /** A name whose value never changes; it reads exactly as a variable does. */
+    registerConstant(name: string, declaration: TypeDeclaration, metadata?: {
+        readonly description?: string;
+    }): this;
+    hasVariable(name: string): boolean;
+    /**
+     * Every schema-typed registration whose schema this engine could not judge whole, with
+     * each node by JSON Pointer. Empty is every node judged, which is the normal answer.
+     */
+    schemaReports(): readonly SchemaRegistrationReport[];
+    /** Registers a named type, with every operator, conversion and member it declares. */
+    registerType(definition: NominalTypeDefinition): this;
+    /**
+     * Registers a namespace and the functions it declares. A namespace is a name that
+     * denotes a module rather than a value, which is what turns `Alias.fn(x)` into a
+     * qualified call rather than a method on something.
+     */
+    registerNamespace(name: string, functions?: readonly (string | NamespaceFunctionDeclaration)[], options?: NamespaceOptions): this;
+    /** Every namespace registered, in canonical order. */
+    namespaces(): readonly string[];
+    /** Reads an expression against this environment's namespaces. */
+    parse(source: string): CelExpression;
+    /**
+     * Checks an expression. A tree resolved under a different namespace set is **refused**
+     * rather than checked: its qualified calls are not the ones this environment would
+     * have found, so every answer about it would be about a different expression.
+     */
+    check(source: string | CelExpression): CheckResult;
+    /**
+     * Compiles an expression into a program. Nothing is type-checked here — the checker
+     * decides every verdict, and a consumer that wants one asks for it — so compiling
+     * refuses only what cannot be compiled at all: a source that did not read whole.
+     *
+     * A compile from text is memoized in a bounded cache; a tree handed over directly is
+     * compiled each time, because a tree has no identity to key on.
+     */
+    compile(source: string | CelExpression): CelProgram;
+    /** Compiles and runs an expression against an activation. */
+    evaluate(source: string | CelExpression, activation?: CelActivation, options?: EvaluateOptions): CelValue;
+    /**
+     * The JavaScript module for a set of expressions, emitted now: its text, its key and its
+     * integrity header. The same expressions in the same order against the same environment
+     * emit byte-identically, so a host may compare two emissions instead of trusting one.
+     *
+     * The host stores and loads the text; this package touches no filesystem and exports no
+     * loader. `emitterRuntime()` is what the loaded module's factory takes, and
+     * `programsFromEmittedModule` verifies its header before anything runs.
+     */
+    emit(sources: readonly string[]): EmittedModule;
+    /**
+     * The module for a set of expressions, read from the store where it holds a copy whose
+     * header matches and emitted and written where it does not — so a corrupted, stale or
+     * foreign stored copy causes a recompile rather than a run.
+     */
+    emittedModule(sources: readonly string[], store: EmittedModuleStore): StoredEmittedModule;
+    /** The runtime support library an emitted module's factory is handed. */
+    emitterRuntime(): EmittedRuntime;
+    /**
+     * This environment's digest: the order-independent hash of its resolved listing, which
+     * the key and the header are both over. A host that caches by key never needs it; a host
+     * explaining a recompile does.
+     */
+    digest(): string;
+    private expressionsOf;
+    /** What the backends need of this environment, built one way for both of them. */
+    private target;
+    /**
+     * An expression a backend may compile: read whole, and resolved under this
+     * environment's own namespaces. Nothing is type-checked — the checker decides every
+     * verdict and a consumer that wants one asks for it.
+     */
+    private readyExpression;
+    private compileExpressionNow;
+    /**
+     * Whether a value of this type can be converted to text by the environment's own
+     * `string()`. A consumer that renders a value into text asks this before it tries;
+     * `dyn` passes, because only the runtime knows what it holds.
+     */
+    convertsToString(type: CelType): boolean;
+    /** Every registration, for a listing a host prints or compares. */
+    definitions(): Definitions;
+    private readonly nominalResolver;
+    private readType;
+    private signatureOf;
+    /** The type a declaration names: a type expression, a field map, or a schema. */
+    private typeOf;
+}
+//# sourceMappingURL=environment.d.ts.map

package/dist/environment.d.ts.map

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