@rytass/bpm-core-nestjs-module 0.19.0 → 0.20.0

package/src/lib/condition/adapters/cel-v2.adapter.js

@@ -0,0 +1,371 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.celV2Adapter = exports.createCelV2Adapter = exports.CEL_V2_LIMITS = void 0;
+exports.loadCelV2Environment = loadCelV2Environment;
+exports.findCelV2ArgumentTypeMismatch = findCelV2ArgumentTypeMismatch;
+exports.parseCelV2 = parseCelV2;
+exports.classifyCelV2Error = classifyCelV2Error;
+const expression_function_registry_1 = require("../../expression-function/expression-function.registry");
+const expression_engine_failure_1 = require("../expression-engine-failure");
+const expression_function_invocation_1 = require("../expression-function-invocation");
+/**
+ * Parse-time structure limits (ADR 22 §3.4, docs/24 §2.7). They are applied by
+ * the engine while parsing, so an over-large expression never reaches the
+ * budget. Comprehension nesting is not an engine limit; P2 checks it on the AST.
+ */
+exports.CEL_V2_LIMITS = {
+    maxAstNodes: 200,
+    maxDepth: 32,
+};
+const MIXED_ARITHMETIC_OPERATORS = ['+', '-', '*', '/', '%'];
+/**
+ * A CEL `int` (a `bigint`) or `double` (a `number`) as a JS number. An int
+ * outside the safe range cannot become a double without silently changing,
+ * so it is refused (docs/24 §2.1: out of safe range is `EXPRESSION_INVALID_RESULT`).
+ */
+const toDouble = (value) => {
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'bigint' &&
+        value <= BigInt(Number.MAX_SAFE_INTEGER) &&
+        value >= BigInt(Number.MIN_SAFE_INTEGER)) {
+        return Number(value);
+    }
+    throw new expression_engine_failure_1.ExpressionEngineFailure('EXPRESSION_INVALID_RESULT');
+};
+/**
+ * The mixed `int`/`double` arithmetic cel-legacy gives for free (it only has
+ * JS numbers) and cel-v2 refuses with `no such overload`. Form values arrive as
+ * JS numbers, which cel-v2 types as `double`, while integer literals are `int`,
+ * so without these `form.amount * 2` fails (ADR 22 §3.3). The result is a
+ * `double`, as in cel-legacy.
+ *
+ * A zero divisor throws `EXPRESSION_TYPE_ERROR` (docs/24 §2.1) instead of
+ * returning `Infinity`/`NaN`, which a comparison would quietly turn into a
+ * routing decision.
+ */
+const MIXED_ARITHMETIC = {
+    '%': (left, right) => left % right,
+    '*': (left, right) => left * right,
+    '+': (left, right) => left + right,
+    '-': (left, right) => left - right,
+    '/': (left, right) => left / right,
+};
+const runMixedArithmetic = (operator, left, right) => {
+    const leftNumber = toDouble(left);
+    const rightNumber = toDouble(right);
+    if ((operator === '/' || operator === '%') && rightNumber === 0) {
+        throw new expression_engine_failure_1.ExpressionEngineFailure('EXPRESSION_TYPE_ERROR');
+    }
+    return MIXED_ARITHMETIC[operator](leftNumber, rightNumber);
+};
+/**
+ * `int == double`, exact: the int is compared as a `bigint`, so a large int is
+ * never rounded into equality with a nearby double. Registering it also gives
+ * the reverse order and `!=` (the engine derives them).
+ */
+const isIntEqualToDouble = (left, right) => {
+    const [int, double] = typeof left === 'bigint' ? [left, right] : [right, left];
+    return (typeof int === 'bigint' &&
+        typeof double === 'number' &&
+        Number.isInteger(double) &&
+        BigInt(double) === int);
+};
+/**
+ * Options that make cel-v2 read a BPM context the way cel-legacy did:
+ * undeclared roots are `dyn` (the roots are checked by the runtime's
+ * allowlist, not by declaration), and list and map literals may mix value
+ * types (`{"a": "x", "b": 2}`, which cel-legacy refuses).
+ */
+const ENVIRONMENT_OPTIONS = {
+    homogeneousAggregateLiterals: false,
+    limits: exports.CEL_V2_LIMITS,
+    unlistedVariablesAreDyn: true,
+};
+const createEnvironment = (module) => {
+    const environment = new module.Environment(ENVIRONMENT_OPTIONS);
+    MIXED_ARITHMETIC_OPERATORS.forEach((operator) => {
+        environment.registerOperator(`double ${operator} int: double`, (left, right) => runMixedArithmetic(operator, left, right));
+        environment.registerOperator(`int ${operator} double: double`, (left, right) => runMixedArithmetic(operator, left, right));
+    });
+    // `in` is deliberately not registered for mixed lists: an `int in
+    // list<double>` overload makes the engine's own `V in list<V>` ambiguous for
+    // `dyn` values, and `form.qty in [1, 2.5]` then fails at evaluation.
+    environment.registerOperator('int == double', isIntEqualToDouble);
+    return environment;
+};
+let celV2BaseEnvironment = null;
+/**
+ * Loads `@marcbachmann/cel-js` on first use, like `loadCelEngine` does for
+ * cel-legacy, and for the same reasons: a host that never evaluates a cel-v2
+ * expression never resolves the package, and the ESM-only package is loaded
+ * with `require` so every caller stays synchronous (Node >=20.19 / >=22.12).
+ *
+ * This is the environment every function environment is cloned from: options,
+ * limits and the mixed-number operators, no functions. Cloning freezes it, so
+ * it is complete before the first clone.
+ */
+const loadCelV2BaseEnvironment = () => {
+    if (celV2BaseEnvironment === null) {
+        let module;
+        try {
+            module = require('@marcbachmann/cel-js');
+        }
+        catch (error) {
+            if (typeof error === 'object' &&
+                error !== null &&
+                error.code === 'ERR_REQUIRE_ESM') {
+                throw new Error(`[@rytass/bpm-core-nestjs-module] This Node version cannot require the ESM-only '@marcbachmann/cel-js'. BPM needs Node >=20.19 or >=22.12 to evaluate cel-v2 expressions. Original error: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            throw error;
+        }
+        celV2BaseEnvironment = createEnvironment(module);
+    }
+    return celV2BaseEnvironment;
+};
+/*
+ * How a declared type is written in a cel-v2 signature. Numbers are `dyn`:
+ * cel-v2 tells an `int` literal (`1000`) from a `double` (a form value, which
+ * is a JS number), so a `double` parameter would refuse `f_v1(1000)` and an
+ * `int` one would refuse `f_v1(form.qty)`. The wrapper checks the number
+ * against the declared type instead. Every other type is enforced by the
+ * engine's overload resolution, which reports a mismatch as a type error.
+ */
+const toSignatureParameterType = (type) => type === 'double' || type === 'int' ? 'dyn' : type;
+const toSignature = (fn) => `${fn.name}(${fn.parameters
+    .map((parameter) => toSignatureParameterType(parameter.type))
+    .join(', ')}): ${fn.returnType}`;
+const celV2Environments = new WeakMap();
+/**
+ * The declared parameter types of every function registered on a function
+ * environment, by name. Kept beside the environment because numbers are
+ * registered as `dyn` (see `toSignatureParameterType`), so the engine's own
+ * check cannot tell a `string` argument handed to a `double` parameter.
+ */
+const celV2FunctionParameters = new WeakMap();
+/**
+ * The cel-v2 environment for a registry: the base environment plus every
+ * function the registry lists (the nine built-ins and the host's), built once
+ * per registry and cached. Without a registry it is the built-ins-only one.
+ *
+ * Every function is registered as a global call (`round(x)`), never as a
+ * method. The name `trim` therefore sits beside cel-v2's own `string.trim()`
+ * method without replacing it; no other built-in name exists in cel-v2.
+ *
+ * The returned environment is frozen: registering on it throws. For a
+ * type check with declared variables (P2's `env.check()`), `clone()` it and
+ * register the variables on the clone.
+ */
+function loadCelV2Environment(registry = expression_function_registry_1.BUILT_IN_EXPRESSION_FUNCTION_REGISTRY) {
+    const cached = celV2Environments.get(registry);
+    if (cached) {
+        return cached;
+    }
+    const environment = loadCelV2BaseEnvironment().clone();
+    const { functions } = (0, expression_function_invocation_1.readExpressionFunctionTable)(registry);
+    functions.forEach((fn) => {
+        environment.registerFunction(toSignature(fn), (0, expression_function_invocation_1.createExpressionFunctionInvoker)(fn, 'cel-v2'));
+    });
+    // Cloning stops the parent from registering more (documented engine
+    // behaviour), so the shared environment cannot be changed by a caller.
+    environment.clone();
+    celV2FunctionParameters.set(environment, new Map(functions.map((fn) => [
+        fn.name,
+        fn.parameters.map((parameter) => parameter.type),
+    ])));
+    celV2Environments.set(registry, environment);
+    return environment;
+}
+const isAstNode = (value) => typeof value === 'object' &&
+    value !== null &&
+    typeof value.op === 'string';
+const NUMERIC_CHECKED_TYPES = new Set([
+    'double',
+    'int',
+    'uint',
+]);
+/*
+ * The checked types (their base, `list<string>` is `list`) a parameter of
+ * each declared type accepts. `dyn` is accepted everywhere: a value the check
+ * cannot type is decided at evaluation, as before. A `double` parameter takes
+ * an `int` and an `int` one a `double` (a form number is a `double` even when
+ * it is whole); the wrapper decides those at evaluation.
+ */
+const isCheckedTypeAccepted = (checkedType, parameterType) => {
+    if (checkedType === 'dyn' || parameterType === 'dyn') {
+        return true;
+    }
+    switch (parameterType) {
+        case 'double':
+        case 'int':
+            return NUMERIC_CHECKED_TYPES.has(checkedType);
+        case 'null':
+            return checkedType === 'null';
+        default:
+            return checkedType === parameterType;
+    }
+};
+const readCheckedBaseType = (node) => {
+    const checked = node
+        ?.checkedType;
+    const name = typeof checked === 'object' && checked !== null
+        ? checked.name
+        : undefined;
+    return typeof name === 'string' ? name.split('<')[0].trim() : null;
+};
+/**
+ * The first global call to a registered function whose argument the type
+ * check typed as something the declared parameter refuses (ADR 22 §3.5): a
+ * text field handed to a `double` parameter, say. Only meaningful on the AST
+ * of an expression `check()` accepted, parsed in a clone of
+ * `loadCelV2Environment(...)`'s environment (`environment` is that
+ * environment, not the clone); an argument without a checked type, or a
+ * function the environment does not know, is skipped.
+ *
+ * The engine checks every other parameter type itself through the
+ * signature; numbers are registered as `dyn` there, which is what this
+ * closes for the publish lint.
+ *
+ * `readArgumentType`, when given, may name the type to compare instead of
+ * the checked one (a base type, `null` to keep the checked one): the lint
+ * passes the schema type of a field it had to check as `dyn`, so that
+ * `form.title != null && f(form.title)` is compared as the text it is.
+ */
+function findCelV2ArgumentTypeMismatch(ast, environment, readArgumentType = () => null) {
+    const parameters = celV2FunctionParameters.get(environment);
+    if (!parameters) {
+        return null;
+    }
+    const visit = (node) => {
+        if (Array.isArray(node)) {
+            return node.reduce((found, child) => found ?? visit(child), null);
+        }
+        if (!isAstNode(node)) {
+            return null;
+        }
+        const args = node.args;
+        if (node.op === 'call' &&
+            Array.isArray(args) &&
+            typeof args[0] === 'string' &&
+            Array.isArray(args[1])) {
+            const declared = parameters.get(args[0]);
+            const callArguments = args[1];
+            const mismatchIndex = declared && declared.length === callArguments.length
+                ? callArguments.findIndex((argument, index) => {
+                    const checkedType = readArgumentType(argument) ?? readCheckedBaseType(argument);
+                    return (checkedType !== null &&
+                        !isCheckedTypeAccepted(checkedType, declared[index]));
+                })
+                : -1;
+            if (declared && mismatchIndex >= 0) {
+                return {
+                    argument: callArguments[mismatchIndex],
+                    functionName: args[0],
+                    parameterType: declared[mismatchIndex],
+                };
+            }
+        }
+        return visit(args);
+    };
+    return visit(ast);
+}
+/**
+ * Parses with cel-v2. Returns `null` when the expression does not parse or
+ * breaks a structure limit. The engine is loaded outside the `try`: a failure
+ * to load it is a configuration error, not a bad expression.
+ *
+ * Parsing does not check that a called function exists; evaluation does.
+ */
+function parseCelV2(expression, registry = expression_function_registry_1.BUILT_IN_EXPRESSION_FUNCTION_REGISTRY) {
+    const environment = loadCelV2Environment(registry);
+    try {
+        return { native: environment.parse(expression) };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Names of the global functions an expression calls (`call` nodes; methods are
+ * `rcall` and never host functions). A small walk of the engine's AST, only
+ * for the evaluation-time check; the publish lint reads references through
+ * P2's AST module.
+ */
+const readCalledFunctionNames = (node) => {
+    if (Array.isArray(node)) {
+        return node.flatMap(readCalledFunctionNames);
+    }
+    if (!isAstNode(node)) {
+        return [];
+    }
+    const args = node.args;
+    const own = node.op === 'call' && Array.isArray(args) && typeof args[0] === 'string'
+        ? [args[0]]
+        : [];
+    return [...own, ...readCalledFunctionNames(args)];
+};
+const isCelError = (error) => error instanceof Error &&
+    (error.name === 'EvaluationError' ||
+        error.name === 'TypeError' ||
+        error.name === 'ParseError') &&
+    typeof error.code === 'string' &&
+    typeof error.summary === 'string';
+/*
+ * The only engine summaries a key name is read from. Anchored at both ends;
+ * the candidate is checked against the expression before anyone sees it.
+ * `No such key: index out of bounds, ...` does not match, by design.
+ */
+const KEY_NAME_PATTERNS = [
+    /^No such key: ([A-Za-z_][A-Za-z0-9_]*)$/u,
+    /^Unknown variable: ([A-Za-z_][A-Za-z0-9_]*)$/u,
+];
+const readKeyNameCandidate = (summary) => KEY_NAME_PATTERNS.reduce((found, pattern) => found ?? pattern.exec(summary)?.[1] ?? null, null);
+const CEL_V2_CODE_MAP = {
+    index_out_of_bounds: 'EXPRESSION_MISSING_KEY',
+    index_out_of_range: 'EXPRESSION_MISSING_KEY',
+    no_such_key: 'EXPRESSION_MISSING_KEY',
+    numeric_overflow: 'EXPRESSION_INVALID_RESULT',
+    unknown_variable: 'EXPRESSION_MISSING_KEY',
+};
+/**
+ * Maps an error cel-v2 threw to a classified failure, by its `code` only. Any
+ * code not listed is a type or evaluation error. Errors that are not cel-v2's
+ * (an operator handler's own failure, a stack overflow) pass through unchanged
+ * and are classified by the runtime.
+ */
+function classifyCelV2Error(error) {
+    if (!isCelError(error)) {
+        return error;
+    }
+    const code = CEL_V2_CODE_MAP[error.code] ?? 'EXPRESSION_TYPE_ERROR';
+    return new expression_engine_failure_1.ExpressionEngineFailure(code, code === 'EXPRESSION_MISSING_KEY'
+        ? readKeyNameCandidate(error.summary)
+        : null);
+}
+/**
+ * The cel-v2 adapter for a registry. A host function the registry no longer
+ * has (withdrawn after publishing) fails the evaluation with
+ * `EXPRESSION_FUNCTION_FAILED` before the engine runs, wherever the call sits.
+ */
+const createCelV2Adapter = (registry) => ({
+    compile: (expression) => parseCelV2(expression, registry),
+    evaluate: (handle, roots) => {
+        const parsed = handle.native;
+        if ((0, expression_function_invocation_1.callsUnavailableFunction)(readCalledFunctionNames(parsed.ast), (0, expression_function_invocation_1.readExpressionFunctionTable)(registry))) {
+            throw new expression_engine_failure_1.ExpressionEngineFailure('EXPRESSION_FUNCTION_FAILED');
+        }
+        return (0, expression_function_invocation_1.runWithExpressionFunctionFrame)(() => {
+            try {
+                return parsed({ ...roots });
+            }
+            catch (error) {
+                throw classifyCelV2Error(error);
+            }
+        });
+    },
+});
+exports.createCelV2Adapter = createCelV2Adapter;
+/** The built-ins-only adapter, used wherever no registry was handed in. */
+exports.celV2Adapter = (0, exports.createCelV2Adapter)(expression_function_registry_1.BUILT_IN_EXPRESSION_FUNCTION_REGISTRY);
+//# sourceMappingURL=cel-v2.adapter.js.map

package/src/lib/condition/adapters/cel-v2.adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cel-v2.adapter.js","sourceRoot":"","sources":["../../../../../../../libs/bpm-core/src/lib/condition/adapters/cel-v2.adapter.ts"],"names":[],"mappings":";;;AA6OA,oDAmCC;AAiFD,sEA2DC;AASD,gCAWC;AAsED,gDAaC;AA7fD,yGAA+G;AAK/G,4EAAuE;AAEvE,sFAK2C;AAW3C;;;;GAIG;AACU,QAAA,aAAa,GAAG;IAC3B,WAAW,EAAE,GAAG;IAChB,QAAQ,EAAE,EAAE;CACJ,CAAC;AAEX,MAAM,0BAA0B,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAU,CAAC;AAItE;;;;GAIG;AACH,MAAM,QAAQ,GAAG,CAAC,KAAc,EAAU,EAAE;IAC1C,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,IACE,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC;QACxC,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,EACxC,CAAC;QACD,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;IAED,MAAM,IAAI,mDAAuB,CAAC,2BAA2B,CAAC,CAAC;AACjE,CAAC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,gBAAgB,GAElB;IACF,GAAG,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,GAAG,KAAK;IAClC,GAAG,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,GAAG,KAAK;IAClC,GAAG,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,GAAG,KAAK;IAClC,GAAG,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,GAAG,KAAK;IAClC,GAAG,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,GAAG,KAAK;CACnC,CAAC;AAEF,MAAM,kBAAkB,GAAG,CACzB,QAAiC,EACjC,IAAa,EACb,KAAc,EACN,EAAE;IACV,MAAM,UAAU,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAClC,MAAM,WAAW,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAEpC,IAAI,CAAC,QAAQ,KAAK,GAAG,IAAI,QAAQ,KAAK,GAAG,CAAC,IAAI,WAAW,KAAK,CAAC,EAAE,CAAC;QAChE,MAAM,IAAI,mDAAuB,CAAC,uBAAuB,CAAC,CAAC;IAC7D,CAAC;IAED,OAAO,gBAAgB,CAAC,QAAQ,CAAC,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;AAC7D,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,kBAAkB,GAAG,CAAC,IAAa,EAAE,KAAc,EAAW,EAAE;IACpE,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,GACjB,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAE3D,OAAO,CACL,OAAO,GAAG,KAAK,QAAQ;QACvB,OAAO,MAAM,KAAK,QAAQ;QAC1B,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC;QACxB,MAAM,CAAC,MAAM,CAAC,KAAK,GAAG,CACvB,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,mBAAmB,GAAuB;IAC9C,4BAA4B,EAAE,KAAK;IACnC,MAAM,EAAE,qBAAa;IACrB,uBAAuB,EAAE,IAAI;CAC9B,CAAC;AAEF,MAAM,iBAAiB,GAAG,CAAC,MAAmB,EAAe,EAAE;IAC7D,MAAM,WAAW,GAAG,IAAI,MAAM,CAAC,WAAW,CAAC,mBAAmB,CAAC,CAAC;IAEhE,0BAA0B,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAQ,EAAE;QACpD,WAAW,CAAC,gBAAgB,CAC1B,UAAU,QAAQ,cAAc,EAChC,CAAC,IAAa,EAAE,KAAc,EAAU,EAAE,CACxC,kBAAkB,CAAC,QAAQ,EAAE,IAAI,EAAE,KAAK,CAAC,CAC5C,CAAC;QACF,WAAW,CAAC,gBAAgB,CAC1B,OAAO,QAAQ,iBAAiB,EAChC,CAAC,IAAa,EAAE,KAAc,EAAU,EAAE,CACxC,kBAAkB,CAAC,QAAQ,EAAE,IAAI,EAAE,KAAK,CAAC,CAC5C,CAAC;IACJ,CAAC,CAAC,CAAC;IACH,kEAAkE;IAClE,6EAA6E;IAC7E,qEAAqE;IACrE,WAAW,CAAC,gBAAgB,CAAC,eAAe,EAAE,kBAAkB,CAAC,CAAC;IAElE,OAAO,WAAW,CAAC;AACrB,CAAC,CAAC;AAEF,IAAI,oBAAoB,GAAuB,IAAI,CAAC;AAEpD;;;;;;;;;GASG;AACH,MAAM,wBAAwB,GAAG,GAAgB,EAAE;IACjD,IAAI,oBAAoB,KAAK,IAAI,EAAE,CAAC;QAClC,IAAI,MAAmB,CAAC;QAExB,IAAI,CAAC;YACH,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAgB,CAAC;QAC1D,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACxB,IACE,OAAO,KAAK,KAAK,QAAQ;gBACzB,KAAK,KAAK,IAAI;gBACb,KAAqC,CAAC,IAAI,KAAK,iBAAiB,EACjE,CAAC;gBACD,MAAM,IAAI,KAAK,CACb,4LACE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CACvD,EAAE,CACH,CAAC;YACJ,CAAC;YAED,MAAM,KAAK,CAAC;QACd,CAAC;QAED,oBAAoB,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACnD,CAAC;IAED,OAAO,oBAAoB,CAAC;AAC9B,CAAC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,wBAAwB,GAAG,CAAC,IAA4B,EAAU,EAAE,CACxE,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;AAErD,MAAM,WAAW,GAAG,CAAC,EAAyB,EAAU,EAAE,CACxD,GAAG,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,UAAU;KACxB,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,wBAAwB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;KAC5D,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,UAAU,EAAE,CAAC;AAErC,MAAM,iBAAiB,GAAG,IAAI,OAAO,EAGlC,CAAC;AAEJ;;;;;GAKG;AACH,MAAM,uBAAuB,GAAG,IAAI,OAAO,EAGxC,CAAC;AAEJ;;;;;;;;;;;;GAYG;AACH,SAAgB,oBAAoB,CAClC,WAA0C,oEAAqC;IAE/E,MAAM,MAAM,GAAG,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAE/C,IAAI,MAAM,EAAE,CAAC;QACX,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,MAAM,WAAW,GAAG,wBAAwB,EAAE,CAAC,KAAK,EAAE,CAAC;IACvD,MAAM,EAAE,SAAS,EAAE,GAAG,IAAA,4DAA2B,EAAC,QAAQ,CAAC,CAAC;IAE5D,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,EAAQ,EAAE;QAC7B,WAAW,CAAC,gBAAgB,CAC1B,WAAW,CAAC,EAAE,CAAC,EACf,IAAA,gEAA+B,EAAC,EAAE,EAAE,QAAQ,CAAC,CAC9C,CAAC;IACJ,CAAC,CAAC,CAAC;IACH,oEAAoE;IACpE,uEAAuE;IACvE,WAAW,CAAC,KAAK,EAAE,CAAC;IACpB,uBAAuB,CAAC,GAAG,CACzB,WAAW,EACX,IAAI,GAAG,CACL,SAAS,CAAC,GAAG,CACX,CAAC,EAAE,EAAwD,EAAE,CAAC;QAC5D,EAAE,CAAC,IAAI;QACP,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC;KACjD,CACF,CACF,CACF,CAAC;IACF,iBAAiB,CAAC,GAAG,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;IAE7C,OAAO,WAAW,CAAC;AACrB,CAAC;AAOD,MAAM,SAAS,GAAG,CAAC,KAAc,EAAyB,EAAE,CAC1D,OAAO,KAAK,KAAK,QAAQ;IACzB,KAAK,KAAK,IAAI;IACd,OAAQ,KAAmC,CAAC,EAAE,KAAK,QAAQ,CAAC;AAU9D,MAAM,qBAAqB,GAAwB,IAAI,GAAG,CAAC;IACzD,QAAQ;IACR,KAAK;IACL,MAAM;CACP,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,qBAAqB,GAAG,CAC5B,WAAmB,EACnB,aAAqC,EAC5B,EAAE;IACX,IAAI,WAAW,KAAK,KAAK,IAAI,aAAa,KAAK,KAAK,EAAE,CAAC;QACrD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,QAAQ,aAAa,EAAE,CAAC;QACtB,KAAK,QAAQ,CAAC;QACd,KAAK,KAAK;YACR,OAAO,qBAAqB,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QAChD,KAAK,MAAM;YACT,OAAO,WAAW,KAAK,MAAM,CAAC;QAChC;YACE,OAAO,WAAW,KAAK,aAAa,CAAC;IACzC,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,mBAAmB,GAAG,CAAC,IAAa,EAAiB,EAAE;IAC3D,MAAM,OAAO,GAAI,IAAkD;QACjE,EAAE,WAAW,CAAC;IAChB,MAAM,IAAI,GACR,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,KAAK,IAAI;QAC7C,CAAC,CAAE,OAAuC,CAAC,IAAI;QAC/C,CAAC,CAAC,SAAS,CAAC;IAEhB,OAAO,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AACrE,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,6BAA6B,CAC3C,GAAY,EACZ,WAAwB,EACxB,mBAAyD,GAAS,EAAE,CAAC,IAAI;IAEzE,MAAM,UAAU,GAAG,uBAAuB,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IAE5D,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,KAAK,GAAG,CAAC,IAAa,EAAoC,EAAE;QAChE,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YACxB,OAAO,IAAI,CAAC,MAAM,CAChB,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC,EACvC,IAAI,CACL,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;YACrB,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QAEvB,IACE,IAAI,CAAC,EAAE,KAAK,MAAM;YAClB,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;YACnB,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,QAAQ;YAC3B,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EACtB,CAAC;YACD,MAAM,QAAQ,GAAG,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YACzC,MAAM,aAAa,GAAuB,IAAI,CAAC,CAAC,CAAC,CAAC;YAClD,MAAM,aAAa,GACjB,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAK,aAAa,CAAC,MAAM;gBAClD,CAAC,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,QAAQ,EAAE,KAAK,EAAW,EAAE;oBACnD,MAAM,WAAW,GACf,gBAAgB,CAAC,QAAQ,CAAC,IAAI,mBAAmB,CAAC,QAAQ,CAAC,CAAC;oBAE9D,OAAO,CACL,WAAW,KAAK,IAAI;wBACpB,CAAC,qBAAqB,CAAC,WAAW,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CACrD,CAAC;gBACJ,CAAC,CAAC;gBACJ,CAAC,CAAC,CAAC,CAAC,CAAC;YAET,IAAI,QAAQ,IAAI,aAAa,IAAI,CAAC,EAAE,CAAC;gBACnC,OAAO;oBACL,QAAQ,EAAE,aAAa,CAAC,aAAa,CAAC;oBACtC,YAAY,EAAE,IAAI,CAAC,CAAC,CAAC;oBACrB,aAAa,EAAE,QAAQ,CAAC,aAAa,CAAC;iBACvC,CAAC;YACJ,CAAC;QACH,CAAC;QAED,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC;IACrB,CAAC,CAAC;IAEF,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC;AACpB,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,UAAU,CACxB,UAAkB,EAClB,WAA0C,oEAAqC;IAE/E,MAAM,WAAW,GAAG,oBAAoB,CAAC,QAAQ,CAAC,CAAC;IAEnD,IAAI,CAAC;QACH,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,CAAC;IACnD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,uBAAuB,GAAG,CAAC,IAAa,EAAqB,EAAE;IACnE,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QACxB,OAAO,IAAI,CAAC,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAC/C,CAAC;IAED,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;QACrB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;IACvB,MAAM,GAAG,GACP,IAAI,CAAC,EAAE,KAAK,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,QAAQ;QACtE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACX,CAAC,CAAC,EAAE,CAAC;IAET,OAAO,CAAC,GAAG,GAAG,EAAE,GAAG,uBAAuB,CAAC,IAAI,CAAC,CAAC,CAAC;AACpD,CAAC,CAAC;AAQF,MAAM,UAAU,GAAG,CAAC,KAAc,EAA0B,EAAE,CAC5D,KAAK,YAAY,KAAK;IACtB,CAAC,KAAK,CAAC,IAAI,KAAK,iBAAiB;QAC/B,KAAK,CAAC,IAAI,KAAK,WAAW;QAC1B,KAAK,CAAC,IAAI,KAAK,YAAY,CAAC;IAC9B,OAAQ,KAAqC,CAAC,IAAI,KAAK,QAAQ;IAC/D,OAAQ,KAAwC,CAAC,OAAO,KAAK,QAAQ,CAAC;AAExE;;;;GAIG;AACH,MAAM,iBAAiB,GAAsB;IAC3C,0CAA0C;IAC1C,+CAA+C;CAChD,CAAC;AAEF,MAAM,oBAAoB,GAAG,CAAC,OAAe,EAAiB,EAAE,CAC9D,iBAAiB,CAAC,MAAM,CACtB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,EAC/D,IAAI,CACL,CAAC;AAEJ,MAAM,eAAe,GAAkD;IACrE,mBAAmB,EAAE,wBAAwB;IAC7C,kBAAkB,EAAE,wBAAwB;IAC5C,WAAW,EAAE,wBAAwB;IACrC,gBAAgB,EAAE,2BAA2B;IAC7C,gBAAgB,EAAE,wBAAwB;CAC3C,CAAC;AAEF;;;;;GAKG;AACH,SAAgB,kBAAkB,CAAC,KAAc;IAC/C,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,IAAI,GAAG,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,uBAAuB,CAAC;IAEpE,OAAO,IAAI,mDAAuB,CAChC,IAAI,EACJ,IAAI,KAAK,wBAAwB;QAC/B,CAAC,CAAC,oBAAoB,CAAC,KAAK,CAAC,OAAO,CAAC;QACrC,CAAC,CAAC,IAAI,CACT,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACI,MAAM,kBAAkB,GAAG,CAChC,QAAuC,EACd,EAAE,CAAC,CAAC;IAC7B,OAAO,EAAE,CAAC,UAAkB,EAA2B,EAAE,CACvD,UAAU,CAAC,UAAU,EAAE,QAAQ,CAAC;IAClC,QAAQ,EAAE,CAAC,MAAM,EAAE,KAAK,EAAW,EAAE;QACnC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAqB,CAAC;QAE5C,IACE,IAAA,yDAAwB,EACtB,uBAAuB,CAAC,MAAM,CAAC,GAAG,CAAC,EACnC,IAAA,4DAA2B,EAAC,QAAQ,CAAC,CACtC,EACD,CAAC;YACD,MAAM,IAAI,mDAAuB,CAAC,4BAA4B,CAAC,CAAC;QAClE,CAAC;QAED,OAAO,IAAA,+DAA8B,EAAC,GAAY,EAAE;YAClD,IAAI,CAAC;gBACH,OAAO,MAAM,CAAC,EAAE,GAAG,KAAK,EAAE,CAAC,CAAC;YAC9B,CAAC;YAAC,OAAO,KAAc,EAAE,CAAC;gBACxB,MAAM,kBAAkB,CAAC,KAAK,CAAC,CAAC;YAClC,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;CACF,CAAC,CAAC;AAzBU,QAAA,kBAAkB,sBAyB5B;AAEH,2EAA2E;AAC9D,QAAA,YAAY,GAA4B,IAAA,0BAAkB,EACrE,oEAAqC,CACtC,CAAC"}

package/src/lib/condition/condition.service.d.ts

@@ -1,16 +1,101 @@
+import { OnApplicationBootstrap } from '@nestjs/common';
+import { ExpressionLintIssue } from '@rytass/bpm-core-shared';
+import { ExpressionBudget } from './expression-budget';
+import { JsonValue } from './expression-result.walker';
+import { type BPMExpressionFunctionRegistry } from '../expression-function/expression-function.types';
+import { ExpressionDialect } from './expression-dialect';
+import { ExpressionLintContext } from './expression-ast';
 interface ConditionExpression {
     readonly expression: string | null | undefined;
     readonly label: string;
 }
-interface ConditionLintOptions {
-    readonly allowedRootIdentifiers?: readonly string[];
+/**
+ * Lint options. Everything beyond `dialect` and `maxExpressionLength` is the
+ * cel-v2 lint context (`ExpressionLintContext`): the use point, the bound
+ * form, the function registry and the field a `SET_FORM_FIELD` writes.
+ * cel-legacy reads only the roots from it (docs/24 §1: the old dialect's lint
+ * does not change).
+ */
+export interface ConditionLintOptions extends ExpressionLintContext {
+    /**
+     * The engine whose parser decides syntax. Absent means `cel-legacy`; one
+     * this version does not know is reported as `EXPRESSION_SYNTAX_ERROR`.
+     */
+    readonly dialect?: ExpressionDialect;
     readonly maxExpressionLength?: number;
 }
+/**
+ * Options for one evaluation. Both fields are optional: without them a
+ * evaluation uses the operation's budget if it runs inside one
+ * (see `runExpressionOperation`), or a fresh single-expression budget.
+ */
+export interface ExpressionCallOptions {
+    /**
+     * Roots the expression may read. Checked at evaluation time, so a dry run
+     * cannot read a root that the published definition would be refused for.
+     */
+    readonly allowedRootIdentifiers?: readonly string[];
+    readonly budget?: ExpressionBudget;
+    /**
+     * The dialect of the definition or rule the expression belongs to. Absent
+     * means `cel-legacy`, which is what every expression saved before the
+     * dialect existed was written for (ADR 22 §3.3). One this version does not
+     * know is refused as `EXPRESSION_SYNTAX_ERROR`.
+     */
+    readonly dialect?: ExpressionDialect;
+}
 export type CelEvaluationContext = Readonly<Record<string, unknown>>;
-export declare class ConditionService {
+/** How long each dialect's warm-up took, in milliseconds; `null` if it failed. */
+export type ExpressionWarmUpResult = Readonly<Record<ExpressionDialect, number | null>>;
+export declare class ConditionService implements OnApplicationBootstrap {
+    private readonly logger;
+    private readonly functionRegistry;
+    private readonly runtime;
+    /**
+     * Evaluates and lints with the expression function registry
+     * (`BPM_EXPRESSION_FUNCTION_REGISTRY`, ADR 22 §3.5): both dialects call its
+     * functions and the cel-v2 lint checks against it. The injection is
+     * optional and `ConditionService` is also built with `new` in hosts and
+     * tests, so `new ConditionService()` still works: only the nine built-ins.
+     */
+    constructor(functionRegistry?: BPMExpressionFunctionRegistry | null);
+    /**
+     * Warms both engines at boot so the first case does not pay for it (Phase 23
+     * P3 live finding: the first evaluation after a restart took about 90 ms of
+     * its 100 ms budget, against about 1 ms warm).
+     *
+     * A warm-up that succeeded for any dialect writes one `log` line with each
+     * dialect's time (a failed one reads `failed` and has already warned with
+     * `EXPRESSION_WARM_UP_FAILED`), so a deployment can see it ran. The line
+     * holds only fixed words and milliseconds: no expression, no data. It is
+     * written here, not in `warmUp()`, so calling `warmUp()` stays silent.
+     */
+    onApplicationBootstrap(): void;
+    /**
+     * Loads each dialect's engine and this registry's environment, then parses,
+     * lints and evaluates one expression per dialect under a generous budget of
+     * its own, so module loading, the cel-v2 environment clone and the `vm`
+     * context are paid here. Never throws: a dialect that fails (a host
+     * registry that cannot be read, say) is logged with a fixed code and left
+     * cold, and the evaluations it serves fail closed as before.
+     */
+    warmUp(): ExpressionWarmUpResult;
+    /**
+     * Loads the dialect's engine and builds this registry's function
+     * environment now, outside any budget. Callers that are about to start a
+     * budgeted run (the dry run) call this first so an interrupt cannot land
+     * halfway through module loading or function registration.
+     */
+    prepareEngine(dialect?: ExpressionDialect): void;
     lintExpressions(expressions: readonly ConditionExpression[], options?: ConditionLintOptions): readonly string[];
+    /**
+     * The lint as structured findings, warnings included (docs/24 §2.2): what
+     * the designer's preview and the publish lint read. `lintExpression` is the
+     * error half of it, as the lines publish has always returned.
+     */
+    lintExpressionIssues(expression: string | null | undefined, label: string, options?: ConditionLintOptions): readonly ExpressionLintIssue[];
     lintExpression(expression: string | null | undefined, label: string, options?: ConditionLintOptions): readonly string[];
-    evaluateBoolean(expression: string | null | undefined, context: CelEvaluationContext, label: string): boolean;
-    evaluateValue(expression: string, context: CelEvaluationContext, label: string): unknown;
+    evaluateBoolean(expression: string | null | undefined, context: CelEvaluationContext, label: string, options?: ExpressionCallOptions): boolean;
+    evaluateValue(expression: string, context: CelEvaluationContext, label: string, options?: ExpressionCallOptions): JsonValue;
 }
 export {};