@hyperfixi/core 2.0.0

package/dist/dom/attribute-processor.d.ts

@@ -0,0 +1,40 @@
+declare global {
+    interface Window {
+        __hyperfixi_behaviors_ready?: Promise<void>;
+    }
+}
+export interface AttributeProcessorOptions {
+    attributeName?: string;
+    autoScan?: boolean;
+    processOnlyNewElements?: boolean;
+    lazyParsing?: boolean;
+    chunkedProcessing?: boolean;
+    chunkSize?: number;
+}
+export declare class AttributeProcessor {
+    private processedElements;
+    private options;
+    private observer;
+    private processedCount;
+    private readyEventDispatched;
+    private initialized;
+    private lazyElements;
+    constructor(options?: AttributeProcessorOptions);
+    init(): Promise<void>;
+    scanAndProcessAll(): Promise<void>;
+    private processHyperscriptTag;
+    private processHyperscriptTagForElements;
+    private processHyperscriptTagGlobal;
+    processElement(element: HTMLElement): void;
+    processElementAsync(element: HTMLElement): Promise<void>;
+    private processElementsChunked;
+    private processElementLazy;
+    private hasMultipleHandlers;
+    private dispatchLoadEvent;
+    private dispatchReadyEvent;
+    private setupMutationObserver;
+    destroy(): void;
+    reset(): void;
+}
+export declare const defaultAttributeProcessor: AttributeProcessor;
+//# sourceMappingURL=attribute-processor.d.ts.map

package/dist/dom/minimal-attribute-processor.d.ts

@@ -0,0 +1,20 @@
+import type { ExecutionContext } from '../types/base-types';
+export interface MinimalRuntime {
+    execute(code: string, context?: ExecutionContext): Promise<any>;
+    parse(code: string): any;
+}
+export declare class MinimalAttributeProcessor {
+    private runtime;
+    private observer;
+    private initialized;
+    constructor(runtime: MinimalRuntime);
+    init(): void;
+    destroy(): void;
+    reset(): void;
+    scanAndProcessAll(): void;
+    private scanDocument;
+    scanElement(root: Element): void;
+    processElement(element: Element): void;
+}
+export declare function createMinimalAttributeProcessor(runtime: MinimalRuntime): MinimalAttributeProcessor;
+//# sourceMappingURL=minimal-attribute-processor.d.ts.map

package/dist/experimental/binary-tree/accessor.d.ts

@@ -0,0 +1,10 @@
+export type AccessPath = (string | number)[];
+export declare function get(buffer: ArrayBuffer, path: AccessPath): unknown;
+export declare function getString(buffer: ArrayBuffer, path: AccessPath): string | null;
+export declare function getNumber(buffer: ArrayBuffer, path: AccessPath): number | null;
+export declare function getBoolean(buffer: ArrayBuffer, path: AccessPath): boolean | null;
+export declare function has(buffer: ArrayBuffer, path: AccessPath): boolean;
+export declare function getType(buffer: ArrayBuffer, path: AccessPath): 'null' | 'undefined' | 'boolean' | 'number' | 'string' | 'array' | 'object' | null;
+export declare function getLength(buffer: ArrayBuffer, path: AccessPath): number | null;
+export declare function getKeys(buffer: ArrayBuffer, path: AccessPath): string[] | null;
+//# sourceMappingURL=accessor.d.ts.map

package/dist/experimental/binary-tree/ast-serializer.d.ts

@@ -0,0 +1,26 @@
+import type { ASTNode } from '../../types/base-types';
+export declare class BinaryAST {
+    private buffer;
+    constructor(ast: ASTNode);
+    getNodeType(): string;
+    getName(): string | null;
+    isBlocking(): boolean;
+    getLine(): number | null;
+    getColumn(): number | null;
+    getRaw(): string | null;
+    get(path: string[]): unknown;
+    getString(path: string[]): string | null;
+    getNumber(path: string[]): number | null;
+    getBoolean(path: string[]): boolean | null;
+    has(path: string[]): boolean;
+    getType(path: string[]): string | null;
+    toAST(): ASTNode;
+    getBuffer(): ArrayBuffer;
+    getByteLength(): number;
+    static fromBuffer(buffer: ArrayBuffer): BinaryAST;
+    clone(): BinaryAST;
+}
+export declare function isCommandNode(buffer: ArrayBuffer): boolean;
+export declare function isExpressionNode(buffer: ArrayBuffer): boolean;
+export declare function getCommandName(buffer: ArrayBuffer): string | null;
+//# sourceMappingURL=ast-serializer.d.ts.map

package/dist/experimental/binary-tree/benchmark.d.ts

@@ -0,0 +1,24 @@
+export interface BenchmarkResult {
+    name: string;
+    iterations: number;
+    jsonTime: number;
+    binaryTime: number;
+    speedup: number;
+    jsonSize: number;
+    binarySize: number;
+    sizeRatio: number;
+}
+export interface BenchmarkSuite {
+    name: string;
+    results: BenchmarkResult[];
+    summary: {
+        avgSpeedup: number;
+        avgSizeRatio: number;
+        totalJsonTime: number;
+        totalBinaryTime: number;
+    };
+}
+export declare function runBenchmarks(iterations?: number): BenchmarkSuite;
+export declare function formatBenchmarkResults(suite: BenchmarkSuite): string;
+export declare function runAndPrintBenchmarks(iterations?: number): void;
+//# sourceMappingURL=benchmark.d.ts.map

package/dist/experimental/binary-tree/buffer-context.d.ts

@@ -0,0 +1,27 @@
+import { WriteCursor, ReadCursor, BinaryTreeOptions } from './types';
+export declare function createWriteCursor(options?: BinaryTreeOptions): WriteCursor;
+export declare function ensureCapacity(cursor: WriteCursor, bytesNeeded: number, options?: BinaryTreeOptions): WriteCursor;
+export declare function writeUint8(cursor: WriteCursor, value: number): WriteCursor;
+export declare function writeUint32(cursor: WriteCursor, value: number): WriteCursor;
+export declare function writeFloat64(cursor: WriteCursor, value: number): WriteCursor;
+export declare function writeString(cursor: WriteCursor, value: string): {
+    cursor: WriteCursor;
+    byteLength: number;
+};
+export declare function writeBytes(cursor: WriteCursor, bytes: Uint8Array): WriteCursor;
+export declare function writeHeader(cursor: WriteCursor, rootOffset: number): WriteCursor;
+export declare function finalizeBuffer(cursor: WriteCursor): ArrayBuffer;
+export declare function createReadCursor(buffer: ArrayBuffer, offset?: number): ReadCursor;
+export declare function readUint8(cursor: ReadCursor, offset?: number): number;
+export declare function readUint32(cursor: ReadCursor, offset?: number): number;
+export declare function readFloat64(cursor: ReadCursor, offset?: number): number;
+export declare function readString(cursor: ReadCursor, offset: number, length: number): string;
+export declare function readHeader(cursor: ReadCursor): {
+    magic: number;
+    version: number;
+    rootOffset: number;
+    totalSize: number;
+} | null;
+export declare function compareStrings(a: string, b: string): number;
+export declare function binarySearchKey(cursor: ReadCursor, entriesOffset: number, keyCount: number, targetKey: string): number;
+//# sourceMappingURL=buffer-context.d.ts.map

package/dist/experimental/binary-tree/deserializer.d.ts

@@ -0,0 +1,17 @@
+export declare function deserialize(buffer: ArrayBuffer): unknown;
+export declare function validate(buffer: ArrayBuffer): {
+    valid: boolean;
+    error?: string;
+};
+export declare function inspect(buffer: ArrayBuffer): {
+    valid: boolean;
+    header?: {
+        magic: number;
+        version: number;
+        rootOffset: number;
+        totalSize: number;
+    };
+    rootType?: string;
+    error?: string;
+};
+//# sourceMappingURL=deserializer.d.ts.map

package/dist/experimental/binary-tree/index.d.ts

@@ -0,0 +1,22 @@
+export { BinaryTreeOptions, SerializableValue, SerializablePrimitive, ValueType, MAGIC_NUMBER, FORMAT_VERSION, HEADER_SIZE, } from './types';
+import { serialize, estimateSize } from './serializer';
+import { deserialize, validate, inspect } from './deserializer';
+import { get, getString, getNumber, getBoolean, has, getType, getLength, getKeys, type AccessPath } from './accessor';
+export declare class BinaryTree {
+    static serialize: typeof serialize;
+    static estimateSize: typeof estimateSize;
+    static deserialize: typeof deserialize;
+    static validate: typeof validate;
+    static inspect: typeof inspect;
+    static get: typeof get;
+    static getString: typeof getString;
+    static getNumber: typeof getNumber;
+    static getBoolean: typeof getBoolean;
+    static has: typeof has;
+    static getType: typeof getType;
+    static getLength: typeof getLength;
+    static getKeys: typeof getKeys;
+}
+export { serialize, estimateSize, deserialize, validate, inspect, get, getString, getNumber, getBoolean, has, getType, getLength, getKeys, };
+export type { AccessPath };
+//# sourceMappingURL=index.d.ts.map

package/dist/experimental/binary-tree/serializer.d.ts

@@ -0,0 +1,4 @@
+import { BinaryTreeOptions } from './types';
+export declare function serialize(value: unknown, options?: BinaryTreeOptions): ArrayBuffer;
+export declare function estimateSize(value: unknown): number;
+//# sourceMappingURL=serializer.d.ts.map

package/dist/experimental/binary-tree/types.d.ts

@@ -0,0 +1,54 @@
+export declare const MAGIC_NUMBER = 1279874099;
+export declare const FORMAT_VERSION = 1;
+export declare const HEADER_SIZE = 16;
+export declare const enum ValueType {
+    Null = 0,
+    Boolean = 1,
+    Number = 2,
+    String = 3,
+    Array = 4,
+    Object = 5,
+    Undefined = 6
+}
+export interface HeaderLayout {
+    magic: number;
+    version: number;
+    rootOffset: number;
+    totalSize: number;
+}
+export interface ObjectEntry {
+    keyOffset: number;
+    keyLength: number;
+    valueOffset: number;
+}
+export interface BinaryTreeOptions {
+    initialSize?: number;
+    growthFactor?: number;
+}
+export interface SerializeResult {
+    buffer: ArrayBuffer;
+    bytesUsed: number;
+}
+export type SerializablePrimitive = null | undefined | boolean | number | string;
+export type SerializableValue = SerializablePrimitive | SerializableValue[] | {
+    [key: string]: SerializableValue;
+};
+export interface WriteCursor {
+    buffer: ArrayBuffer;
+    view: DataView;
+    uint8: Uint8Array;
+    offset: number;
+}
+export interface ReadCursor {
+    view: DataView;
+    uint8: Uint8Array;
+    offset: number;
+}
+export declare const TYPE_TAG_SIZE = 1;
+export declare const LENGTH_SIZE = 4;
+export declare const OFFSET_SIZE = 4;
+export declare const OBJECT_ENTRY_SIZE = 12;
+export declare const ARRAY_ENTRY_SIZE = 4;
+export declare const NUMBER_SIZE = 8;
+export declare const BOOLEAN_SIZE = 1;
+//# sourceMappingURL=types.d.ts.map

package/dist/expressions/base-expression.d.ts

@@ -0,0 +1,27 @@
+import type { RuntimeValidator } from '../validation/lightweight-validators';
+import type { TypedExpressionContext, EvaluationResult, ValidationResult, ValidationError, ExpressionMetadata, EvaluationType, ExpressionCategory } from '../types/base-types';
+export declare abstract class BaseExpressionImpl<TInput = unknown, TOutput = unknown> {
+    abstract readonly name: string;
+    abstract readonly category: ExpressionCategory;
+    abstract readonly syntax: string;
+    abstract readonly description: string;
+    abstract readonly inputSchema: RuntimeValidator<TInput>;
+    abstract readonly outputType: EvaluationType;
+    abstract readonly metadata: ExpressionMetadata;
+    protected trackPerformance(context: TypedExpressionContext, input: unknown, result: EvaluationResult<TOutput>, startTime: number): void;
+    protected trackSimple(context: TypedExpressionContext, startTime: number, success: boolean, output?: unknown): void;
+    protected toBoolean(value: unknown): boolean;
+    protected success<T>(value: T, type: EvaluationResult<T>['type']): EvaluationResult<T>;
+    protected failure<T>(name: string, type: ValidationError['type'], message: string, code: string, suggestions?: readonly string[] | string[]): EvaluationResult<T>;
+    protected validationSuccess(): ValidationResult;
+    protected validationFailure(type: ValidationError['type'], message: string, suggestions?: string[]): ValidationResult;
+    protected isElement(value: unknown): value is Element;
+    protected inferType(value: unknown): EvaluationResult<unknown>['type'];
+    protected inferEvaluationType(value: unknown): EvaluationType;
+    protected normalizeCollection(collection: unknown): unknown[];
+    protected toNumber(value: unknown): number | null;
+    abstract evaluate(context: TypedExpressionContext, input: TInput): Promise<EvaluationResult<TOutput>>;
+    abstract validate(input: unknown): ValidationResult;
+}
+export declare function isBaseExpression(expr: unknown): expr is BaseExpressionImpl;
+//# sourceMappingURL=base-expression.d.ts.map

package/dist/expressions/bundles/common-expressions.d.ts

@@ -0,0 +1,9 @@
+import { ConfigurableExpressionEvaluator } from '../../core/configurable-expression-evaluator';
+import { referencesExpressions } from '../references/index';
+import { logicalExpressions } from '../logical/index';
+import { specialExpressions } from '../special/index';
+import { conversionExpressions } from '../conversion/index';
+import { positionalExpressions } from '../positional/index';
+export declare function createCommonExpressionEvaluator(): ConfigurableExpressionEvaluator;
+export { referencesExpressions, logicalExpressions, specialExpressions, conversionExpressions, positionalExpressions, };
+//# sourceMappingURL=common-expressions.d.ts.map

package/dist/expressions/bundles/core-expressions.d.ts

@@ -0,0 +1,7 @@
+import { ConfigurableExpressionEvaluator } from '../../core/configurable-expression-evaluator';
+import { referencesExpressions } from '../references/index';
+import { logicalExpressions } from '../logical/index';
+import { specialExpressions } from '../special/index';
+export declare function createCoreExpressionEvaluator(): ConfigurableExpressionEvaluator;
+export { referencesExpressions, logicalExpressions, specialExpressions };
+//# sourceMappingURL=core-expressions.d.ts.map

package/dist/expressions/bundles/full-expressions.d.ts

@@ -0,0 +1,10 @@
+import { ConfigurableExpressionEvaluator } from '../../core/configurable-expression-evaluator';
+import { referencesExpressions } from '../references/index';
+import { logicalExpressions } from '../logical/index';
+import { specialExpressions } from '../special/index';
+import { conversionExpressions } from '../conversion/index';
+import { positionalExpressions } from '../positional/index';
+import { propertiesExpressions } from '../properties/index';
+export declare function createFullExpressionEvaluator(): ConfigurableExpressionEvaluator;
+export { referencesExpressions, logicalExpressions, specialExpressions, conversionExpressions, positionalExpressions, propertiesExpressions, };
+//# sourceMappingURL=full-expressions.d.ts.map

package/dist/expressions/bundles/index.d.ts

@@ -0,0 +1,7 @@
+export { createCoreExpressionEvaluator } from './core-expressions';
+export { createCommonExpressionEvaluator } from './common-expressions';
+export { createFullExpressionEvaluator } from './full-expressions';
+export { referencesExpressions, logicalExpressions, specialExpressions } from './core-expressions';
+export { conversionExpressions, positionalExpressions } from './common-expressions';
+export { propertiesExpressions } from './full-expressions';
+//# sourceMappingURL=index.d.ts.map

package/dist/expressions/comparison/index.d.ts

@@ -0,0 +1,80 @@
+import type { ValidationResult, TypedExecutionContext as TypedExpressionContext, EvaluationType, ExpressionMetadata, TypedResult, ExpressionCategory } from '../../types/index';
+interface BaseTypedExpression<T> {
+    readonly name: string;
+    readonly category: string;
+    readonly syntax: string;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: unknown): Promise<TypedResult<T>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class GreaterThanExpression implements BaseTypedExpression<boolean> {
+    readonly name = "greaterThan";
+    readonly category: ExpressionCategory;
+    readonly syntax = "left > right";
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(_context: TypedExpressionContext, input: unknown): Promise<TypedResult<boolean>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class LessThanExpression implements BaseTypedExpression<boolean> {
+    readonly name = "lessThan";
+    readonly category: ExpressionCategory;
+    readonly syntax = "left < right";
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(_context: TypedExpressionContext, input: unknown): Promise<TypedResult<boolean>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class GreaterThanOrEqualExpression implements BaseTypedExpression<boolean> {
+    readonly name = "greaterThanOrEqual";
+    readonly category: ExpressionCategory;
+    readonly syntax = "left >= right";
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(_context: TypedExpressionContext, input: unknown): Promise<TypedResult<boolean>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class LessThanOrEqualExpression implements BaseTypedExpression<boolean> {
+    readonly name = "lessThanOrEqual";
+    readonly category: ExpressionCategory;
+    readonly syntax = "left <= right";
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(_context: TypedExpressionContext, input: unknown): Promise<TypedResult<boolean>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class EqualityExpression implements BaseTypedExpression<boolean> {
+    readonly name = "equals";
+    readonly category: ExpressionCategory;
+    readonly syntax = "left == right";
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(_context: TypedExpressionContext, input: unknown): Promise<TypedResult<boolean>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class InequalityExpression implements BaseTypedExpression<boolean> {
+    readonly name = "notEquals";
+    readonly category: ExpressionCategory;
+    readonly syntax = "left != right";
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(_context: TypedExpressionContext, input: unknown): Promise<TypedResult<boolean>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare function createGreaterThanExpression(): GreaterThanExpression;
+export declare function createLessThanExpression(): LessThanExpression;
+export declare function createGreaterThanOrEqualExpression(): GreaterThanOrEqualExpression;
+export declare function createLessThanOrEqualExpression(): LessThanOrEqualExpression;
+export declare function createEqualityExpression(): EqualityExpression;
+export declare function createInequalityExpression(): InequalityExpression;
+export declare const comparisonExpressions: {
+    readonly greaterThan: GreaterThanExpression;
+    readonly lessThan: LessThanExpression;
+    readonly greaterThanOrEqual: GreaterThanOrEqualExpression;
+    readonly lessThanOrEqual: LessThanOrEqualExpression;
+    readonly equals: EqualityExpression;
+    readonly notEquals: InequalityExpression;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/expressions/comparison/utils.d.ts

@@ -0,0 +1,2 @@
+export { isNumber, isString, isBoolean, toNumber } from '../type-helpers';
+//# sourceMappingURL=utils.d.ts.map

package/dist/expressions/conversion/impl/bridge.d.ts

@@ -0,0 +1,117 @@
+import type { ExecutionContext, TypedExpressionContext, ExpressionEvaluationOptions } from '../../../types/base-types';
+export declare function createTypedExpressionContext(context: ExecutionContext, options?: ExpressionEvaluationOptions): TypedExpressionContext;
+export declare function updateExecutionContext(originalContext: ExecutionContext, typedContext: TypedExpressionContext): ExecutionContext;
+export declare class ConversionAdapter {
+    static evaluateAs(context: ExecutionContext, value: unknown, type: string): Promise<unknown>;
+    static evaluateIs(context: ExecutionContext, value: unknown, type: string): Promise<boolean>;
+    static getExpressionMetadata(expressionName: string): import("../../../types/base-types").ExpressionMetadata;
+    static getExpressionDocumentation(expressionName: string): import("../../../types/base-types").LLMDocumentation;
+    static validateExpressionInput(expressionName: string, input: unknown): import("../../../types/base-types").ValidationResult<unknown>;
+}
+export declare const EnhancedConversionAdapter: typeof ConversionAdapter;
+export declare class LegacyCompatibilityLayer {
+    static asExpression: {
+        name: string;
+        category: "Conversion";
+        evaluatesTo: "Any";
+        evaluate(context: ExecutionContext, value: unknown, type: string): Promise<unknown>;
+        validate(args: unknown[]): string | null;
+    };
+    static isExpression: {
+        name: string;
+        category: "Conversion";
+        evaluatesTo: "Boolean";
+        evaluate(context: ExecutionContext, value: unknown, type: string): Promise<boolean>;
+        validate(args: unknown[]): string | null;
+    };
+}
+export declare class ExpressionMigrationUtility {
+    private static migrationMap;
+    static enableEnhanced(expressionName: string): void;
+    static disableEnhanced(expressionName: string): void;
+    static isEnhancedEnabled(expressionName: string): boolean;
+    static getMigrationStatus(): {
+        [k: string]: boolean;
+    };
+    static enableAllEnhanced(): void;
+    static disableAllEnhanced(): void;
+}
+export declare class ConversionUtilities {
+    static safeConvert(context: ExecutionContext, value: unknown, type: string, fallback?: unknown): Promise<{
+        success: boolean;
+        value: unknown;
+        error?: unknown;
+    }>;
+    static batchConvert(context: ExecutionContext, conversions: Array<{
+        value: unknown;
+        type: string;
+        key?: string;
+    }>): Promise<{
+        success: boolean;
+        results: Record<string, unknown>;
+        errors: Array<unknown>;
+    }>;
+    static getAvailableConversions(): {
+        String: {
+            description: string;
+            complexity: string;
+        };
+        Number: {
+            description: string;
+            complexity: string;
+        };
+        Int: {
+            description: string;
+            complexity: string;
+        };
+        Float: {
+            description: string;
+            complexity: string;
+        };
+        Boolean: {
+            description: string;
+            complexity: string;
+        };
+        Array: {
+            description: string;
+            complexity: string;
+        };
+        Object: {
+            description: string;
+            complexity: string;
+        };
+        Date: {
+            description: string;
+            complexity: string;
+        };
+        JSON: {
+            description: string;
+            complexity: string;
+        };
+        Values: {
+            description: string;
+            complexity: string;
+        };
+        'Values:Form': {
+            description: string;
+            complexity: string;
+        };
+        'Values:JSON': {
+            description: string;
+            complexity: string;
+        };
+        HTML: {
+            description: string;
+            complexity: string;
+        };
+        Fragment: {
+            description: string;
+            complexity: string;
+        };
+        'Fixed:N': {
+            description: string;
+            complexity: string;
+        };
+    };
+}
+//# sourceMappingURL=bridge.d.ts.map

package/dist/expressions/conversion/impl/index.d.ts

@@ -0,0 +1,59 @@
+import { type RuntimeValidator } from '../../../validation/lightweight-validators';
+import type { TypedExpressionContext, EvaluationResult, ExpressionMetadata, BaseTypedExpression, ValidationResult, EvaluationType } from '../../../types/base-types';
+import type { ExpressionCategory, LLMDocumentation } from '../../../types/expression-types';
+import { BaseExpressionImpl } from '../../base-expression';
+export type SupportedConversionType = 'Array' | 'Boolean' | 'Date' | 'Float' | 'Fragment' | 'HTML' | 'Int' | 'JSON' | 'Number' | 'Object' | 'String' | 'Values' | 'Values:Form' | 'Values:JSON' | `Fixed:${number}` | string;
+export interface EnhancedTypeConverter<T = unknown> {
+    (value: unknown, context: TypedExpressionContext): EvaluationResult<T>;
+}
+export declare const enhancedConverters: Record<string, EnhancedTypeConverter>;
+export declare class AsExpression extends BaseExpressionImpl<{
+    value: unknown;
+    type: string;
+}, unknown> implements BaseTypedExpression<unknown> {
+    readonly name = "as";
+    readonly category: ExpressionCategory;
+    readonly syntax = "value as Type";
+    readonly description = "Converts values between different types using the \"as\" keyword";
+    readonly outputType: EvaluationType;
+    readonly inputSchema: RuntimeValidator<{
+        value: unknown;
+        type: string;
+    }>;
+    readonly metadata: ExpressionMetadata;
+    readonly documentation: LLMDocumentation;
+    evaluate(context: TypedExpressionContext, input: {
+        value: unknown;
+        type: string;
+    }): Promise<EvaluationResult<unknown>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class IsExpression extends BaseExpressionImpl<{
+    value: unknown;
+    type: string;
+}, boolean> implements BaseTypedExpression<boolean> {
+    readonly name = "is";
+    readonly category: ExpressionCategory;
+    readonly syntax = "value is Type";
+    readonly description = "Checks if a value is of a specific type";
+    readonly outputType: EvaluationType;
+    readonly inputSchema: RuntimeValidator<{
+        value: unknown;
+        type: string;
+    }>;
+    readonly metadata: ExpressionMetadata;
+    readonly documentation: LLMDocumentation;
+    evaluate(context: TypedExpressionContext, input: {
+        value: unknown;
+        type: string;
+    }): Promise<EvaluationResult<boolean>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare const conversionExpressions: {
+    readonly as: AsExpression;
+    readonly is: IsExpression;
+};
+export type ConversionExpressionName = keyof typeof conversionExpressions;
+export declare function createAsExpression(): AsExpression;
+export declare function createIsExpression(): IsExpression;
+//# sourceMappingURL=index.d.ts.map

package/dist/expressions/conversion/index.d.ts

@@ -0,0 +1,23 @@
+import type { ExecutionContext, ExpressionImplementation } from '../../types/core';
+export interface ConversionFunction {
+    (value: unknown, context?: ExecutionContext): unknown;
+}
+export declare const defaultConversions: Record<string, ConversionFunction>;
+declare function getFormValues(form: HTMLFormElement): Record<string, unknown>;
+declare function getFormValuesProcessed(form: HTMLFormElement): Record<string, unknown>;
+declare function getInputValue(input: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement): unknown;
+declare function parseFixedPrecision(type: string): {
+    precision?: number;
+};
+export declare const asExpression: ExpressionImplementation;
+export declare const isExpression: ExpressionImplementation;
+export declare const asyncExpression: ExpressionImplementation;
+export declare const conversionExpressions: {
+    readonly as: ExpressionImplementation;
+    readonly is: ExpressionImplementation;
+    readonly async: ExpressionImplementation;
+};
+export type ConversionExpressionName = keyof typeof conversionExpressions;
+export { getFormValues, getFormValuesProcessed, getInputValue, parseFixedPrecision };
+export { AsExpression, createAsExpression } from './impl/index';
+//# sourceMappingURL=index.d.ts.map

package/dist/expressions/expression-tiers.d.ts

@@ -0,0 +1,13 @@
+export declare const EXPRESSION_TIERS: {
+    readonly core: readonly ["references", "logical", "special"];
+    readonly common: readonly ["properties", "conversion"];
+    readonly optional: readonly ["positional"];
+};
+export type ExpressionTier = keyof typeof EXPRESSION_TIERS;
+export type ExpressionCategory = (typeof EXPRESSION_TIERS.core)[number] | (typeof EXPRESSION_TIERS.common)[number] | (typeof EXPRESSION_TIERS.optional)[number];
+export declare const CATEGORY_TO_TIER: Record<ExpressionCategory, ExpressionTier>;
+export declare function getTierForCategory(category: string): ExpressionTier | null;
+export declare function getCategoriesForTier(tier: ExpressionTier): readonly string[];
+export declare function isCategoryInTier(category: string, tier: ExpressionTier): boolean;
+export declare function getAllCategories(): string[];
+//# sourceMappingURL=expression-tiers.d.ts.map

package/dist/expressions/index.d.ts

@@ -0,0 +1,11 @@
+export { referencesExpressions as references } from './bundles/core-expressions';
+export { logicalExpressions as logical } from './bundles/core-expressions';
+export { specialExpressions as special } from './bundles/core-expressions';
+export { conversionExpressions as conversion } from './bundles/common-expressions';
+export { positionalExpressions as positional } from './bundles/common-expressions';
+export { propertiesExpressions as properties } from './bundles/full-expressions';
+export { createCoreExpressionEvaluator, createCommonExpressionEvaluator, createFullExpressionEvaluator, } from './bundles';
+export { ConfigurableExpressionEvaluator } from '../core/configurable-expression-evaluator';
+export { BaseExpressionEvaluator } from '../core/base-expression-evaluator';
+export * from './bundles';
+//# sourceMappingURL=index.d.ts.map