@praxisui/core 4.0.0-beta.0 → 5.0.0-beta.0

package/fesm2022/praxisui-core.mjs

@@ -788,13 +788,6 @@ class SchemaNormalizerService {
         }
         return undefined;
     }
-    /** Parse a predicate function: () => boolean */
-    parsePredicateFunction(fn) {
-        const parsed = this.parseFunction(fn);
-        if (!parsed)
-            return undefined;
-        return parsed;
-    }
     /** Parse a transform function: (val: any) => any */
     parseTransformFunction(fn) {
         const parsed = this.parseFunction(fn);
@@ -802,14 +795,32 @@ class SchemaNormalizerService {
             return undefined;
         return parsed;
     }
-    /**
-     * Parse de validador condicional: (value: any, model?: any) => boolean | string | Promise<boolean | string>
-     */
-    parseConditionalValidator(fn) {
-        const parsed = this.parseFunction(fn);
-        if (!parsed)
+    parseConditionalValidationRules(value, fieldName) {
+        if (value === undefined) {
             return undefined;
-        return parsed;
+        }
+        if (!Array.isArray(value)) {
+            console.warn(`[SchemaNormalizer] Ignoring non-array x-ui.conditionalValidation for field "${fieldName}". Expected an array of declarative rules.`);
+            return undefined;
+        }
+        const rules = [];
+        value.forEach((candidate, index) => {
+            if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+                console.warn(`[SchemaNormalizer] Ignoring invalid x-ui.conditionalValidation[${index}] for field "${fieldName}". Expected an object rule.`);
+                return;
+            }
+            const condition = this.parseJsonLogicExpression(candidate['condition'], fieldName, `x-ui.conditionalValidation[${index}].condition`);
+            const validatorsSource = candidate['validators'];
+            if (!validatorsSource || typeof validatorsSource !== 'object' || Array.isArray(validatorsSource)) {
+                console.warn(`[SchemaNormalizer] Ignoring x-ui.conditionalValidation[${index}] for field "${fieldName}" because validators is missing or invalid.`);
+                return;
+            }
+            rules.push({
+                condition: condition ?? null,
+                validators: this.parseValidators(validatorsSource),
+            });
+        });
+        return rules.length ? rules : undefined;
     }
     /**
      * Extrai e normaliza propriedades de validação a partir do objeto x-ui.
@@ -818,7 +829,7 @@ class SchemaNormalizerService {
      * arquivos (allowedFileTypes, fileTypeMessage, maxFileSize), custom/async validators,
      * minWords e comportamento (validationTrigger(s), validationDebounce, showInlineErrors, errorPosition).
      */
-    parseValidators(ui) {
+    parseValidators(ui, fieldName = 'unknown') {
         if (!ui || typeof ui !== 'object') {
             return {};
         }
@@ -893,9 +904,9 @@ class SchemaNormalizerService {
             if (uniq)
                 out.uniqueValidator = uniq;
         }
-        // Conditional validation rule
+        // Conditional validation rules
         if (ui.conditionalValidation !== undefined) {
-            const cond = this.parseConditionalValidator(ui.conditionalValidation);
+            const cond = this.parseConditionalValidationRules(ui.conditionalValidation, fieldName);
             if (cond)
                 out.conditionalValidation = cond;
         }
@@ -949,6 +960,19 @@ class SchemaNormalizerService {
         }
         return value.map((v) => ({ ...v }));
     }
+    parseJsonLogicExpression(value, fieldName, sourceKey) {
+        if (value === undefined) {
+            return undefined;
+        }
+        if (value === null) {
+            return null;
+        }
+        if (typeof value === 'object' && !Array.isArray(value)) {
+            return JSON.parse(JSON.stringify(value));
+        }
+        console.warn(`[SchemaNormalizer] Ignoring non-Json-Logic ${sourceKey} for field "${fieldName}". Expected object/null, received ${typeof value}.`);
+        return undefined;
+    }
     resolveNonEmptyStringToken(...values) {
         for (const value of values) {
             const text = String(value ?? '').trim();
@@ -1085,14 +1109,13 @@ class SchemaNormalizerService {
             if (ui.viewOnlyStyle !== undefined) {
                 field.viewOnlyStyle = String(ui.viewOnlyStyle);
             }
-            Object.assign(field, this.parseValidators(ui));
-            // Inline conditional functions
-            const condDisplay = this.parsePredicateFunction(ui.conditionalDisplay);
-            if (condDisplay) {
+            Object.assign(field, this.parseValidators(ui, name));
+            const condDisplay = this.parseJsonLogicExpression(ui.conditionalDisplay, name, 'x-ui.conditionalDisplay');
+            if (condDisplay !== undefined) {
                 field.conditionalDisplay = condDisplay;
             }
-            const condRequired = this.parsePredicateFunction(ui.conditionalRequired);
-            if (condRequired) {
+            const condRequired = this.parseJsonLogicExpression(ui.conditionalRequired, name, 'x-ui.conditionalRequired');
+            if (condRequired !== undefined) {
                 field.conditionalRequired = condRequired;
             }
             const transformFn = this.parseTransformFunction(ui.transformValueFunction);
@@ -1122,7 +1145,10 @@ class SchemaNormalizerService {
                 field.hint = ui.hint;
             }
             if (ui.hiddenCondition !== undefined) {
-                field.hiddenCondition = ui.hiddenCondition;
+                const hiddenCondition = this.parseJsonLogicExpression(ui.hiddenCondition, name, 'x-ui.hiddenCondition');
+                if (hiddenCondition !== undefined) {
+                    field.hiddenCondition = hiddenCondition;
+                }
             }
             if (ui.icon !== undefined) {
                 field.icon = ui.icon;
@@ -1519,7 +1545,6 @@ function resolveDefaultHeaders() {
  * HTTP-based storage that talks to praxis-config-starter user-config API.
  */
 class ApiConfigStorage {
-    static unavailableLoadBaseUrls = new Set();
     static loadAvailabilityProbes = new Map();
     http = inject(HttpClient);
     opts = inject(API_CONFIG_STORAGE_OPTIONS, { optional: true });
@@ -1551,9 +1576,6 @@ class ApiConfigStorage {
         return this.shouldPropagateClearError(key);
     }
     loadConfig(key) {
-        if (ApiConfigStorage.unavailableLoadBaseUrls.has(this.baseUrl)) {
-            return of(null);
-        }
         const existingProbe = ApiConfigStorage.loadAvailabilityProbes.get(this.baseUrl);
         if (existingProbe) {
             return defer(() => from(existingProbe).pipe(switchMap((available) => available ? this.executeLoadConfigRequest(key, false) : of(null))));
@@ -1582,11 +1604,6 @@ class ApiConfigStorage {
                 resolveProbe(true);
                 previousRelease();
             };
-            const markUnavailable = () => {
-                ApiConfigStorage.unavailableLoadBaseUrls.add(this.baseUrl);
-                resolveProbe(false);
-                previousRelease();
-            };
             return this.http
                 .get(url, { observe: 'response', headers, params })
                 .pipe(map((resp) => {
@@ -1603,7 +1620,7 @@ class ApiConfigStorage {
                     return of(cached.payload);
                 }
                 if (err.status === 404) {
-                    markUnavailable();
+                    releaseProbe?.();
                     return of(null);
                 }
                 releaseProbe?.();
@@ -1630,7 +1647,6 @@ class ApiConfigStorage {
                 return of(cached.payload);
             }
             if (err.status === 404) {
-                ApiConfigStorage.unavailableLoadBaseUrls.add(this.baseUrl);
                 return of(null);
             }
             if (this.shouldLogLoadError(key, err)) {
@@ -1645,7 +1661,8 @@ class ApiConfigStorage {
         const { type, id } = this.resolveKey(key);
         const url = `${this.baseUrl}`;
         const params = this.buildParams(type, id);
-        const headers = this.buildHeaders();
+        const cached = this.cache.get(key);
+        const headers = this.buildHeaders(cached?.etag ? { 'If-Match': this.formatEtag(cached.etag) } : undefined);
         return this.http
             .put(url, { payload: config }, { observe: 'response', headers, params })
             .pipe(map((resp) => {
@@ -1686,7 +1703,8 @@ class ApiConfigStorage {
         const { type, id } = this.resolveKey(key);
         const url = `${this.baseUrl}`;
         const params = this.buildParams(type, id);
-        const headers = this.buildHeaders();
+        const cached = this.cache.get(key);
+        const headers = this.buildHeaders(cached?.etag ? { 'If-Match': this.formatEtag(cached.etag) } : undefined);
         return this.http
             .delete(url, { observe: 'response', headers, params })
             .pipe(map(() => {
@@ -1822,9 +1840,9 @@ function isObject(value) {
  */
 function deepMerge(left, right) {
     if (right === undefined || right === null)
-        return clone$1(left);
+        return clone$2(left);
     if (Array.isArray(left)) {
-        return (Array.isArray(right) ? right : clone$1(left));
+        return (Array.isArray(right) ? right : clone$2(left));
     }
     if (!isObject(left) || !isObject(right)) {
         // Right wins when defined, else left
@@ -1837,13 +1855,13 @@ function deepMerge(left, right) {
         if (r === undefined)
             continue; // keep left as-is
         if (Array.isArray(r)) {
-            out[key] = r.map((v) => clone$1(v));
+            out[key] = r.map((v) => clone$2(v));
         }
         else if (isObject(r) && isObject(l)) {
             out[key] = deepMerge(l, r);
         }
         else {
-            out[key] = clone$1(r);
+            out[key] = clone$2(r);
         }
     }
     return out;
@@ -1855,7 +1873,7 @@ function deepMerge(left, right) {
  */
 function fillUndefined(target, defaults) {
     if (defaults === undefined || defaults === null)
-        return clone$1(target);
+        return clone$2(target);
     if (!isObject(target) || !isObject(defaults)) {
         return (target === undefined || target === null ? defaults : target);
     }
@@ -1864,7 +1882,7 @@ function fillUndefined(target, defaults) {
         const d = defaults[key];
         const t = target[key];
         if (t === undefined || t === null) {
-            out[key] = clone$1(d);
+            out[key] = clone$2(d);
         }
         else if (isObject(t) && isObject(d)) {
             out[key] = fillUndefined(t, d);
@@ -1875,7 +1893,7 @@ function fillUndefined(target, defaults) {
     }
     return out;
 }
-function clone$1(v) {
+function clone$2(v) {
     if (v == null || typeof v !== 'object')
         return v;
     try {
@@ -3726,10 +3744,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
                     args: [API_URL]
                 }] }] });
 
-/**
- * Nova arquitetura modular do TableConfig v2.0
- * Preparada para crescimento exponencial e alinhada com as 5 abas do editor
- */
 // =============================================================================
 // HELPER FUNCTIONS
 // =============================================================================
@@ -5586,53 +5600,1067 @@ class OverlayDeciderService {
             reason: this.matrix.fallback.reason,
         };
     }
-    matches(ctx, match) {
-        if (match.device && !match.device.includes(ctx.device)) {
+    matches(ctx, match) {
+        if (match.device && !match.device.includes(ctx.device)) {
+            return false;
+        }
+        if (match.fieldCount) {
+            if (match.fieldCount.min !== undefined &&
+                ctx.fieldCount < match.fieldCount.min) {
+                return false;
+            }
+            if (match.fieldCount.max !== undefined &&
+                ctx.fieldCount > match.fieldCount.max) {
+                return false;
+            }
+        }
+        if (match.dependencyCount) {
+            if (match.dependencyCount.min !== undefined &&
+                ctx.dependencyCount < match.dependencyCount.min) {
+                return false;
+            }
+            if (match.dependencyCount.max !== undefined &&
+                ctx.dependencyCount > match.dependencyCount.max) {
+                return false;
+            }
+        }
+        if (Array.isArray(match.any)) {
+            return match.any.some((sub) => this.matches(ctx, sub));
+        }
+        return true;
+    }
+    log(ctx, decision) {
+        if (this.debug) {
+            console.debug('Overlay decision', {
+                device: ctx.device,
+                fieldCount: ctx.fieldCount,
+                dependencyCount: ctx.dependencyCount,
+                pattern: decision.pattern,
+            });
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: OverlayDeciderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: OverlayDeciderService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: OverlayDeciderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+const PRAXIS_JSON_LOGIC_OPERATORS = new InjectionToken('PRAXIS_JSON_LOGIC_OPERATORS');
+function providePraxisJsonLogicOperator(definition) {
+    return {
+        provide: PRAXIS_JSON_LOGIC_OPERATORS,
+        multi: true,
+        useValue: definition,
+    };
+}
+
+class PraxisJsonLogicError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'PraxisJsonLogicError';
+    }
+}
+class PraxisJsonLogicService {
+    customOperators = new Map();
+    constructor(operatorDefinitions) {
+        for (const definition of operatorDefinitions ?? DEFAULT_JSON_LOGIC_OPERATORS) {
+            this.customOperators.set(definition.operator, definition);
+        }
+    }
+    evaluate(expression, data, options) {
+        const context = this.createContext(data, options);
+        return this.evaluateValue(expression, context);
+    }
+    evaluateResult(expression, data, options) {
+        const value = this.evaluate(expression, data, options);
+        return {
+            value,
+            truthy: this.isTruthy(value),
+        };
+    }
+    validate(expression, options) {
+        const result = this.validateResult(expression, options);
+        if (!result.valid) {
+            const first = result.issues[0];
+            throw new PraxisJsonLogicError(first.code, first.message);
+        }
+    }
+    validateResult(expression, options) {
+        const issues = [];
+        const context = this.createContext({}, options);
+        if (options?.requireExpressionObject && !this.isTopLevelExpressionObject(expression)) {
+            issues.push({
+                code: 'RULE_SHAPE_INVALID',
+                message: 'JSON Logic condition must be a single-operator object.',
+                path: '$',
+            });
+            return { valid: false, issues };
+        }
+        this.validateValue(expression, context, '$', issues, true);
+        return {
+            valid: issues.length === 0,
+            issues,
+        };
+    }
+    matches(input) {
+        if (!input.condition) {
+            return true;
+        }
+        return this.evaluateResult(input.condition, input.data, input.options).truthy;
+    }
+    truthy(value) {
+        return this.isTruthy(value);
+    }
+    createContext(data, options) {
+        return {
+            data,
+            availableRoots: options?.availableRoots,
+            defaultRoot: options?.defaultRoot,
+            allowImplicitRoot: options?.allowImplicitRoot,
+            nowUtc: options?.nowUtc,
+            userTimeZone: options?.userTimeZone,
+        };
+    }
+    evaluateValue(value, context) {
+        if (value === null) {
+            return null;
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => this.evaluateValue(item, context));
+        }
+        if (typeof value !== 'object') {
+            return value;
+        }
+        const candidateRecord = value;
+        if (!this.isExpressionObject(candidateRecord)) {
+            return this.evaluateRecord(candidateRecord, context);
+        }
+        const [operator, rawArgs] = this.getOperatorEntry(candidateRecord);
+        if (operator === 'var') {
+            return this.evaluateVar(rawArgs, context);
+        }
+        if (operator === 'and') {
+            return this.evaluateAnd(rawArgs, context);
+        }
+        if (operator === 'or') {
+            return this.evaluateOr(rawArgs, context);
+        }
+        if (operator === '!') {
+            return !this.isTruthy(this.evaluateArgs(operator, rawArgs, context, 1, 1)[0]);
+        }
+        if (operator === '!!') {
+            return this.isTruthy(this.evaluateArgs(operator, rawArgs, context, 1, 1)[0]);
+        }
+        if (operator === 'if') {
+            return this.evaluateIf(rawArgs, context);
+        }
+        if (isComparisonOperator(operator)) {
+            return this.evaluateComparison(operator, rawArgs, context);
+        }
+        if (isArithmeticOperator(operator)) {
+            return this.evaluateArithmetic(operator, rawArgs, context);
+        }
+        if (operator === 'in') {
+            return this.evaluateIn(rawArgs, context);
+        }
+        if (operator === 'cat') {
+            return this.evaluateCat(rawArgs, context);
+        }
+        if (operator === 'substr') {
+            return this.evaluateSubstr(rawArgs, context);
+        }
+        const custom = this.customOperators.get(operator);
+        if (!custom) {
+            throw new PraxisJsonLogicError('RULE_OPERATOR_UNKNOWN', `Unsupported JSON Logic operator: ${operator}`);
+        }
+        const args = this.toArgumentArray(rawArgs).map((arg) => this.evaluateValue(arg, context));
+        const helpers = {
+            evaluate: (expression) => this.evaluateValue(expression, context),
+            truthy: (candidate) => this.isTruthy(candidate),
+            resolvePath: (path) => this.resolveVarPath(path, context),
+            requireArgs: (candidateOperator, candidateArgs, min, max) => this.requireArgs(candidateOperator, candidateArgs, min, max),
+        };
+        return custom.evaluate(args, context, helpers);
+    }
+    evaluateRecord(value, context) {
+        const result = {};
+        for (const [key, child] of Object.entries(value)) {
+            result[key] = this.evaluateValue(child, context);
+        }
+        return result;
+    }
+    getOperatorEntry(expression) {
+        const entries = Object.entries(expression);
+        if (entries.length !== 1) {
+            throw new PraxisJsonLogicError('RULE_OPERATOR_UNKNOWN', 'JSON Logic expression must contain exactly one operator.');
+        }
+        return [entries[0][0], entries[0][1]];
+    }
+    evaluateVar(rawArgs, context) {
+        if (typeof rawArgs === 'string') {
+            return this.resolveVarPath(rawArgs, context);
+        }
+        if (Array.isArray(rawArgs) && rawArgs.length >= 1 && rawArgs.length <= 2) {
+            const path = rawArgs[0];
+            if (typeof path !== 'string') {
+                throw new PraxisJsonLogicError('RULE_ARGUMENT_TYPE_INVALID', '`var` requires a string path as the first argument.');
+            }
+            const resolved = this.resolveVarPath(path, context);
+            return resolved === undefined && rawArgs.length === 2 ? rawArgs[1] : resolved;
+        }
+        throw new PraxisJsonLogicError('RULE_ARITY_INVALID', '`var` requires a string path or [path, defaultValue].');
+    }
+    evaluateAnd(rawArgs, context) {
+        const args = this.toArgumentArray(rawArgs);
+        this.requireArgs('and', args, 1);
+        let result = null;
+        for (const arg of args) {
+            result = this.evaluateValue(arg, context);
+            if (!this.isTruthy(result)) {
+                return result;
+            }
+        }
+        return result;
+    }
+    evaluateOr(rawArgs, context) {
+        const args = this.toArgumentArray(rawArgs);
+        this.requireArgs('or', args, 1);
+        let result = null;
+        for (const arg of args) {
+            result = this.evaluateValue(arg, context);
+            if (this.isTruthy(result)) {
+                return result;
+            }
+        }
+        return result;
+    }
+    evaluateIf(rawArgs, context) {
+        const args = this.toArgumentArray(rawArgs);
+        this.requireArgs('if', args, 2);
+        for (let index = 0; index + 1 < args.length; index += 2) {
+            const condition = this.evaluateValue(args[index], context);
+            if (this.isTruthy(condition)) {
+                return this.evaluateValue(args[index + 1], context);
+            }
+        }
+        if (args.length % 2 === 1) {
+            return this.evaluateValue(args[args.length - 1], context);
+        }
+        return null;
+    }
+    evaluateComparison(operator, rawArgs, context) {
+        const [left, right] = this.evaluateArgs(operator, rawArgs, context, 2, 2);
+        switch (operator) {
+            case '==':
+                return left == right;
+            case '===':
+                return left === right;
+            case '!=':
+                return left != right;
+            case '!==':
+                return left !== right;
+            case '>':
+                this.assertComparable(operator, left, right);
+                return left > right;
+            case '>=':
+                this.assertComparable(operator, left, right);
+                return left >= right;
+            case '<':
+                this.assertComparable(operator, left, right);
+                return left < right;
+            case '<=':
+                this.assertComparable(operator, left, right);
+                return left <= right;
+        }
+    }
+    evaluateIn(rawArgs, context) {
+        const [needle, haystack] = this.evaluateArgs('in', rawArgs, context, 2, 2);
+        if (typeof haystack === 'string' && typeof needle === 'string') {
+            return haystack.includes(needle);
+        }
+        if (Array.isArray(haystack)) {
+            return haystack.some((item) => item === needle);
+        }
+        throw new PraxisJsonLogicError('RULE_ARGUMENT_TYPE_INVALID', '`in` requires a string haystack or an array haystack.');
+    }
+    evaluateArithmetic(operator, rawArgs, context) {
+        const args = this.evaluateArgs(operator, rawArgs, context, operator === '-' ? 1 : 1);
+        const values = args.map((candidate) => this.toFiniteNumber(operator, candidate));
+        switch (operator) {
+            case '+':
+                return values.reduce((sum, item) => sum + item, 0);
+            case '-':
+                return values.length === 1
+                    ? -values[0]
+                    : values.slice(1).reduce((acc, item) => acc - item, values[0]);
+            case '*':
+                return values.reduce((product, item) => product * item, 1);
+            case '/': {
+                this.requireArgs('/', values, 2);
+                return values.slice(1).reduce((acc, item) => acc / item, values[0]);
+            }
+            case '%': {
+                this.requireArgs('%', values, 2, 2);
+                return values[0] % values[1];
+            }
+            case 'min':
+                return Math.min(...values);
+            case 'max':
+                return Math.max(...values);
+        }
+    }
+    evaluateCat(rawArgs, context) {
+        const args = this.evaluateArgs('cat', rawArgs, context, 1);
+        return args.map((value) => value == null ? '' : String(value)).join('');
+    }
+    evaluateSubstr(rawArgs, context) {
+        const args = this.evaluateArgs('substr', rawArgs, context, 2, 3);
+        const value = args[0] == null ? '' : String(args[0]);
+        const start = Math.trunc(this.toFiniteNumber('substr', args[1]));
+        const length = args.length === 3 ? Math.trunc(this.toFiniteNumber('substr', args[2])) : undefined;
+        const normalizedStart = start < 0 ? Math.max(value.length + start, 0) : start;
+        if (length === undefined) {
+            return value.slice(normalizedStart);
+        }
+        if (length < 0) {
+            return value.slice(normalizedStart, Math.max(value.length + length, normalizedStart));
+        }
+        return value.slice(normalizedStart, normalizedStart + length);
+    }
+    evaluateArgs(operator, rawArgs, context, min, max) {
+        const args = this.toArgumentArray(rawArgs).map((arg) => this.evaluateValue(arg, context));
+        return this.requireArgs(operator, args, min, max);
+    }
+    requireArgs(operator, rawArgs, min, max) {
+        if (rawArgs.length < min) {
+            throw new PraxisJsonLogicError('RULE_ARITY_INVALID', `Operator ${operator} requires at least ${min} arguments.`);
+        }
+        if (typeof max === 'number' && rawArgs.length > max) {
+            throw new PraxisJsonLogicError('RULE_ARITY_INVALID', `Operator ${operator} accepts at most ${max} arguments.`);
+        }
+        return rawArgs;
+    }
+    resolveVarPath(path, context) {
+        if (!path.length) {
+            return context.data;
+        }
+        const availableRoots = context.availableRoots ?? [];
+        const allowImplicitRoot = context.allowImplicitRoot ?? availableRoots.length <= 1;
+        const firstToken = splitPath(path)[0];
+        if (!allowImplicitRoot && availableRoots.length > 1 && !availableRoots.includes(firstToken)) {
+            throw new PraxisJsonLogicError('RULE_CONTEXT_AMBIGUOUS', `Implicit root is not allowed for path "${path}".`);
+        }
+        return readPath(context.data, path);
+    }
+    assertComparable(operator, left, right) {
+        const comparable = (typeof left === 'number' && typeof right === 'number') ||
+            (typeof left === 'string' && typeof right === 'string');
+        if (!comparable) {
+            throw new PraxisJsonLogicError('RULE_ARGUMENT_TYPE_INVALID', `Operator ${operator} requires comparable operands.`);
+        }
+    }
+    toFiniteNumber(operator, value) {
+        if (typeof value !== 'number' || !Number.isFinite(value)) {
+            throw new PraxisJsonLogicError('RULE_ARGUMENT_TYPE_INVALID', `Operator ${operator} requires finite numeric operands.`);
+        }
+        return value;
+    }
+    toArgumentArray(rawArgs) {
+        return Array.isArray(rawArgs) ? rawArgs : [rawArgs];
+    }
+    isExpressionObject(value) {
+        const keys = Object.keys(value);
+        return keys.length === 1;
+    }
+    isTruthy(value) {
+        if (value === undefined || value === null) {
+            return false;
+        }
+        if (typeof value === 'boolean') {
+            return value;
+        }
+        if (typeof value === 'number') {
+            return value !== 0;
+        }
+        if (typeof value === 'string') {
+            return value.length > 0;
+        }
+        if (Array.isArray(value)) {
+            return value.length > 0;
+        }
+        return true;
+    }
+    validateValue(value, context, path, issues, topLevel = false) {
+        if (value === null || typeof value !== 'object') {
+            return;
+        }
+        if (Array.isArray(value)) {
+            if (topLevel) {
+                issues.push({
+                    code: 'RULE_SHAPE_INVALID',
+                    message: 'Top-level JSON Logic condition cannot be an array.',
+                    path,
+                });
+            }
+            value.forEach((item, index) => this.validateValue(item, context, `${path}[${index}]`, issues));
+            return;
+        }
+        const record = value;
+        const keys = Object.keys(record);
+        if (keys.length !== 1) {
+            if (topLevel) {
+                issues.push({
+                    code: 'RULE_SHAPE_INVALID',
+                    message: 'Top-level JSON Logic condition must contain exactly one operator.',
+                    path,
+                });
+            }
+            for (const [key, child] of Object.entries(record)) {
+                this.validateValue(child, context, `${path}.${key}`, issues);
+            }
+            return;
+        }
+        const operator = keys[0];
+        const rawArgs = record[operator];
+        if (operator === 'var') {
+            this.validateVar(rawArgs, context, path, issues);
+            return;
+        }
+        if (!this.isSupportedOperator(operator)) {
+            issues.push({
+                code: 'RULE_OPERATOR_UNKNOWN',
+                message: `Unsupported JSON Logic operator: ${operator}`,
+                path,
+                operator,
+            });
+            return;
+        }
+        const args = this.toArgumentArray(rawArgs);
+        const arity = this.getOperatorArity(operator);
+        if (arity) {
+            this.validateArity(operator, args.length, arity.min, arity.max, path, issues);
+        }
+        args.forEach((arg, index) => this.validateValue(arg, context, `${path}.${operator}[${index}]`, issues));
+    }
+    validateVar(rawArgs, context, path, issues) {
+        if (typeof rawArgs === 'string') {
+            this.validateVarPath(rawArgs, context, path, issues);
+            return;
+        }
+        if (Array.isArray(rawArgs) && rawArgs.length >= 1 && rawArgs.length <= 2) {
+            const candidatePath = rawArgs[0];
+            if (typeof candidatePath !== 'string') {
+                issues.push({
+                    code: 'RULE_ARGUMENT_TYPE_INVALID',
+                    message: '`var` requires a string path as the first argument.',
+                    path,
+                    operator: 'var',
+                });
+                return;
+            }
+            this.validateVarPath(candidatePath, context, path, issues);
+            if (rawArgs.length === 2) {
+                this.validateValue(rawArgs[1], context, `${path}.var[1]`, issues);
+            }
+            return;
+        }
+        issues.push({
+            code: 'RULE_ARITY_INVALID',
+            message: '`var` requires a string path or [path, defaultValue].',
+            path,
+            operator: 'var',
+        });
+    }
+    validateVarPath(rawPath, context, path, issues) {
+        if (!rawPath.length) {
+            return;
+        }
+        const availableRoots = context.availableRoots ?? [];
+        if (!availableRoots.length) {
+            return;
+        }
+        const firstToken = splitPath(rawPath)[0];
+        if (!firstToken) {
+            return;
+        }
+        if (ALL_RULE_CONTEXT_ROOTS.includes(firstToken)
+            && !availableRoots.includes(firstToken)) {
+            issues.push({
+                code: 'RULE_ROOT_UNKNOWN',
+                message: `Root "${firstToken}" is not available in this JSON Logic context.`,
+                path,
+                operator: 'var',
+            });
+            return;
+        }
+        const allowImplicitRoot = context.allowImplicitRoot ?? availableRoots.length <= 1;
+        if (!allowImplicitRoot
+            && availableRoots.length > 1
+            && !availableRoots.includes(firstToken)) {
+            issues.push({
+                code: 'RULE_CONTEXT_AMBIGUOUS',
+                message: `Implicit root is not allowed for path "${rawPath}".`,
+                path,
+                operator: 'var',
+            });
+        }
+    }
+    validateArity(operator, count, min, max, path, issues) {
+        if (count < min) {
+            issues.push({
+                code: 'RULE_ARITY_INVALID',
+                message: `Operator ${operator} requires at least ${min} arguments.`,
+                path,
+                operator,
+            });
+        }
+        if (typeof max === 'number' && count > max) {
+            issues.push({
+                code: 'RULE_ARITY_INVALID',
+                message: `Operator ${operator} accepts at most ${max} arguments.`,
+                path,
+                operator,
+            });
+        }
+    }
+    getOperatorArity(operator) {
+        switch (operator) {
+            case 'and':
+            case 'or':
+                return { min: 1 };
+            case '!':
+            case '!!':
+                return { min: 1, max: 1 };
+            case 'if':
+                return { min: 2 };
+            case 'in':
+            case '==':
+            case '===':
+            case '!=':
+            case '!==':
+            case '>':
+            case '>=':
+            case '<':
+            case '<=':
+                return { min: 2, max: 2 };
+            case 'cat':
+                return { min: 1 };
+            case 'substr':
+                return { min: 2, max: 3 };
+            case '+':
+            case '*':
+            case 'min':
+            case 'max':
+                return { min: 1 };
+            case '-':
+                return { min: 1 };
+            case '/':
+                return { min: 2 };
+            case '%':
+                return { min: 2, max: 2 };
+            default: {
+                const custom = this.customOperators.get(operator);
+                if (!custom) {
+                    return undefined;
+                }
+                return {
+                    min: custom.minArgs ?? 0,
+                    max: custom.maxArgs,
+                };
+            }
+        }
+    }
+    isSupportedOperator(operator) {
+        return BUILTIN_JSON_LOGIC_OPERATORS.includes(operator)
+            || this.customOperators.has(operator);
+    }
+    isTopLevelExpressionObject(value) {
+        return !!value && typeof value === 'object' && !Array.isArray(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisJsonLogicService, deps: [{ token: PRAXIS_JSON_LOGIC_OPERATORS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisJsonLogicService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisJsonLogicService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [PRAXIS_JSON_LOGIC_OPERATORS]
+                }] }] });
+const DEFAULT_JSON_LOGIC_OPERATORS = [
+    {
+        operator: 'contains',
+        minArgs: 2,
+        maxArgs: 2,
+        evaluate: (args, _context, helpers) => {
+            const [container, candidate] = helpers.requireArgs('contains', args, 2, 2);
+            if (typeof container === 'string' && typeof candidate === 'string') {
+                return container.includes(candidate);
+            }
+            if (Array.isArray(container)) {
+                return container.some((item) => item === candidate);
+            }
+            throw new PraxisJsonLogicError('RULE_ARGUMENT_TYPE_INVALID', '`contains` requires a string or array as the first argument.');
+        },
+    },
+    {
+        operator: 'startsWith',
+        minArgs: 2,
+        maxArgs: 2,
+        evaluate: (args, _context, helpers) => {
+            const [value, prefix] = helpers.requireArgs('startsWith', args, 2, 2);
+            if (typeof value !== 'string' || typeof prefix !== 'string') {
+                throw new PraxisJsonLogicError('RULE_ARGUMENT_TYPE_INVALID', '`startsWith` requires string arguments.');
+            }
+            return value.startsWith(prefix);
+        },
+    },
+    {
+        operator: 'endsWith',
+        minArgs: 2,
+        maxArgs: 2,
+        evaluate: (args, _context, helpers) => {
+            const [value, suffix] = helpers.requireArgs('endsWith', args, 2, 2);
+            if (typeof value !== 'string' || typeof suffix !== 'string') {
+                throw new PraxisJsonLogicError('RULE_ARGUMENT_TYPE_INVALID', '`endsWith` requires string arguments.');
+            }
+            return value.endsWith(suffix);
+        },
+    },
+    {
+        operator: 'matches',
+        minArgs: 2,
+        maxArgs: 2,
+        evaluate: (args, _context, helpers) => {
+            const [value, pattern] = helpers.requireArgs('matches', args, 2, 2);
+            if (typeof value !== 'string' || typeof pattern !== 'string') {
+                throw new PraxisJsonLogicError('RULE_ARGUMENT_TYPE_INVALID', '`matches` requires string arguments.');
+            }
+            try {
+                return new RegExp(pattern).test(value);
+            }
+            catch {
+                throw new PraxisJsonLogicError('RULE_ARGUMENT_TYPE_INVALID', '`matches` received an invalid regular expression.');
+            }
+        },
+    },
+    {
+        operator: 'isBlank',
+        minArgs: 1,
+        maxArgs: 1,
+        evaluate: (args, _context, helpers) => {
+            const [value] = helpers.requireArgs('isBlank', args, 1, 1);
+            if (value === undefined || value === null) {
+                return true;
+            }
+            if (typeof value === 'string') {
+                return value.trim().length === 0;
+            }
+            if (Array.isArray(value)) {
+                return value.length === 0;
+            }
+            return false;
+        },
+    },
+    {
+        operator: 'len',
+        minArgs: 1,
+        maxArgs: 1,
+        evaluate: (args, _context, helpers) => {
+            const [value] = helpers.requireArgs('len', args, 1, 1);
+            if (value === undefined || value === null) {
+                return null;
+            }
+            if (typeof value === 'string' || Array.isArray(value)) {
+                return value.length;
+            }
+            if (value instanceof Set || value instanceof Map) {
+                return value.size;
+            }
+            if (typeof value === 'object') {
+                return Object.keys(value).length;
+            }
+            throw new PraxisJsonLogicError('RULE_ARGUMENT_TYPE_INVALID', '`len` requires a string, array, set, map, or object target.');
+        },
+    },
+    {
+        operator: 'round',
+        minArgs: 1,
+        maxArgs: 1,
+        evaluate: (args, _context, helpers) => {
+            const [value] = helpers.requireArgs('round', args, 1, 1);
+            if (typeof value !== 'number' || !Number.isFinite(value)) {
+                throw new PraxisJsonLogicError('RULE_ARGUMENT_TYPE_INVALID', '`round` requires a finite numeric argument.');
+            }
+            return Math.round(value);
+        },
+    },
+    {
+        operator: 'ceil',
+        minArgs: 1,
+        maxArgs: 1,
+        evaluate: (args, _context, helpers) => {
+            const [value] = helpers.requireArgs('ceil', args, 1, 1);
+            if (typeof value !== 'number' || !Number.isFinite(value)) {
+                throw new PraxisJsonLogicError('RULE_ARGUMENT_TYPE_INVALID', '`ceil` requires a finite numeric argument.');
+            }
+            return Math.ceil(value);
+        },
+    },
+    {
+        operator: 'floor',
+        minArgs: 1,
+        maxArgs: 1,
+        evaluate: (args, _context, helpers) => {
+            const [value] = helpers.requireArgs('floor', args, 1, 1);
+            if (typeof value !== 'number' || !Number.isFinite(value)) {
+                throw new PraxisJsonLogicError('RULE_ARGUMENT_TYPE_INVALID', '`floor` requires a finite numeric argument.');
+            }
+            return Math.floor(value);
+        },
+    },
+    {
+        operator: 'abs',
+        minArgs: 1,
+        maxArgs: 1,
+        evaluate: (args, _context, helpers) => {
+            const [value] = helpers.requireArgs('abs', args, 1, 1);
+            if (typeof value !== 'number' || !Number.isFinite(value)) {
+                throw new PraxisJsonLogicError('RULE_ARGUMENT_TYPE_INVALID', '`abs` requires a finite numeric argument.');
+            }
+            return Math.abs(value);
+        },
+    },
+    {
+        operator: 'coalesce',
+        minArgs: 1,
+        evaluate: (args, _context, helpers) => {
+            const values = helpers.requireArgs('coalesce', args, 1);
+            for (const value of values) {
+                if (value !== undefined && value !== null && value !== '') {
+                    return value;
+                }
+            }
+            return null;
+        },
+    },
+    {
+        operator: 'now',
+        minArgs: 0,
+        maxArgs: 0,
+        evaluate: () => Date.now(),
+    },
+    {
+        operator: 'date',
+        minArgs: 1,
+        maxArgs: 1,
+        evaluate: (args, _context, helpers) => {
+            const [value] = helpers.requireArgs('date', args, 1, 1);
+            const parsed = parseTemporalValue(value);
+            if (!parsed) {
+                return null;
+            }
+            if (parsed.kind === 'date-only') {
+                return Date.parse(`${parsed.ymd}T00:00:00.000Z`);
+            }
+            return parsed.date.getTime();
+        },
+    },
+    {
+        operator: 'yearsSince',
+        minArgs: 1,
+        maxArgs: 1,
+        evaluate: (args, context, helpers) => {
+            const [value] = helpers.requireArgs('yearsSince', args, 1, 1);
+            const parsed = parseTemporalValue(value);
+            if (!parsed) {
+                return null;
+            }
+            const now = context.nowUtc ? new Date(context.nowUtc) : new Date();
+            return Math.floor((now.getTime() - temporalValueToInstant(parsed).getTime()) / 31557600000);
+        },
+    },
+    {
+        operator: 'monthsSince',
+        minArgs: 1,
+        maxArgs: 1,
+        evaluate: (args, context, helpers) => {
+            const [value] = helpers.requireArgs('monthsSince', args, 1, 1);
+            const parsed = parseTemporalValue(value);
+            if (!parsed) {
+                return null;
+            }
+            const now = context.nowUtc ? new Date(context.nowUtc) : new Date();
+            return Math.floor((now.getTime() - temporalValueToInstant(parsed).getTime()) / 2629800000);
+        },
+    },
+    {
+        operator: 'daysSince',
+        minArgs: 1,
+        maxArgs: 1,
+        evaluate: (args, context, helpers) => {
+            const [value] = helpers.requireArgs('daysSince', args, 1, 1);
+            const parsed = parseTemporalValue(value);
+            if (!parsed) {
+                return null;
+            }
+            const now = context.nowUtc ? new Date(context.nowUtc) : new Date();
+            return Math.floor((now.getTime() - temporalValueToInstant(parsed).getTime()) / 86400000);
+        },
+    },
+    {
+        operator: 'toNumber',
+        minArgs: 1,
+        maxArgs: 1,
+        evaluate: (args, _context, helpers) => {
+            const [value] = helpers.requireArgs('toNumber', args, 1, 1);
+            const parsed = Number(value);
+            return Number.isFinite(parsed) ? parsed : null;
+        },
+    },
+    {
+        operator: 'stringify',
+        minArgs: 1,
+        maxArgs: 1,
+        evaluate: (args, _context, helpers) => {
+            const [value] = helpers.requireArgs('stringify', args, 1, 1);
+            return value == null ? '' : String(value);
+        },
+    },
+    {
+        operator: 'jsonGet',
+        minArgs: 2,
+        maxArgs: 2,
+        evaluate: (args, _context, helpers) => {
+            const [target, path] = helpers.requireArgs('jsonGet', args, 2, 2);
+            if (typeof path !== 'string') {
+                throw new PraxisJsonLogicError('RULE_ARGUMENT_TYPE_INVALID', '`jsonGet` requires a string path.');
+            }
+            if (target === null || typeof target !== 'object' || Array.isArray(target)) {
+                throw new PraxisJsonLogicError('RULE_ARGUMENT_TYPE_INVALID', '`jsonGet` requires an object target.');
+            }
+            return readPath(target, path);
+        },
+    },
+    {
+        operator: 'hasKey',
+        minArgs: 2,
+        maxArgs: 2,
+        evaluate: (args, _context, helpers) => {
+            const [target, path] = helpers.requireArgs('hasKey', args, 2, 2);
+            if (typeof path !== 'string') {
+                throw new PraxisJsonLogicError('RULE_ARGUMENT_TYPE_INVALID', '`hasKey` requires a string path.');
+            }
+            if (target === null || typeof target !== 'object' || Array.isArray(target)) {
+                throw new PraxisJsonLogicError('RULE_ARGUMENT_TYPE_INVALID', '`hasKey` requires an object target.');
+            }
+            return hasPath(target, path);
+        },
+    },
+    {
+        operator: 'isToday',
+        minArgs: 1,
+        maxArgs: 1,
+        evaluate: (args, context, helpers) => {
+            const [candidate] = helpers.requireArgs('isToday', args, 1, 1);
+            const parsed = parseTemporalValue(candidate);
+            if (!parsed) {
+                return false;
+            }
+            return temporalValueToYmd(parsed, context) === currentYmd(context);
+        },
+    },
+    {
+        operator: 'inLast',
+        minArgs: 3,
+        maxArgs: 3,
+        evaluate: (args, context, helpers) => {
+            const [candidate, rawAmount, rawUnit] = helpers.requireArgs('inLast', args, 3, 3);
+            const parsed = parseTemporalValue(candidate);
+            const amount = Math.abs(Number(rawAmount));
+            const unit = String(rawUnit || '').toLowerCase();
+            if (!parsed || !Number.isFinite(amount) || !unit) {
+                return false;
+            }
+            const today = currentYmd(context);
+            const floor = addYmdByUnit(today, -amount, unit);
+            const candidateYmd = temporalValueToYmd(parsed, context);
+            return candidateYmd >= floor && candidateYmd <= today;
+        },
+    },
+    {
+        operator: 'weekdayIn',
+        minArgs: 2,
+        maxArgs: 2,
+        evaluate: (args, context, helpers) => {
+            const [candidate, rawDays] = helpers.requireArgs('weekdayIn', args, 2, 2);
+            const parsed = parseTemporalValue(candidate);
+            if (!parsed || !Array.isArray(rawDays)) {
+                return false;
+            }
+            const normalized = rawDays.map((item) => Number(item)).filter(Number.isFinite);
+            if (!normalized.length) {
+                return false;
+            }
+            return normalized.includes(ymdToWeekday(temporalValueToYmd(parsed, context)));
+        },
+    },
+];
+const ALL_RULE_CONTEXT_ROOTS = [
+    'form',
+    'row',
+    'computed',
+    'meta',
+    'source',
+    'event',
+    'payload',
+    'state',
+    'context',
+];
+const BUILTIN_JSON_LOGIC_OPERATORS = [
+    'var',
+    '==',
+    '===',
+    '!=',
+    '!==',
+    '>',
+    '>=',
+    '<',
+    '<=',
+    '!',
+    '!!',
+    'and',
+    'or',
+    'if',
+    'in',
+    'cat',
+    'substr',
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    'min',
+    'max',
+];
+function isComparisonOperator(operator) {
+    return ['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(operator);
+}
+function isArithmeticOperator(operator) {
+    return ['+', '-', '*', '/', '%', 'min', 'max'].includes(operator);
+}
+function parseTemporalValue(value) {
+    if (value instanceof Date && !Number.isNaN(value.getTime())) {
+        return { kind: 'instant', date: value };
+    }
+    if (typeof value === 'number') {
+        const date = new Date(value);
+        return Number.isNaN(date.getTime()) ? null : { kind: 'instant', date };
+    }
+    const raw = String(value ?? '').trim();
+    if (!raw) {
+        return null;
+    }
+    if (/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
+        return { kind: 'date-only', ymd: raw };
+    }
+    const date = new Date(raw);
+    return Number.isNaN(date.getTime()) ? null : { kind: 'instant', date };
+}
+function temporalValueToYmd(value, context) {
+    if (value.kind === 'date-only') {
+        return value.ymd;
+    }
+    return formatDateYmd(value.date, context.userTimeZone);
+}
+function temporalValueToInstant(value) {
+    if (value.kind === 'instant') {
+        return value.date;
+    }
+    return new Date(`${value.ymd}T00:00:00.000Z`);
+}
+function currentYmd(context) {
+    const now = context.nowUtc ? new Date(context.nowUtc) : new Date();
+    return formatDateYmd(now, context.userTimeZone);
+}
+function formatDateYmd(date, timeZone) {
+    if (!timeZone) {
+        return date.toISOString().slice(0, 10);
+    }
+    const formatter = new Intl.DateTimeFormat('en-CA', {
+        timeZone,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+    });
+    return formatter.format(date);
+}
+function addYmdByUnit(ymd, amount, unit) {
+    const [year, month, day] = ymd.split('-').map((item) => Number(item));
+    const base = new Date(Date.UTC(year, month - 1, day));
+    const normalized = String(unit || 'days').toLowerCase();
+    if (normalized.startsWith('week')) {
+        base.setUTCDate(base.getUTCDate() + amount * 7);
+        return base.toISOString().slice(0, 10);
+    }
+    if (normalized.startsWith('month')) {
+        return new Date(Date.UTC(base.getUTCFullYear(), base.getUTCMonth() + amount, Math.min(base.getUTCDate(), 28)))
+            .toISOString()
+            .slice(0, 10);
+    }
+    base.setUTCDate(base.getUTCDate() + amount);
+    return base.toISOString().slice(0, 10);
+}
+function ymdToWeekday(ymd) {
+    const [year, month, day] = ymd.split('-').map((item) => Number(item));
+    const date = new Date(Date.UTC(year, month - 1, day));
+    const weekday = date.getUTCDay();
+    return weekday === 0 ? 7 : weekday;
+}
+function splitPath(path) {
+    const normalized = path.startsWith('$.') ? path.slice(2) : path;
+    return normalized
+        .replace(/\["([^"]+)"\]/g, '.$1')
+        .replace(/\[(\d+)\]/g, '.$1')
+        .split('.')
+        .filter(Boolean);
+}
+function readPath(target, path) {
+    let current = target;
+    for (const segment of splitPath(path)) {
+        if (current === null || typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+function hasPath(target, path) {
+    let current = target;
+    for (const segment of splitPath(path)) {
+        if (current === null || typeof current !== 'object') {
             return false;
         }
-        if (match.fieldCount) {
-            if (match.fieldCount.min !== undefined &&
-                ctx.fieldCount < match.fieldCount.min) {
-                return false;
-            }
-            if (match.fieldCount.max !== undefined &&
-                ctx.fieldCount > match.fieldCount.max) {
-                return false;
-            }
-        }
-        if (match.dependencyCount) {
-            if (match.dependencyCount.min !== undefined &&
-                ctx.dependencyCount < match.dependencyCount.min) {
-                return false;
-            }
-            if (match.dependencyCount.max !== undefined &&
-                ctx.dependencyCount > match.dependencyCount.max) {
-                return false;
-            }
-        }
-        if (Array.isArray(match.any)) {
-            return match.any.some((sub) => this.matches(ctx, sub));
-        }
-        return true;
-    }
-    log(ctx, decision) {
-        if (this.debug) {
-            console.debug('Overlay decision', {
-                device: ctx.device,
-                fieldCount: ctx.fieldCount,
-                dependencyCount: ctx.dependencyCount,
-                pattern: decision.pattern,
-            });
+        if (!Object.prototype.hasOwnProperty.call(current, segment)) {
+            return false;
         }
+        current = current[segment];
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: OverlayDeciderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: OverlayDeciderService, providedIn: 'root' });
+    return true;
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: OverlayDeciderService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
 
+const DEFAULT_JSON_LOGIC$3 = new PraxisJsonLogicService(null);
+const FORM_RULE_OPTIONS = {
+    availableRoots: ['form'],
+    defaultRoot: 'form',
+    allowImplicitRoot: true,
+};
 // ----------------------- Utils -----------------------
 function toMessageError(key, base, message) {
     if (!message)
@@ -5788,14 +6816,32 @@ function debounceAsyncValidator(validator, waitMs) {
     };
 }
 // ----------------------- Conditional rules (metadata) -----------------------
-function composeConditionalValidators(rules) {
+function matchesConditionalValidationRule(jsonLogic, condition, model) {
+    if (!condition) {
+        return true;
+    }
+    try {
+        return jsonLogic.matches({
+            condition,
+            data: { form: model ?? {} },
+            options: FORM_RULE_OPTIONS,
+        });
+    }
+    catch (error) {
+        if (error instanceof PraxisJsonLogicError) {
+            return false;
+        }
+        throw error;
+    }
+}
+function composeConditionalValidators(rules, jsonLogic = DEFAULT_JSON_LOGIC$3) {
     // Build per-rule validators once
-    const built = rules.map((r) => buildValidatorsFromValidatorOptions(r.validators));
+    const built = rules.map((r) => buildValidatorsFromValidatorOptions(r.validators, jsonLogic));
     const sync = (control) => {
         const model = control.root?.value;
         let errors = null;
         rules.forEach((rule, idx) => {
-            if (rule.condition(model)) {
+            if (matchesConditionalValidationRule(jsonLogic, rule.condition, model)) {
                 for (const vf of built[idx].validators) {
                     const res = vf(control);
                     if (res)
@@ -5810,7 +6856,7 @@ function composeConditionalValidators(rules) {
         let errors = null;
         for (let idx = 0; idx < rules.length; idx++) {
             const rule = rules[idx];
-            if (!rule.condition(model))
+            if (!matchesConditionalValidationRule(jsonLogic, rule.condition, model))
                 continue;
             const avs = built[idx].asyncValidators;
             for (const av of avs) {
@@ -6028,9 +7074,13 @@ function buildAngularValidators(field) {
         av.push(customAsyncValidatorFn(field.asyncValidator));
     if (field.uniqueValidator)
         av.push(uniqueAsyncValidator(field.uniqueValidator, field.uniqueMessage));
-    // Conditional (function-based)
-    if (field.conditionalValidation && typeof field.conditionalValidation === 'function') {
-        av.push(conditionalAsyncValidator(field.conditionalValidation));
+    // Conditional (canonical declarative array)
+    if (Array.isArray(field.conditionalValidation)) {
+        const composed = composeConditionalValidators(field.conditionalValidation, DEFAULT_JSON_LOGIC$3);
+        if (composed.sync)
+            v.push(composed.sync);
+        if (composed.async)
+            av.push(composed.async);
     }
     // Debounce async validators if requested
     const debounceMs = field.validationDebounce;
@@ -6039,7 +7089,7 @@ function buildAngularValidators(field) {
     }
     return { validators: v, asyncValidators: av };
 }
-function buildValidatorsFromValidatorOptions(opts = {}) {
+function buildValidatorsFromValidatorOptions(opts = {}, jsonLogic = DEFAULT_JSON_LOGIC$3) {
     const v = [];
     let av = [];
     if (opts.required)
@@ -6080,17 +7130,12 @@ function buildValidatorsFromValidatorOptions(opts = {}) {
         v.push(maxFileSizeValidator(mfs));
     // Conditional (metadata array-based)
     if (opts.conditionalValidation && Array.isArray(opts.conditionalValidation)) {
-        const composed = composeConditionalValidators(opts.conditionalValidation);
+        const composed = composeConditionalValidators(opts.conditionalValidation, jsonLogic);
         if (composed.sync)
             v.push(composed.sync);
         if (composed.async)
             av.push(composed.async);
     }
-    // Conditional function support via 'conditionalValidationFn' ad-hoc entry
-    const condFn = opts.conditionalValidationFn;
-    if (typeof condFn === 'function') {
-        av.push(conditionalAsyncValidator(condFn));
-    }
     // Debounce async validators if requested
     const debounceMs = opts.validationDebounce;
     if (debounceMs && debounceMs > 0 && av.length) {
@@ -7002,15 +8047,15 @@ class DefaultLoadingRenderer {
     defaultLabel(ctx) {
         switch (ctx.phase) {
             case 'schema':
-                return 'Carregando configuração…';
+                return 'Carregando configuracao...';
             case 'mount':
-                return 'Montando interface…';
+                return 'Montando interface...';
             case 'data':
-                return 'Carregando dados…';
+                return 'Carregando dados...';
             case 'action':
-                return 'Processando…';
+                return 'Processando...';
             default:
-                return 'Carregando…';
+                return 'Carregando...';
         }
     }
     ensureRoot(doc) {
@@ -7041,6 +8086,7 @@ class DefaultLoadingRenderer {
       }
       .pfx-loading-entry[data-blocking="false"] {
         inset: 0;
+        z-index: var(--praxis-layer-loading-inline, 120);
       }
       .pfx-loading-backdrop {
         position: absolute;
@@ -7072,22 +8118,41 @@ class DefaultLoadingRenderer {
       }
       .pfx-loading-topbar {
         position: absolute;
-        top: 0;
-        left: 0;
-        right: 0;
-        height: 3px;
+        top: var(--pdx-loading-topbar-top, 0);
+        left: var(--pdx-loading-topbar-left, 0);
+        right: var(--pdx-loading-topbar-right, 0);
+        height: var(--pdx-loading-topbar-height, 3px);
         background: var(
           --pdx-loading-topbar-gradient,
           linear-gradient(90deg, transparent, var(--pdx-loading-spinner-accent, #8b5cf6), transparent)
         );
+        border-radius: var(--pdx-loading-topbar-radius, 999px);
+        box-shadow: var(--pdx-loading-topbar-shadow, none);
         animation: pfxBar 1.1s ease-in-out infinite;
       }
       .pfx-loading-inline-text {
         position: absolute;
-        top: 8px;
-        right: 12px;
+        top: var(--pdx-loading-inline-top, 8px);
+        right: var(--pdx-loading-inline-right, 12px);
+        left: auto;
+        display: var(--pdx-loading-inline-display, inline-flex);
+        align-items: center;
+        min-height: var(--pdx-loading-inline-min-height, 28px);
+        max-width: min(
+          var(--pdx-loading-inline-max-width, 320px),
+          calc(100vw - var(--pdx-loading-inline-right, 12px) - var(--pdx-loading-inline-left, 12px))
+        );
+        padding: var(--pdx-loading-inline-padding, 0);
+        border-radius: var(--pdx-loading-inline-radius, 999px);
+        border: var(--pdx-loading-inline-border, 0 solid transparent);
+        background: var(--pdx-loading-inline-bg, transparent);
+        box-shadow: var(--pdx-loading-inline-shadow, none);
         font-size: 12px;
         color: var(--pdx-loading-topbar-text, #5f6368);
+        line-height: 1.2;
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
       }
       @keyframes pfxSpin { to { transform: rotate(360deg); } }
       @keyframes pfxBar {
@@ -11688,6 +12753,7 @@ function getEditorialFormTemplateById(templateId) {
 const RULE_PROPERTY_SCHEMA = {
     field: [
         { name: 'visible', type: 'boolean', label: 'Visível' },
+        { name: 'hidden', type: 'boolean', label: 'Oculto' },
         { name: 'required', type: 'boolean', label: 'Obrigatório' },
         { name: 'readonly', type: 'boolean', label: 'Somente leitura' },
         { name: 'disabled', type: 'boolean', label: 'Desabilitado' },
@@ -12841,11 +13907,11 @@ function normalizeCompositionLink(link) {
         intent: link.intent,
     };
     if (link.transform) {
-        normalized.transform = clone(link.transform);
+        normalized.transform = clone$1(link.transform);
     }
-    const conditions = normalizeConditions(link.conditions);
-    if (conditions) {
-        normalized.conditions = conditions;
+    const condition = normalizeCondition(link.condition);
+    if (condition !== undefined) {
+        normalized.condition = condition;
     }
     const policy = normalizePolicy(link.policy);
     if (policy) {
@@ -12868,6 +13934,9 @@ function normalizeCompositionLinks(links) {
 /**
  * Canonical persisted write surface for CompositionLink[].
  * New saved shapes must serialize links under `composition.links`.
+ * Semantic guards persist only through `link.condition` as Json Logic.
+ * Operational delivery behavior remains under `link.policy` and must not be
+ * folded into the condition payload.
  */
 function serializeCompositionLinks(links) {
     return {
@@ -12880,7 +13949,7 @@ function serializeCompositionLinks(links) {
  * The canonical writer omits legacy `connections` to avoid dual-write ambiguity.
  */
 function writeCompositionLinksToPersistedPage(page, links) {
-    const { composition: _legacyComposition, ...rest } = clone(page);
+    const { composition: _legacyComposition, ...rest } = clone$1(page);
     return {
         ...rest,
         composition: serializeCompositionLinks(links),
@@ -12907,20 +13976,14 @@ function normalizeEndpoint$1(endpoint) {
         },
     };
 }
-function normalizeConditions(conditions) {
-    if (!conditions?.length) {
+function normalizeCondition(condition) {
+    if (condition === undefined) {
         return undefined;
     }
-    return conditions
-        .map((condition) => ({
-        kind: condition.kind,
-        ...(condition.expression ? { expression: condition.expression } : {}),
-        ...(condition.path ? { path: condition.path } : {}),
-        ...(condition.value !== undefined ? { value: clone(condition.value) } : {}),
-        ...(condition.negate !== undefined ? { negate: condition.negate } : {}),
-        ...(condition.description ? { description: condition.description } : {}),
-    }))
-        .sort(compareConditions);
+    if (condition === null) {
+        return null;
+    }
+    return clone$1(condition);
 }
 function normalizePolicy(policy) {
     if (!policy) {
@@ -12955,34 +14018,19 @@ function normalizeMetadata(metadata) {
     };
     return Object.keys(normalized).length ? normalized : undefined;
 }
-function compareConditions(a, b) {
-    return compareValues([
-        a.kind,
-        a.expression || '',
-        a.path || '',
-        JSON.stringify(a.value ?? null),
-        String(a.negate ?? ''),
-        a.description || '',
-    ], [
-        b.kind,
-        b.expression || '',
-        b.path || '',
-        JSON.stringify(b.value ?? null),
-        String(b.negate ?? ''),
-        b.description || '',
-    ]);
-}
 function compareNormalizedLinks(a, b) {
     return compareValues([
         a.id,
         a.intent,
         endpointSortKey(a.from),
         endpointSortKey(a.to),
+        JSON.stringify(a.condition ?? null),
     ], [
         b.id,
         b.intent,
         endpointSortKey(b.from),
         endpointSortKey(b.to),
+        JSON.stringify(b.condition ?? null),
     ]);
 }
 function endpointSortKey(endpoint) {
@@ -13011,7 +14059,7 @@ function compareValues(left, right) {
     }
     return 0;
 }
-function clone(value) {
+function clone$1(value) {
     if (value == null || typeof value !== 'object') {
         return value;
     }
@@ -13532,6 +14580,12 @@ function mapFieldDefinitionToMetadata(field) {
     if (field.hiddenCondition !== undefined) {
         metadata.hiddenCondition = field.hiddenCondition;
     }
+    if (field.conditionalDisplay !== undefined) {
+        metadata.conditionalDisplay = field.conditionalDisplay;
+    }
+    if (field.conditionalRequired !== undefined) {
+        metadata.conditionalRequired = field.conditionalRequired;
+    }
     if (field.clearButton !== undefined) {
         metadata.clearButton = field.clearButton;
     }
@@ -13598,15 +14652,12 @@ function mapFieldDefinitionToMetadata(field) {
         validators.customValidator = field.customValidator;
     if (field.asyncValidator !== undefined)
         validators.asyncValidator = field.asyncValidator;
-    // Conditional: suportar função direta e/ou regras compostas
+    // Conditional: canonical declarative rules only
     if (field.conditionalValidation !== undefined) {
         const cv = field.conditionalValidation;
         if (Array.isArray(cv)) {
             validators.conditionalValidation = cv;
         }
-        else if (typeof cv === 'function') {
-            validators.conditionalValidationFn = cv;
-        }
     }
     // Arquivos (extensão do contrato)
     if (field.allowedFileTypes !== undefined)
@@ -15449,11 +16500,12 @@ const FIELD_METADATA_CAPABILITIES = {
     version: 'v1.3',
     enums: ENUMS$1,
     notes: [
+        'Condições booleanas declarativas devem usar Json Logic canônico. Funções permanecem restritas a escapes host-level como transforms e validators customizados.',
         'Este catálogo define as capacidades genéricas de FieldMetadata.',
         'O host típico para estes metadados é FormConfig (via fieldMetadata[]) ou FormLayout.',
         'Detalhes específicos de cada controle (ex: opções de datepicker, máscaras específicas) devem ser consultados nos catálogos de microcomponentes.',
         'POLICY: Arrays e objetos (ex: options, validators) devem sofrer merge/append, nunca substituição completa sem confirmação.',
-        'Funções (conditionalRequired, transforms) não são serializáveis. O LLM não deve gerar código de função, apenas expressões string se suportado pelo interpretador, ou solicitar configuração manual.',
+        'Não gere função para conditionalDisplay/conditionalRequired. Use Json Logic serializável; funções ficam restritas a transforms e validators customizados.',
     ],
     capabilities: [
         // =============================================================================
@@ -15986,14 +17038,14 @@ const FIELD_METADATA_CAPABILITIES = {
             category: 'validation',
             valueKind: 'array',
             description: 'Regras de validacao condicional.',
-            safetyNotes: 'Condicoes com funcao exigem wiring manual.',
+            safetyNotes: 'Use regras declarativas com Json Logic serializavel; nao gere funcoes aqui.',
         },
         {
             path: 'validators.conditionalValidation[].condition',
             category: 'validation',
             valueKind: 'expression',
             description: 'Condicao para aplicar validadores.',
-            safetyNotes: 'Funcoes nao sao serializaveis; use expressao quando suportado.',
+            safetyNotes: 'Use Json Logic canônico avaliado sobre o root `form`.',
         },
         {
             path: 'validators.conditionalValidation[].validators',
@@ -16149,16 +17201,16 @@ const FIELD_METADATA_CAPABILITIES = {
             path: 'conditionalRequired',
             category: 'dependency',
             valueKind: 'expression',
-            description: 'Condição para obrigatoriedade (função ou string).',
-            safetyNotes: 'Funções não são serializáveis. Use string se o parser suportar.',
+            description: 'Condição Json Logic para obrigatoriedade declarativa.',
+            safetyNotes: 'Use Json Logic serializável; não gere função nem DSL textual.',
             intentExamples: ['obrigatório se outro campo for X', 'condicionalmente requerido'],
         },
         {
             path: 'conditionalDisplay',
             category: 'dependency',
             valueKind: 'expression',
-            description: 'Condição para visibilidade (função ou string).',
-            safetyNotes: 'Funções não são serializáveis.',
+            description: 'Condição Json Logic para visibilidade declarativa.',
+            safetyNotes: 'Use Json Logic serializável; não gere função nem DSL textual.',
             intentExamples: ['mostrar se checkbox marcado', 'visibilidade condicional'],
         },
         {
@@ -16367,8 +17419,8 @@ const CAPS = [
     { path: 'page.composition.links[].to', category: 'connections', valueKind: 'object', description: 'Endpoint de destino do link.' },
     { path: 'page.composition.links[].intent', category: 'connections', valueKind: 'string', description: 'Intencao semantica do link.' },
     { path: 'page.composition.links[].transform', category: 'connections', valueKind: 'object', description: 'Pipeline de transformacao do link.' },
-    { path: 'page.composition.links[].conditions', category: 'connections', valueKind: 'array', description: 'Condicoes opcionais de entrega.' },
-    { path: 'page.composition.links[].policy', category: 'connections', valueKind: 'object', description: 'Politicas opcionais de entrega.' },
+    { path: 'page.composition.links[].condition', category: 'connections', valueKind: 'expression', description: 'Guarda semantica opcional do link, expressa como um unico AST Json Logic canonico.' },
+    { path: 'page.composition.links[].policy', category: 'connections', valueKind: 'object', description: 'Politicas operacionais opcionais do link, como debounce, distinct e missing-value.' },
     { path: 'page.composition.links[].metadata', category: 'connections', valueKind: 'object', description: 'Metadados opcionais do link.' },
 ];
 const DYNAMIC_PAGE_AI_CAPABILITIES = {
@@ -16378,6 +17430,7 @@ const DYNAMIC_PAGE_AI_CAPABILITIES = {
     notes: [
         'Este catalogo e especifico para o componente praxis-dynamic-page.',
         'Widgets e page.composition.links sao arrays; o adapter faz merge por key estavel.',
+        'Taxonomia editorial: condition usa Json Logic canonico; transform usa pipeline declarativo; nao trate ambos como a mesma "expression".',
         'Para remocao/replace, use flags {_remove:true} ou {_replace:true} no item.',
         'Para renomear um link, inclua {_beforeKey:"link-id-anterior"} no item.',
         'Inputs de widgets dependem do componente (ex: praxis-table, praxis-dynamic-form). Evite inventar campos; prefira pedir confirmacao.',
@@ -19211,8 +20264,23 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
             args: [{ providedIn: 'root' }]
         }] });
 
+const DEFAULT_JSON_LOGIC$2 = new PraxisJsonLogicService(null);
 class WidgetPageStateRuntimeService {
+    jsonLogic;
     connections = new ConnectionManagerService();
+    selectCaseRuleOptions = {
+        availableRoots: ['state', 'context'],
+        defaultRoot: 'state',
+        allowImplicitRoot: true,
+    };
+    derivedValueRuleOptions = {
+        availableRoots: ['state', 'context'],
+        defaultRoot: 'state',
+        allowImplicitRoot: true,
+    };
+    constructor(jsonLogic = DEFAULT_JSON_LOGIC$2) {
+        this.jsonLogic = jsonLogic;
+    }
     normalizeState(state) {
         if (!state)
             return { values: {} };
@@ -19324,8 +20392,8 @@ class WidgetPageStateRuntimeService {
         if (compute.kind === 'template') {
             return this.resolveTemplate(compute.value, env);
         }
-        if (compute.kind === 'expr') {
-            return this.readPath(env, compute.expression.trim());
+        if (compute.kind === 'json-logic') {
+            return this.evaluateDerivedJsonLogic(compute.expression, env, diagnostics, key);
         }
         if (compute.kind === 'transformer') {
             diagnostics.push(`Derived state '${key}' references transformer '${compute.transformerId}', but transformer runtime is not implemented yet.`);
@@ -19441,7 +20509,7 @@ class WidgetPageStateRuntimeService {
                 return Object.values(source).filter((value) => !this.isEmptyValue(value)).length;
             }
             case 'select-case':
-                return this.selectCase(options, env);
+                return this.selectCase(options, env, diagnostics, key);
             case 'template':
                 return this.resolveTemplate(options['value'], env);
             default:
@@ -19541,13 +20609,31 @@ class WidgetPageStateRuntimeService {
             metric: this.formatFieldValue(total, options['metricFormat'] || 'integer'),
         }));
     }
-    selectCase(options, env) {
+    selectCase(options, env, diagnostics, key) {
         const cases = Array.isArray(options['cases']) ? options['cases'] : [];
         for (const item of cases) {
             if (!item || typeof item !== 'object')
                 continue;
-            if (!this.matchesCase(item['when'], env.state))
+            const condition = item['when'];
+            try {
+                const matched = this.jsonLogic.matches({
+                    condition: condition ?? null,
+                    data: {
+                        state: this.clone(env.state) || {},
+                        context: this.clone(env.context) || {},
+                    },
+                    options: this.selectCaseRuleOptions,
+                });
+                if (!matched)
+                    continue;
+            }
+            catch (error) {
+                const detail = error instanceof PraxisJsonLogicError
+                    ? error.message
+                    : this.describeError(error);
+                diagnostics.push(`Derived state '${key}' uses invalid select-case Json Logic condition: ${detail}`);
                 continue;
+            }
             return this.resolveCaseValue(item, env);
         }
         return this.resolveCaseValue({
@@ -19556,42 +20642,20 @@ class WidgetPageStateRuntimeService {
             path: options['defaultPath'],
         }, env);
     }
-    matchesCase(condition, state) {
-        if (!condition || typeof condition !== 'object')
-            return false;
-        const path = typeof condition['path'] === 'string' ? condition['path'].trim() : '';
-        const value = path ? this.readPath(state, path) : undefined;
-        const compareValue = condition['comparePath']
-            ? this.readPath(state, String(condition['comparePath']).trim())
-            : condition['value'];
-        if ('equals' in condition)
-            return value === condition['equals'];
-        if ('notEquals' in condition)
-            return value !== condition['notEquals'];
-        if (condition['truthy'] === true)
-            return Boolean(value);
-        if (condition['falsy'] === true)
-            return !value;
-        if (condition['notEmpty'] === true)
-            return value != null && String(value).trim().length > 0;
-        if ('lt' in condition)
-            return this.toNumber(value) < this.toNumber(condition['lt']);
-        if ('lte' in condition)
-            return this.toNumber(value) <= this.toNumber(condition['lte']);
-        if ('gt' in condition)
-            return this.toNumber(value) > this.toNumber(condition['gt']);
-        if ('gte' in condition)
-            return this.toNumber(value) >= this.toNumber(condition['gte']);
-        if ('comparePath' in condition && 'op' in condition) {
-            switch (String(condition['op']).trim()) {
-                case 'lt': return this.toNumber(value) < this.toNumber(compareValue);
-                case 'lte': return this.toNumber(value) <= this.toNumber(compareValue);
-                case 'gt': return this.toNumber(value) > this.toNumber(compareValue);
-                case 'gte': return this.toNumber(value) >= this.toNumber(compareValue);
-                case 'equals': return value === compareValue;
+    evaluateDerivedJsonLogic(expression, env, diagnostics, key) {
+        try {
+            return this.jsonLogic.evaluate(expression, {
+                state: this.clone(env.state) || {},
+                context: this.clone(env.context) || {},
+            }, this.derivedValueRuleOptions);
+        }
+        catch (error) {
+            if (error instanceof PraxisJsonLogicError) {
+                diagnostics.push(`Derived state '${key}' has invalid JSON Logic: ${error.message}`);
+                return undefined;
             }
+            throw error;
         }
-        return false;
     }
     resolveCaseValue(item, env) {
         if ('path' in item && typeof item['path'] === 'string' && item['path'].trim()) {
@@ -19721,13 +20785,13 @@ class WidgetPageStateRuntimeService {
             return error;
         return 'Unknown runtime error';
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: WidgetPageStateRuntimeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: WidgetPageStateRuntimeService, deps: [{ token: PraxisJsonLogicService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: WidgetPageStateRuntimeService, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: WidgetPageStateRuntimeService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }] });
+        }], ctorParameters: () => [{ type: PraxisJsonLogicService }] });
 
 class CompositionRuntimeStore {
     snapshot;
@@ -20001,12 +21065,20 @@ function isSupportedTransformKind(kind) {
 
 const DEFAULT_PATH_ACCESSOR$1 = new ConnectionManagerService();
 const DEFAULT_TEMPLATE_RESOLVER = new SurfaceBindingRuntimeService();
+const DEFAULT_JSON_LOGIC$1 = new PraxisJsonLogicService(null);
+const TRANSFORM_RULE_OPTIONS = {
+    availableRoots: ['event', 'payload', 'state', 'context', 'source'],
+    defaultRoot: 'source',
+    allowImplicitRoot: true,
+};
 class TransformRuntimeService {
     pathAccessor;
     templateResolver;
-    constructor(pathAccessor = DEFAULT_PATH_ACCESSOR$1, templateResolver = DEFAULT_TEMPLATE_RESOLVER) {
+    jsonLogic;
+    constructor(pathAccessor = DEFAULT_PATH_ACCESSOR$1, templateResolver = DEFAULT_TEMPLATE_RESOLVER, jsonLogic = DEFAULT_JSON_LOGIC$1) {
         this.pathAccessor = pathAccessor;
         this.templateResolver = templateResolver;
+        this.jsonLogic = jsonLogic;
     }
     executePipeline(pipeline, runtime) {
         const diagnostics = [];
@@ -20153,25 +21225,7 @@ class TransformRuntimeService {
         if (!condition) {
             return true;
         }
-        const sourceValue = condition.source
-            ? this.resolveBindingSource(condition.source, env, undefined)
-            : env['current'];
-        const value = condition.path
-            ? this.pathAccessor.extractByPath(sourceValue, condition.path)
-            : sourceValue;
-        if (condition.truthy === true && !value) {
-            return false;
-        }
-        if (condition.equals !== undefined && value !== condition.equals) {
-            return false;
-        }
-        if (condition.notEquals !== undefined && value === condition.notEquals) {
-            return false;
-        }
-        if (condition.notEmpty === true && this.isEmptyValue(value)) {
-            return false;
-        }
-        return true;
+        return this.matchesJsonLogic(condition, env);
     }
     resolveConstantStep(step, inputs) {
         if (step.input?.value !== undefined) {
@@ -20291,7 +21345,11 @@ class TransformRuntimeService {
             ? step.config?.['cases']
             : [];
         for (const item of cases) {
-            if (!this.matchesCase(item['when'], env, source)) {
+            if (!this.matchesJsonLogic(item['when'], {
+                ...env,
+                source,
+                current: source,
+            })) {
                 continue;
             }
             return this.resolveCaseValue(item, env, source);
@@ -20302,30 +21360,30 @@ class TransformRuntimeService {
             path: step.config?.['defaultPath'],
         }, env, source);
     }
-    matchesCase(condition, env, source) {
-        if (!condition || typeof condition !== 'object') {
-            return false;
-        }
-        const conditionRecord = condition;
-        const path = typeof conditionRecord['path'] === 'string'
-            ? conditionRecord['path'].trim()
-            : '';
-        const value = path
-            ? this.resolveCasePath(path, env, source)
-            : source;
-        if ('equals' in conditionRecord) {
-            return value === conditionRecord['equals'];
-        }
-        if ('notEquals' in conditionRecord) {
-            return value !== conditionRecord['notEquals'];
+    matchesJsonLogic(condition, env) {
+        if (!condition) {
+            return true;
         }
-        if (conditionRecord['truthy'] === true) {
-            return Boolean(value);
+        const data = {
+            event: this.toJsonLogicValue(this.clone(env['event'])),
+            payload: this.toJsonLogicValue(this.clone(env['payload'])),
+            state: this.toJsonLogicValue(this.clone(env['state']) || {}),
+            context: this.toJsonLogicValue(this.clone(env['context']) || {}),
+            source: this.toJsonLogicValue(this.clone(env['current'])),
+        };
+        try {
+            return this.jsonLogic.matches({
+                condition,
+                data,
+                options: TRANSFORM_RULE_OPTIONS,
+            });
         }
-        if (conditionRecord['notEmpty'] === true) {
-            return !this.isEmptyValue(value);
+        catch (error) {
+            if (error instanceof PraxisJsonLogicError) {
+                return false;
+            }
+            throw error;
         }
-        return false;
     }
     resolveCaseValue(item, env, source) {
         if (typeof item['path'] === 'string' && item['path'].trim()) {
@@ -20459,23 +21517,39 @@ class TransformRuntimeService {
         }
         return hash.toString(36);
     }
+    toJsonLogicValue(value) {
+        if (value === null
+            || typeof value === 'string'
+            || typeof value === 'number'
+            || typeof value === 'boolean') {
+            return value;
+        }
+        if (Array.isArray(value) || (value && typeof value === 'object')) {
+            return value;
+        }
+        return value == null ? null : String(value);
+    }
 }
 
 const DEFAULT_PATH_ACCESSOR = new ConnectionManagerService();
 const DEFAULT_TRANSFORM_RUNNER = new TransformRuntimeService();
+const DEFAULT_JSON_LOGIC = new PraxisJsonLogicService(null);
+const COMPOSITION_RULE_ROOTS = ['source', 'event', 'payload', 'state', 'context', 'meta'];
 class LinkExecutorService {
     transforms;
     pathAccessor;
-    constructor(transforms = DEFAULT_TRANSFORM_RUNNER, pathAccessor = DEFAULT_PATH_ACCESSOR) {
+    jsonLogic;
+    constructor(transforms = DEFAULT_TRANSFORM_RUNNER, pathAccessor = DEFAULT_PATH_ACCESSOR, jsonLogic = DEFAULT_JSON_LOGIC) {
         this.transforms = transforms;
         this.pathAccessor = pathAccessor;
+        this.jsonLogic = jsonLogic;
     }
     executeLink(link, context) {
         const diagnostics = [];
         const snapshot = this.cloneSnapshot(context.snapshot.state);
         const now = context.now || new Date().toISOString();
         const sourceValue = this.resolveSourceValue(link.from, context, snapshot);
-        if (!this.matchesConditions(link, sourceValue, context, snapshot, diagnostics)) {
+        if (!this.matchesCondition(link, sourceValue, context, snapshot, diagnostics)) {
             return {
                 status: diagnostics.some((item) => item.severity === 'error' || item.severity === 'fatal')
                     ? 'failed'
@@ -20483,7 +21557,7 @@ class LinkExecutorService {
                 value: sourceValue,
                 diagnostics,
                 snapshot,
-                skippedReason: diagnostics.length ? 'condition-error' : 'conditions-not-matched',
+                skippedReason: diagnostics.length ? 'condition-error' : 'condition-not-matched',
             };
         }
         const transformResult = link.transform
@@ -20576,113 +21650,52 @@ class LinkExecutorService {
             context: context.context || {},
         }, normalized);
     }
-    matchesConditions(link, sourceValue, context, snapshot, diagnostics) {
-        for (const condition of link.conditions || []) {
-            const result = this.evaluateCondition(condition, sourceValue, context, snapshot, link, diagnostics);
-            if (!result) {
-                return false;
-            }
-        }
-        return true;
-    }
-    evaluateCondition(condition, sourceValue, context, snapshot, link, diagnostics) {
-        let matched = true;
-        switch (condition.kind) {
-            case 'always':
-                matched = true;
-                break;
-            case 'present':
-                matched = !this.isEmptyValue(this.readConditionValue(condition.path, sourceValue, context, snapshot));
-                break;
-            case 'equals':
-                matched = this.readConditionValue(condition.path, sourceValue, context, snapshot) === condition.value;
-                break;
-            case 'changed':
-                matched = !this.isEqual(sourceValue, context.lastDeliveredValue);
-                break;
-            case 'matches-port-kind':
-                matched = this.matchesPortKind(link, condition.value);
-                break;
-            case 'expression':
-                matched = this.evaluateExpression(condition.expression, sourceValue, context, snapshot, link, diagnostics);
-                break;
-            default:
-                matched = true;
-                break;
-        }
-        return condition.negate ? !matched : matched;
-    }
-    evaluateExpression(expression, sourceValue, context, snapshot, link, diagnostics) {
-        const normalized = String(expression || '').trim();
-        if (!normalized) {
+    matchesCondition(link, sourceValue, context, snapshot, diagnostics) {
+        if (!link.condition) {
             return true;
         }
-        const binary = normalized.match(/^(.*?)\s*(===|!==|==|!=)\s*(.*?)$/);
-        if (binary) {
-            const left = this.resolveExpressionOperand(binary[1], sourceValue, context, snapshot);
-            const right = this.resolveExpressionOperand(binary[3], sourceValue, context, snapshot);
-            switch (binary[2]) {
-                case '===':
-                case '==':
-                    return left === right;
-                case '!==':
-                case '!=':
-                    return left !== right;
-            }
-        }
-        if (/^(payload|event|state|context|source)\b/.test(normalized)) {
-            return Boolean(this.resolveExpressionOperand(normalized, sourceValue, context, snapshot));
-        }
-        diagnostics.push(this.createDiagnostic(link, 'RUNTIME_CONDITION_EXPRESSION_UNSUPPORTED', 'warning', `A expressao '${normalized}' nao e suportada pelo runtime inicial e foi tratada como falsa.`, {
-            expression: normalized,
-        }));
-        return false;
-    }
-    resolveExpressionOperand(token, sourceValue, context, snapshot) {
-        const normalized = token.trim();
-        if (normalized === 'null') {
-            return null;
-        }
-        if (normalized === 'undefined') {
-            return undefined;
-        }
-        if (normalized === 'true') {
-            return true;
+        try {
+            return this.jsonLogic.matches({
+                condition: link.condition,
+                data: this.buildConditionData(sourceValue, context, snapshot),
+                options: {
+                    availableRoots: [...COMPOSITION_RULE_ROOTS],
+                    defaultRoot: null,
+                    allowImplicitRoot: false,
+                    nowUtc: context.now || new Date().toISOString(),
+                },
+            });
         }
-        if (normalized === 'false') {
+        catch (error) {
+            const details = {
+                condition: link.condition,
+            };
+            if (error instanceof PraxisJsonLogicError) {
+                details['jsonLogicCode'] = error.code;
+            }
+            else if (error instanceof Error) {
+                details['error'] = error.message;
+            }
+            diagnostics.push(this.createDiagnostic(link, 'RUNTIME_LINK_CONDITION_INVALID', 'warning', 'A condicao Json Logic do link falhou em runtime e foi tratada como falsa.', details));
             return false;
         }
-        if (/^-?\d+(\.\d+)?$/.test(normalized)) {
-            return Number(normalized);
-        }
-        if ((normalized.startsWith('"') && normalized.endsWith('"'))
-            || (normalized.startsWith('\'') && normalized.endsWith('\''))) {
-            return normalized.slice(1, -1);
-        }
-        return this.pathAccessor.extractByPath({
-            source: sourceValue,
-            event: context.event,
-            payload: context.payload !== undefined
+    }
+    buildConditionData(sourceValue, context, snapshot) {
+        return {
+            source: this.clone(sourceValue),
+            event: this.clone(context.event),
+            payload: this.clone(context.payload !== undefined
                 ? context.payload
                 : (context.event && typeof context.event === 'object'
                     ? context.event['payload']
-                    : undefined),
-            state: this.buildEffectiveState(snapshot),
-            context: context.context || {},
-        }, normalized);
-    }
-    readConditionValue(path, sourceValue, context, snapshot) {
-        if (!path) {
-            return sourceValue;
-        }
-        return this.resolveExpressionOperand(path, sourceValue, context, snapshot);
-    }
-    matchesPortKind(link, value) {
-        const expected = String(value || '').trim();
-        if (!expected || link.to.kind !== 'component-port') {
-            return false;
-        }
-        return link.to.ref.port === expected;
+                    : undefined)),
+            state: this.clone(this.buildEffectiveState(snapshot)),
+            context: this.clone(context.context || {}),
+            meta: {
+                now: context.now || new Date().toISOString(),
+                lastDeliveredAt: context.lastDeliveredAt ?? null,
+            },
+        };
     }
     buildTransformContext(context, snapshot, sourceValue) {
         const eventPayload = context.payload !== undefined
@@ -21606,6 +22619,202 @@ class CompositionRuntimeFacade {
     }
 }
 
+function migrateLegacyCompositionLinks(links) {
+    return (links || []).map((link) => migrateLegacyCompositionLink(link));
+}
+function migrateLegacyCompositionLink(link) {
+    const cloned = clone(link);
+    const { condition: rawCondition, conditions, meta, policy: currentPolicy, metadata: currentMetadata, ...rest } = cloned;
+    const resolvedCondition = resolveCanonicalCondition(rest.id, rawCondition, conditions, meta?.filterExpr);
+    const resolvedPolicy = mergeLegacyPolicy(currentPolicy, meta);
+    const usedLegacyCondition = rawCondition === undefined && (!!conditions?.length || !!meta?.filterExpr)
+        || typeof rawCondition === 'string';
+    const usedLegacyPolicy = !!meta && (meta.debounceMs !== undefined
+        || meta.distinct !== undefined
+        || meta.distinctBy !== undefined);
+    return {
+        ...rest,
+        ...(resolvedCondition !== undefined ? { condition: resolvedCondition } : {}),
+        ...(resolvedPolicy ? { policy: resolvedPolicy } : {}),
+        ...(mergeLegacyMetadata(currentMetadata, usedLegacyCondition || usedLegacyPolicy)
+            ? { metadata: mergeLegacyMetadata(currentMetadata, usedLegacyCondition || usedLegacyPolicy) }
+            : {}),
+    };
+}
+function resolveCanonicalCondition(linkId, rawCondition, legacyConditions, legacyFilterExpr) {
+    if (rawCondition === null) {
+        return null;
+    }
+    if (rawCondition !== undefined && typeof rawCondition !== 'string') {
+        return rawCondition;
+    }
+    const migrated = [];
+    if (typeof rawCondition === 'string' && rawCondition.trim()) {
+        migrated.push(parseLegacyExpression(rawCondition.trim(), linkId, 'condition'));
+    }
+    for (const condition of legacyConditions || []) {
+        const migratedCondition = migrateLegacyCondition(linkId, condition);
+        if (migratedCondition === true) {
+            continue;
+        }
+        migrated.push(migratedCondition);
+    }
+    if (legacyFilterExpr?.trim()) {
+        migrated.push(parseLegacyExpression(legacyFilterExpr.trim(), linkId, 'meta.filterExpr'));
+    }
+    if (!migrated.length) {
+        return undefined;
+    }
+    if (migrated.length === 1) {
+        return migrated[0];
+    }
+    return { and: migrated };
+}
+function migrateLegacyCondition(linkId, condition) {
+    let migrated;
+    switch (condition.kind) {
+        case 'always':
+            migrated = true;
+            break;
+        case 'expression':
+            migrated = parseLegacyExpression(requireString(condition.expression, linkId, 'condition.expression'), linkId, 'conditions[].expression');
+            break;
+        case 'equals':
+            migrated = {
+                '===': [
+                    buildVarReference(condition.path || 'source'),
+                    toJsonLogicValue(condition.value),
+                ],
+            };
+            break;
+        case 'present':
+            migrated = {
+                '!': [
+                    {
+                        isBlank: [buildVarReference(condition.path || 'source')],
+                    },
+                ],
+            };
+            break;
+        case 'changed':
+        case 'matches-port-kind':
+            throw new Error(`CompositionLink '${linkId}' uses legacy condition kind '${condition.kind}', which no longer has a canonical condition equivalent. Move this behavior into policy or endpoint modeling before loading the page.`);
+        default:
+            throw new Error(`CompositionLink '${linkId}' contains unsupported legacy condition kind.`);
+    }
+    if (!condition.negate || migrated === true) {
+        return condition.negate && migrated === true ? false : migrated;
+    }
+    return { '!': [migrated] };
+}
+function parseLegacyExpression(expression, linkId, sourceField) {
+    const trimmed = expression.trim();
+    const comparisonMatch = trimmed.match(/^(.*?)\s*(===|!==|==|!=|>=|<=|>|<)\s*(.*?)$/);
+    if (comparisonMatch) {
+        const [, leftRaw, operator, rightRaw] = comparisonMatch;
+        const left = parseLegacyOperand(leftRaw.trim(), linkId, sourceField);
+        const right = parseLegacyOperand(rightRaw.trim(), linkId, sourceField);
+        return { [operator]: [left, right] };
+    }
+    const negatedPath = trimmed.match(/^!\s*([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\[\d+\])*)$/);
+    if (negatedPath) {
+        return { '!': [buildVarReference(negatedPath[1])] };
+    }
+    if (looksLikePath(trimmed)) {
+        return { '!!': [buildVarReference(trimmed)] };
+    }
+    throw new Error(`CompositionLink '${linkId}' contains unsupported legacy expression in ${sourceField}: "${expression}". Only simple comparisons and root-qualified truthiness checks can be migrated automatically.`);
+}
+function parseLegacyOperand(raw, linkId, sourceField) {
+    if (raw === 'null') {
+        return null;
+    }
+    if (raw === 'true') {
+        return true;
+    }
+    if (raw === 'false') {
+        return false;
+    }
+    if (/^-?\d+(?:\.\d+)?$/.test(raw)) {
+        return Number(raw);
+    }
+    if ((raw.startsWith('"') && raw.endsWith('"')) || (raw.startsWith('\'') && raw.endsWith('\''))) {
+        return parseQuotedLiteral(raw, linkId, sourceField);
+    }
+    if (raw.startsWith('{') || raw.startsWith('[')) {
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            throw new Error(`CompositionLink '${linkId}' contains invalid JSON literal in ${sourceField}: "${raw}".`);
+        }
+    }
+    if (looksLikePath(raw)) {
+        return buildVarReference(raw);
+    }
+    throw new Error(`CompositionLink '${linkId}' contains unsupported legacy operand "${raw}" in ${sourceField}.`);
+}
+function parseQuotedLiteral(raw, linkId, sourceField) {
+    try {
+        if (raw.startsWith('\'')) {
+            return JSON.parse(`"${raw.slice(1, -1).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`);
+        }
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`CompositionLink '${linkId}' contains invalid quoted literal in ${sourceField}: "${raw}".`);
+    }
+}
+function buildVarReference(path) {
+    return { var: path };
+}
+function mergeLegacyPolicy(policy, legacyMeta) {
+    const merged = {
+        ...(policy || {}),
+        ...(legacyMeta?.debounceMs !== undefined ? { debounceMs: legacyMeta.debounceMs } : {}),
+        ...(legacyMeta?.distinct !== undefined ? { distinct: legacyMeta.distinct } : {}),
+        ...(legacyMeta?.distinctBy ? { distinctBy: legacyMeta.distinctBy } : {}),
+    };
+    return Object.keys(merged).length ? merged : undefined;
+}
+function mergeLegacyMetadata(metadata, markLegacySource) {
+    if (!metadata && !markLegacySource) {
+        return undefined;
+    }
+    const merged = {
+        ...(metadata || {}),
+        ...(!metadata?.source && markLegacySource ? { source: 'legacy-widget-connection' } : {}),
+    };
+    return Object.keys(merged).length ? merged : undefined;
+}
+function requireString(value, linkId, field) {
+    if (!value?.trim()) {
+        throw new Error(`CompositionLink '${linkId}' is missing legacy field '${field}' required for migration.`);
+    }
+    return value.trim();
+}
+function looksLikePath(value) {
+    return /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\[\d+\])*$/.test(value);
+}
+function toJsonLogicValue(value) {
+    if (value === null
+        || typeof value === 'string'
+        || typeof value === 'number'
+        || typeof value === 'boolean') {
+        return value;
+    }
+    if (Array.isArray(value) || (value && typeof value === 'object')) {
+        return clone(value);
+    }
+    return value == null ? null : String(value);
+}
+function clone(value) {
+    if (value == null || typeof value !== 'object') {
+        return value;
+    }
+    return JSON.parse(JSON.stringify(value));
+}
+
 const DYNAMIC_WIDGET_PAGE_I18N_NAMESPACE = 'dynamicWidgetPage';
 const DYNAMIC_WIDGET_PAGE_I18N_CONFIG = {
     namespaces: {
@@ -21671,7 +22880,38 @@ class WidgetPageCompositionFactory {
         };
     }
     readCanonicalLinks(page) {
-        return this.clone(page.composition?.links) || [];
+        const links = this.clone(page.composition?.links) || [];
+        this.assertCanonicalLinks(links);
+        return links;
+    }
+    assertCanonicalLinks(links) {
+        for (const link of links) {
+            const rawLink = link;
+            const id = String(rawLink['id'] ?? 'unknown-link');
+            const condition = rawLink['condition'];
+            const conditions = rawLink['conditions'];
+            const meta = rawLink['meta'];
+            if (typeof condition === 'string') {
+                throw new Error(`WidgetPageCompositionFactory no longer accepts string condition in composition.links for '${id}'. Use canonical Json Logic in condition.`);
+            }
+            if (conditions !== undefined) {
+                throw new Error(`WidgetPageCompositionFactory no longer accepts legacy conditions[] in composition.links for '${id}'. Use canonical Json Logic in condition.`);
+            }
+            if (meta && typeof meta === 'object' && !Array.isArray(meta) && 'filterExpr' in meta) {
+                throw new Error(`WidgetPageCompositionFactory no longer accepts meta.filterExpr in composition.links for '${id}'. Use canonical Json Logic in condition.`);
+            }
+            if (condition !== undefined
+                && condition !== null
+                && (typeof condition !== 'object' || Array.isArray(condition))) {
+                throw new Error(`WidgetPageCompositionFactory requires composition.links[].condition to be canonical Json Logic or null for '${id}'.`);
+            }
+            if (condition && !this.isJsonLogicLike(condition)) {
+                throw new Error(`WidgetPageCompositionFactory requires composition.links[].condition to be a canonical Json Logic expression for '${id}'.`);
+            }
+        }
+    }
+    isJsonLogicLike(condition) {
+        return Object.keys(condition).length > 0;
     }
     indexWidgets(widgets) {
         const widgetsByKey = {};
@@ -25335,4 +26575,4 @@ function provideHookWhitelist(allowed) {
  * Generated bundle index. Do not edit.
  */
 
-export { API_CONFIG_STORAGE_OPTIONS, API_URL, ASYNC_CONFIG_STORAGE, AllowedFileTypes, AnalyticsPresentationResolver, AnalyticsSchemaContractService, AnalyticsStatsRequestBuilderService, ApiConfigStorage, ApiEndpoint, BUILTIN_PAGE_LAYOUT_PRESETS, BUILTIN_PAGE_THEME_PRESETS, BUILTIN_SHELL_PRESETS, CONFIG_STORAGE, CONNECTION_STORAGE, ComponentKeyService, ComponentMetadataRegistry, CompositionRuntimeFacade, ConsoleLoggerSink, DEFAULT_FIELD_SELECTOR_CONTROL_TYPE_MAP, DEFAULT_TABLE_CONFIG, DYNAMIC_PAGE_AI_CAPABILITIES, DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK, DYNAMIC_PAGE_CONFIG_EDITOR, DYNAMIC_PAGE_SHELL_EDITOR, DefaultLoadingRenderer, DeferredAsyncConfigStorage, DynamicFormService, DynamicWidgetLoaderDirective, DynamicWidgetPageComponent, EDITORIAL_ALLOWED_CONTENT_FORMATS, EDITORIAL_COMPLIANCE_PRESETS, EDITORIAL_EXTERNAL_LINK_REL, EDITORIAL_FORM_TEMPLATE_CATALOG, EDITORIAL_HTML_ENABLED, EDITORIAL_MARKDOWN_IMAGES_ENABLED, EDITORIAL_SOLUTION_CATALOG, EDITORIAL_SOLUTION_PRESETS, EDITORIAL_THEME_PRESETS, EDITORIAL_WIDGET_CONVENTION_INPUTS, EDITORIAL_WIDGET_TAG, EMPLOYEE_ONBOARDING_EDITORIAL_SOLUTION, EMPLOYEE_ONBOARDING_EDITORIAL_TEMPLATE, EMPLOYEE_ONBOARDING_GUIDED_EDITORIAL_SOLUTION, EMPLOYEE_ONBOARDING_GUIDED_EDITORIAL_TEMPLATE, EVENT_REGISTRATION_EDITORIAL_SOLUTION, EVENT_REGISTRATION_EDITORIAL_TEMPLATE, EmptyStateCardComponent, ErrorMessageService, FIELD_METADATA_CAPABILITIES, FIELD_SELECTOR_REGISTRY_BASE, FIELD_SELECTOR_REGISTRY_DISABLE_DEFAULTS, FIELD_SELECTOR_REGISTRY_OVERRIDES, FORM_HOOKS, FORM_HOOKS_PRESETS, FORM_HOOKS_WHITELIST, FORM_HOOK_RESOLVERS, FieldControlType, FieldDataType, FieldSelectorRegistry, FormHooksRegistry, GLOBAL_ACTION_CATALOG$1 as GLOBAL_ACTION_CATALOG, GLOBAL_ACTION_HANDLERS, GLOBAL_ACTION_CATALOG as GLOBAL_ACTION_SPEC_CATALOG, GLOBAL_ACTION_UI_SCHEMAS, GLOBAL_ANALYTICS_SERVICE, GLOBAL_API_CLIENT, GLOBAL_CONFIG, GLOBAL_DIALOG_SERVICE, GLOBAL_ROUTE_GUARD_RESOLVER, GLOBAL_SURFACE_SERVICE, GLOBAL_TOAST_SERVICE, GenericCrudService, GlobalActionService, GlobalConfigService, INLINE_FILTER_ALIAS_TOKENS, INLINE_FILTER_CONTROL_TYPES, INLINE_FILTER_CONTROL_TYPE_SET, INLINE_FILTER_CONTROL_TYPE_VALUES, INLINE_FILTER_TOKEN_TO_BASE_CONTROL_TYPE, INLINE_FILTER_TOKEN_TO_CONTROL_TYPE, IconPickerService, IconPosition, IconSize, LOGGER_LEVEL_BY_ENV, LOGGER_LEVEL_PRIORITY, LoadingOrchestrator, LocalConnectionStorage, LocalStorageAsyncAdapter, LocalStorageCacheAdapter, LocalStorageConfigService, LoggerService, LoggerThrottleTracker, LoggerWarnOnceTracker, MemoryCacheAdapter, NumericFormat, OVERLAY_DECIDER_DEBUG, OVERLAY_DECISION_MATRIX, ObservabilityDashboardService, OverlayDeciderService, PRAXIS_CORPORATE_SENSITIVE_KEYS, PRAXIS_DEFAULT_OBSERVABILITY_ALERT_RULES, PRAXIS_DYNAMIC_PAGE_COMPONENT_METADATA, PRAXIS_FOOTER_LINKS_METADATA, PRAXIS_GLOBAL_ACTION_CATALOG, PRAXIS_GLOBAL_CONFIG_BOOTSTRAP_OPTIONS, PRAXIS_GLOBAL_CONFIG_BOOTSTRAP_READY, PRAXIS_GLOBAL_CONFIG_TENANT_RESOLVER, PRAXIS_HERO_BANNER_METADATA, PRAXIS_I18N_CONFIG, PRAXIS_I18N_TRANSLATOR, PRAXIS_LAYER_SCALE_DEFAULTS, PRAXIS_LAYER_SCALE_VARS, PRAXIS_LEGAL_NOTICE_METADATA, PRAXIS_LOADING_CTX, PRAXIS_LOADING_RENDERER, PRAXIS_LOGGER_CONFIG, PRAXIS_LOGGER_SINKS, PRAXIS_OBSERVABILITY_DASHBOARD_OPTIONS, PRAXIS_RICH_TEXT_BLOCK_METADATA, PRAXIS_TELEMETRY_TRANSPORT, PRAXIS_USER_CONTEXT_SUMMARY_METADATA, PRIVACY_CONSENT_EDITORIAL_SOLUTION, PRIVACY_CONSENT_EDITORIAL_TEMPLATE, PraxisCore, PraxisFooterLinksComponent, PraxisGlobalErrorHandler, PraxisHeroBannerComponent, PraxisI18nService, PraxisIconDirective, PraxisIconPickerComponent, PraxisLayerScaleStyleService, PraxisLegalNoticeComponent, PraxisLoadingInterceptor, PraxisRichTextBlockComponent, PraxisSurfaceHostComponent, PraxisUserContextSummaryComponent, RESOURCE_DISCOVERY_I18N_CONFIG, RESOURCE_DISCOVERY_I18N_NAMESPACE, RULE_PROPERTY_SCHEMA, RemoteConfigStorage, ResourceActionOpenAdapterService, ResourceDiscoveryService, ResourceQuickConnectComponent, ResourceSurfaceOpenAdapterService, SCHEMA_VIEWER_CONTEXT, SETTINGS_PANEL_BRIDGE, SETTINGS_PANEL_DATA, STEPPER_CONFIG_EDITOR, SURFACE_DRAWER_BRIDGE, SURFACE_OPEN_I18N_CONFIG, SURFACE_OPEN_I18N_NAMESPACE, SURFACE_OPEN_PRESETS, SchemaMetadataClient, SchemaNormalizerService, SchemaViewerComponent, SurfaceBindingRuntimeService, SurfaceOpenActionEditorComponent, TABLE_CONFIG_EDITOR, TableConfigService, TelemetryLoggerSink, TelemetryService, ValidationPattern, WidgetPageStateRuntimeService, WidgetShellComponent, applyLocalCustomizations$2 as applyLocalCustomizations, applyLocalCustomizations$1 as applyLocalFormCustomizations, buildAngularValidators, buildApiUrl, buildBaseColumnFromDef, buildBaseFormField, buildFormConfigFromEditorialTemplate, buildHeaders, buildPageKey, buildPraxisLayerScaleCss, buildSchemaId, buildValidatorsFromValidatorOptions, cancelIfCpfInvalidHook, clampRange, cloneTableConfig, cnpjAlphaValidator, collapseWhitespace, composeHeadersWithVersion, conditionalAsyncValidator, convertFormLayoutToConfig, createCorporateLoggerConfig, createCorporateObservabilityOptions, createCpfCnpjValidator, createDefaultFormConfig, createDefaultTableConfig, createEmptyFormConfig, createPersistedPage, customAsyncValidatorFn, customValidatorFn, debounceAsyncValidator, deepMerge, ensureIds, ensureNoConflictsHookFactory, ensurePageIds, extractNormalizedError, fetchWithETag, fileTypeValidator, fillUndefined, generateId, getDefaultFormHints, getEditorialCompliancePresetById, getEditorialFormTemplateById, getEditorialFormTemplateCatalog, getEditorialSolutionById, getEditorialSolutionCatalog, getEditorialSolutionPresetById, getEditorialThemePresetById, getEssentialConfig, getFieldMetadataCapabilities, getGlobalActionCatalog, getGlobalActionUiSchema, getReferencedFieldMetadata, getTextTransformer, interpolatePraxisTranslation, isAllowedEditorialContentFormat, isAllowedEditorialHref, isCssTextTransform, isEditorialComponentMeta, isInlineFilterControlType, isRangeValidForFilter, isTableConfigV2, isValidFormConfig, isValidTableConfig, legacyCnpjValidator, legacyCpfValidator, logOnErrorHook, mapFieldDefinitionToMetadata, mapFieldDefinitionsToMetadata, matchFieldValidator, maxFileSizeValidator, mergeFieldMetadata, mergePraxisI18nConfigs, mergeTableConfigs, migrateFormLayoutRule, minWordsValidator, normalizeControlTypeKey, normalizeControlTypeToken, normalizeEditorialLink, normalizeEnd, normalizeFieldConstraints, normalizeFormConfig, normalizeFormMetadata, normalizePath, normalizePraxisDataQueryContext, normalizeResourceAvailabilityReasonCode, normalizeStart, normalizeUnknownError, notifySuccessHook, parseJsonResponseOrEmpty, praxisLoadingInterceptorFn, prefillFromContextHook, provideDefaultFormHooks, provideFieldSelectorRegistryBase, provideFieldSelectorRegistryOverride, provideFieldSelectorRegistryRuntime, provideFormHookPresets, provideFormHooks, provideGlobalActionCatalog, provideGlobalActionHandler, provideGlobalConfig, provideGlobalConfigReady, provideGlobalConfigSeed, provideGlobalConfigTenant, provideHookResolvers, provideHookWhitelist, provideOverlayDecisionMatrix, providePraxisAnalyticsGlobalActions, providePraxisDynamicPageMetadata, providePraxisFooterLinksMetadata, providePraxisGlobalActionCatalog, providePraxisGlobalActions, providePraxisGlobalConfigBootstrap, providePraxisHeroBannerMetadata, providePraxisHttpLoading, providePraxisI18n, providePraxisI18nConfig, providePraxisI18nTranslator, providePraxisLegalNoticeMetadata, providePraxisLoadingDefaults, providePraxisLogging, providePraxisRichTextBlockMetadata, providePraxisToastGlobalActions, providePraxisUserContextSummaryMetadata, provideRemoteGlobalConfig, reconcileFilterConfig, reconcileFormConfig, reconcileTableConfig, removeDiacritics, reportTelemetryHookFactory, requiredCheckedValidator, resolveBuiltinPresets, resolveControlTypeAlias, resolveDefaultValuePresentationFormat, resolveHidden, resolveInlineFilterControlType, resolveInlineFilterControlTypeToBaseControlType, resolveLoggerConfig, resolveObservabilityOptions, resolveOffset, resolveOrder, resolvePraxisFilterCriteria, resolveResourceAvailabilityReasonKey, resolveSpan, resolveValuePresentation, resolveValuePresentationLocale, slugify, stripMasksHook, supportsImplicitValuePresentation, syncWithServerMetadata, toCamel, toCapitalize, toKebab, toPascal, toSentenceCase, toSnake, toTitleCase, translateResourceAvailabilityReason, translateResourceDiscoveryText, translateUnavailableWorkflowMessage, trim, uniqueAsyncValidator, urlValidator, withMessage, withPraxisHttpLoading };
+export { API_CONFIG_STORAGE_OPTIONS, API_URL, ASYNC_CONFIG_STORAGE, AllowedFileTypes, AnalyticsPresentationResolver, AnalyticsSchemaContractService, AnalyticsStatsRequestBuilderService, ApiConfigStorage, ApiEndpoint, BUILTIN_PAGE_LAYOUT_PRESETS, BUILTIN_PAGE_THEME_PRESETS, BUILTIN_SHELL_PRESETS, CONFIG_STORAGE, CONNECTION_STORAGE, ComponentKeyService, ComponentMetadataRegistry, CompositionRuntimeFacade, ConsoleLoggerSink, DEFAULT_FIELD_SELECTOR_CONTROL_TYPE_MAP, DEFAULT_JSON_LOGIC_OPERATORS, DEFAULT_TABLE_CONFIG, DYNAMIC_PAGE_AI_CAPABILITIES, DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK, DYNAMIC_PAGE_CONFIG_EDITOR, DYNAMIC_PAGE_SHELL_EDITOR, DefaultLoadingRenderer, DeferredAsyncConfigStorage, DynamicFormService, DynamicWidgetLoaderDirective, DynamicWidgetPageComponent, EDITORIAL_ALLOWED_CONTENT_FORMATS, EDITORIAL_COMPLIANCE_PRESETS, EDITORIAL_EXTERNAL_LINK_REL, EDITORIAL_FORM_TEMPLATE_CATALOG, EDITORIAL_HTML_ENABLED, EDITORIAL_MARKDOWN_IMAGES_ENABLED, EDITORIAL_SOLUTION_CATALOG, EDITORIAL_SOLUTION_PRESETS, EDITORIAL_THEME_PRESETS, EDITORIAL_WIDGET_CONVENTION_INPUTS, EDITORIAL_WIDGET_TAG, EMPLOYEE_ONBOARDING_EDITORIAL_SOLUTION, EMPLOYEE_ONBOARDING_EDITORIAL_TEMPLATE, EMPLOYEE_ONBOARDING_GUIDED_EDITORIAL_SOLUTION, EMPLOYEE_ONBOARDING_GUIDED_EDITORIAL_TEMPLATE, EVENT_REGISTRATION_EDITORIAL_SOLUTION, EVENT_REGISTRATION_EDITORIAL_TEMPLATE, EmptyStateCardComponent, ErrorMessageService, FIELD_METADATA_CAPABILITIES, FIELD_SELECTOR_REGISTRY_BASE, FIELD_SELECTOR_REGISTRY_DISABLE_DEFAULTS, FIELD_SELECTOR_REGISTRY_OVERRIDES, FORM_HOOKS, FORM_HOOKS_PRESETS, FORM_HOOKS_WHITELIST, FORM_HOOK_RESOLVERS, FieldControlType, FieldDataType, FieldSelectorRegistry, FormHooksRegistry, GLOBAL_ACTION_CATALOG$1 as GLOBAL_ACTION_CATALOG, GLOBAL_ACTION_HANDLERS, GLOBAL_ACTION_CATALOG as GLOBAL_ACTION_SPEC_CATALOG, GLOBAL_ACTION_UI_SCHEMAS, GLOBAL_ANALYTICS_SERVICE, GLOBAL_API_CLIENT, GLOBAL_CONFIG, GLOBAL_DIALOG_SERVICE, GLOBAL_ROUTE_GUARD_RESOLVER, GLOBAL_SURFACE_SERVICE, GLOBAL_TOAST_SERVICE, GenericCrudService, GlobalActionService, GlobalConfigService, INLINE_FILTER_ALIAS_TOKENS, INLINE_FILTER_CONTROL_TYPES, INLINE_FILTER_CONTROL_TYPE_SET, INLINE_FILTER_CONTROL_TYPE_VALUES, INLINE_FILTER_TOKEN_TO_BASE_CONTROL_TYPE, INLINE_FILTER_TOKEN_TO_CONTROL_TYPE, IconPickerService, IconPosition, IconSize, LOGGER_LEVEL_BY_ENV, LOGGER_LEVEL_PRIORITY, LoadingOrchestrator, LocalConnectionStorage, LocalStorageAsyncAdapter, LocalStorageCacheAdapter, LocalStorageConfigService, LoggerService, LoggerThrottleTracker, LoggerWarnOnceTracker, MemoryCacheAdapter, NumericFormat, OVERLAY_DECIDER_DEBUG, OVERLAY_DECISION_MATRIX, ObservabilityDashboardService, OverlayDeciderService, PRAXIS_CORPORATE_SENSITIVE_KEYS, PRAXIS_DEFAULT_OBSERVABILITY_ALERT_RULES, PRAXIS_DYNAMIC_PAGE_COMPONENT_METADATA, PRAXIS_FOOTER_LINKS_METADATA, PRAXIS_GLOBAL_ACTION_CATALOG, PRAXIS_GLOBAL_CONFIG_BOOTSTRAP_OPTIONS, PRAXIS_GLOBAL_CONFIG_BOOTSTRAP_READY, PRAXIS_GLOBAL_CONFIG_TENANT_RESOLVER, PRAXIS_HERO_BANNER_METADATA, PRAXIS_I18N_CONFIG, PRAXIS_I18N_TRANSLATOR, PRAXIS_JSON_LOGIC_OPERATORS, PRAXIS_LAYER_SCALE_DEFAULTS, PRAXIS_LAYER_SCALE_VARS, PRAXIS_LEGAL_NOTICE_METADATA, PRAXIS_LOADING_CTX, PRAXIS_LOADING_RENDERER, PRAXIS_LOGGER_CONFIG, PRAXIS_LOGGER_SINKS, PRAXIS_OBSERVABILITY_DASHBOARD_OPTIONS, PRAXIS_RICH_TEXT_BLOCK_METADATA, PRAXIS_TELEMETRY_TRANSPORT, PRAXIS_USER_CONTEXT_SUMMARY_METADATA, PRIVACY_CONSENT_EDITORIAL_SOLUTION, PRIVACY_CONSENT_EDITORIAL_TEMPLATE, PraxisCore, PraxisFooterLinksComponent, PraxisGlobalErrorHandler, PraxisHeroBannerComponent, PraxisI18nService, PraxisIconDirective, PraxisIconPickerComponent, PraxisJsonLogicError, PraxisJsonLogicService, PraxisLayerScaleStyleService, PraxisLegalNoticeComponent, PraxisLoadingInterceptor, PraxisRichTextBlockComponent, PraxisSurfaceHostComponent, PraxisUserContextSummaryComponent, RESOURCE_DISCOVERY_I18N_CONFIG, RESOURCE_DISCOVERY_I18N_NAMESPACE, RULE_PROPERTY_SCHEMA, RemoteConfigStorage, ResourceActionOpenAdapterService, ResourceDiscoveryService, ResourceQuickConnectComponent, ResourceSurfaceOpenAdapterService, SCHEMA_VIEWER_CONTEXT, SETTINGS_PANEL_BRIDGE, SETTINGS_PANEL_DATA, STEPPER_CONFIG_EDITOR, SURFACE_DRAWER_BRIDGE, SURFACE_OPEN_I18N_CONFIG, SURFACE_OPEN_I18N_NAMESPACE, SURFACE_OPEN_PRESETS, SchemaMetadataClient, SchemaNormalizerService, SchemaViewerComponent, SurfaceBindingRuntimeService, SurfaceOpenActionEditorComponent, TABLE_CONFIG_EDITOR, TableConfigService, TelemetryLoggerSink, TelemetryService, ValidationPattern, WidgetPageStateRuntimeService, WidgetShellComponent, applyLocalCustomizations$2 as applyLocalCustomizations, applyLocalCustomizations$1 as applyLocalFormCustomizations, buildAngularValidators, buildApiUrl, buildBaseColumnFromDef, buildBaseFormField, buildFormConfigFromEditorialTemplate, buildHeaders, buildPageKey, buildPraxisLayerScaleCss, buildSchemaId, buildValidatorsFromValidatorOptions, cancelIfCpfInvalidHook, clampRange, cloneTableConfig, cnpjAlphaValidator, collapseWhitespace, composeHeadersWithVersion, conditionalAsyncValidator, convertFormLayoutToConfig, createCorporateLoggerConfig, createCorporateObservabilityOptions, createCpfCnpjValidator, createDefaultFormConfig, createDefaultTableConfig, createEmptyFormConfig, createPersistedPage, customAsyncValidatorFn, customValidatorFn, debounceAsyncValidator, deepMerge, ensureIds, ensureNoConflictsHookFactory, ensurePageIds, extractNormalizedError, fetchWithETag, fileTypeValidator, fillUndefined, generateId, getDefaultFormHints, getEditorialCompliancePresetById, getEditorialFormTemplateById, getEditorialFormTemplateCatalog, getEditorialSolutionById, getEditorialSolutionCatalog, getEditorialSolutionPresetById, getEditorialThemePresetById, getEssentialConfig, getFieldMetadataCapabilities, getGlobalActionCatalog, getGlobalActionUiSchema, getReferencedFieldMetadata, getTextTransformer, interpolatePraxisTranslation, isAllowedEditorialContentFormat, isAllowedEditorialHref, isCssTextTransform, isEditorialComponentMeta, isInlineFilterControlType, isRangeValidForFilter, isTableConfigV2, isValidFormConfig, isValidTableConfig, legacyCnpjValidator, legacyCpfValidator, logOnErrorHook, mapFieldDefinitionToMetadata, mapFieldDefinitionsToMetadata, matchFieldValidator, maxFileSizeValidator, mergeFieldMetadata, mergePraxisI18nConfigs, mergeTableConfigs, migrateFormLayoutRule, migrateLegacyCompositionLink, migrateLegacyCompositionLinks, minWordsValidator, normalizeControlTypeKey, normalizeControlTypeToken, normalizeEditorialLink, normalizeEnd, normalizeFieldConstraints, normalizeFormConfig, normalizeFormMetadata, normalizePath, normalizePraxisDataQueryContext, normalizeResourceAvailabilityReasonCode, normalizeStart, normalizeUnknownError, notifySuccessHook, parseJsonResponseOrEmpty, praxisLoadingInterceptorFn, prefillFromContextHook, provideDefaultFormHooks, provideFieldSelectorRegistryBase, provideFieldSelectorRegistryOverride, provideFieldSelectorRegistryRuntime, provideFormHookPresets, provideFormHooks, provideGlobalActionCatalog, provideGlobalActionHandler, provideGlobalConfig, provideGlobalConfigReady, provideGlobalConfigSeed, provideGlobalConfigTenant, provideHookResolvers, provideHookWhitelist, provideOverlayDecisionMatrix, providePraxisAnalyticsGlobalActions, providePraxisDynamicPageMetadata, providePraxisFooterLinksMetadata, providePraxisGlobalActionCatalog, providePraxisGlobalActions, providePraxisGlobalConfigBootstrap, providePraxisHeroBannerMetadata, providePraxisHttpLoading, providePraxisI18n, providePraxisI18nConfig, providePraxisI18nTranslator, providePraxisJsonLogicOperator, providePraxisLegalNoticeMetadata, providePraxisLoadingDefaults, providePraxisLogging, providePraxisRichTextBlockMetadata, providePraxisToastGlobalActions, providePraxisUserContextSummaryMetadata, provideRemoteGlobalConfig, reconcileFilterConfig, reconcileFormConfig, reconcileTableConfig, removeDiacritics, reportTelemetryHookFactory, requiredCheckedValidator, resolveBuiltinPresets, resolveControlTypeAlias, resolveDefaultValuePresentationFormat, resolveHidden, resolveInlineFilterControlType, resolveInlineFilterControlTypeToBaseControlType, resolveLoggerConfig, resolveObservabilityOptions, resolveOffset, resolveOrder, resolvePraxisFilterCriteria, resolveResourceAvailabilityReasonKey, resolveSpan, resolveValuePresentation, resolveValuePresentationLocale, slugify, stripMasksHook, supportsImplicitValuePresentation, syncWithServerMetadata, toCamel, toCapitalize, toKebab, toPascal, toSentenceCase, toSnake, toTitleCase, translateResourceAvailabilityReason, translateResourceDiscoveryText, translateUnavailableWorkflowMessage, trim, uniqueAsyncValidator, urlValidator, withMessage, withPraxisHttpLoading };