@hyperfixi/core 2.0.0

package/dist/chunks/feature-eventsource-DWb514fy.js

@@ -0,0 +1,2 @@
+import{v as e,z as n}from"./feature-sockets-3PFuvCVY.js";e.object({source:n.object({url:e.string().min(1),withCredentials:e.boolean().default(!1),headers:n.record(e.string(),e.string()).default({}),retry:e.object({enabled:e.boolean().default(!0),maxAttempts:e.number().default(5),delay:e.number().default(3e3),backoff:n.enum(["linear","exponential"]).default("exponential"),maxDelay:e.number().default(3e4)}).default({}),timeout:e.object({enabled:e.boolean().default(!0),duration:e.number().default(6e4)}).default({})}),eventHandlers:e.array(e.object({event:e.string().min(1),commands:e.array(e.any()).min(1),filter:e.string().optional(),options:n.object({throttle:e.number().optional(),debounce:e.number().optional()}).optional()})).default([]),messageProcessing:e.object({format:n.enum(["text","json","raw"]).default("text"),validation:n.object({enabled:e.boolean().default(!0),schema:e.any().optional()}).default({}),buffer:e.object({enabled:e.boolean().default(!0),maxSize:e.number().min(0).default(100),flushInterval:e.number().default(1e3)}).default({})}).default({}),context:e.object({variables:n.record(e.string(),e.any()).default({}),me:e.any().optional(),it:e.any().optional(),target:e.any().optional()}).default({}),options:e.object({enableAutoConnect:e.boolean().default(!0),enableMessageBuffer:e.boolean().default(!0),enableErrorHandling:e.boolean().default(!0),maxConnections:e.number().default(1),connectionTimeout:e.number().default(3e4)}).default({}),environment:n.enum(["frontend","backend","universal"]).default("frontend"),debug:e.boolean().default(!1)}),e.object({contextId:e.string(),timestamp:e.number(),category:e.literal("Frontend"),capabilities:e.array(e.string()),state:n.enum(["ready","connecting","connected","disconnecting","disconnected","error"]),connection:n.object({connect:e.any(),disconnect:e.any(),reconnect:e.any(),getState:e.any(),getConnectionInfo:e.any(),isConnected:e.any()}),events:e.object({addHandler:e.any(),removeHandler:e.any(),getHandlers:e.any(),emit:e.any()}),messages:e.object({getHistory:e.any(),getBuffer:e.any(),flushBuffer:e.any(),clearHistory:e.any(),subscribe:e.any(),unsubscribe:e.any()}),errors:e.object({handle:e.any(),getErrorHistory:e.any(),clearErrors:e.any(),setErrorHandler:e.any()})});
+//# sourceMappingURL=feature-eventsource-DWb514fy.js.map

package/dist/chunks/feature-sockets-3PFuvCVY.js

@@ -0,0 +1,2 @@
+function e(e,t,r,n=[]){return{type:e,message:t,suggestions:n,...r&&{path:r}}}const t="undefined"!=typeof process&&"production"===process.env.NODE_ENV||"undefined"!=typeof process&&"true"===process.env.HYPERFIXI_SKIP_VALIDATION||"undefined"!=typeof globalThis&&"true"===globalThis.HYPERFIXI_SKIP_VALIDATION;let r;function n(){return r({validate:e=>({success:!0,data:e})})}function s(a,o){if(t)return n();const c=r({validate:t=>{if("object"!=typeof t||null===t||Array.isArray(t))return{success:!1,error:e("type-mismatch","Expected object, received "+typeof t)};const r=t,n={};if(o?.strict){const t=Object.keys(a),n=Object.keys(r).filter(e=>!t.includes(e));if(n.length>0)return{success:!1,error:e("runtime-error","Unexpected properties: "+n.join(", "))}}for(const[t,s]of Object.entries(a)){const a=r[t];if(!(t in r)&&!s._isOptional)return{success:!1,error:e("missing-argument",`Required field "${t}" is missing`,t)};const o=s.validate(a);if(!o.success){return{success:!1,error:e("validation-error",o.error.message||`Field "${t}" validation failed`,o.error.path?`${t}.${o.error.path}`:t)}}void 0!==o.data&&(n[t]=o.data)}return{success:!0,data:n}}});return c.strict=()=>s(a,{strict:!0}),c}function a(s,a="Custom validation failed"){return t?n():r({validate:t=>s(t)?{success:!0,data:t}:{success:!1,error:e("runtime-error",a)}})}r=function(t){return t.describe||(t.describe=function(e){return this.description=e,this}),t.safeParse||(t.safeParse=function(e){const t=this.validate(e);return t.success?{success:!0,data:t.data}:{success:!1,error:{errors:t.error?[t.error]:[]}}}),t.parse||(t.parse=function(e){const t=this.validate(e);if(t.success&&void 0!==t.data)return t.data;throw Error(t.error?.message||"Validation failed")}),t.optional||(t.optional=function(){const e=this.validate.bind(this),t={...this,_isOptional:!0,validate:t=>null==t?{success:!0,data:void 0}:e(t)};return r(t)}),t.min||(t.min=function(t){const n=this.validate.bind(this),s={...this,validate:r=>{const s=n(r);return s.success&&"string"==typeof s.data&&t>s.data.length?{success:!1,error:e("runtime-error",`String must be at least ${t} characters long`)}:s}};return r(s)}),t.max||(t.max=function(t){const n=this.validate.bind(this),s={...this,validate:r=>{const s=n(r);return s.success&&"string"==typeof s.data&&s.data.length>t?{success:!1,error:e("runtime-error",`String must be at most ${t} characters long`)}:s}};return r(s)}),t.default||(t.default=function(e){const t=this.validate.bind(this),n={...this,_defaultValue:e,_hasDefault:!0,validate:r=>void 0===r?{success:!0,data:e}:t(r)};return r(n)}),t.rest||(t.rest=function(e){return this}),t.refine||(t.refine=function(t,n){const s=this.validate.bind(this),a={...this,validate:r=>{const a=s(r);return a.success?t(a.data)?a:{success:!1,error:e("runtime-error",n||"Refinement validation failed")}:a}};return r(a)}),new Proxy(t,{get:(e,t,r)=>t in e||"string"!=typeof t||t.startsWith("_")||"constructor"===t||"validate"===t||"then"===t?Reflect.get(e,t,r):function(...e){return r}})};const o={string:s=>function(s={}){return t?n():r({validate:t=>s.optional&&null==t?{success:!0,data:void 0}:"string"!=typeof t?{success:!1,error:e("type-mismatch","Expected string, received "+typeof t)}:void 0!==s.minLength&&s.minLength>t.length?{success:!1,error:e("runtime-error",`String must be at least ${s.minLength} characters long`)}:void 0!==s.maxLength&&t.length>s.maxLength?{success:!1,error:e("runtime-error",`String must be at most ${s.maxLength} characters long`)}:s.pattern&&!s.pattern.test(t)?s.pattern.source.startsWith("^")&&s.pattern.source.endsWith("$")?{success:!1,error:e("runtime-error",`Expected "${s.pattern.source.slice(1,-1)}", received "${t}"`)}:{success:!1,error:e("missing-argument","String does not match required pattern")}:{success:!0,data:t},...s.description&&{description:s.description}})}(s||{}),number:s=>function(s={}){return t?n():r({validate:t=>{const r=Number(t);return isNaN(r)?{success:!1,error:e("type-mismatch","Expected number, received "+typeof t)}:void 0!==s.min&&s.min>r?{success:!1,error:e("runtime-error","Number must be at least "+s.min)}:void 0!==s.max&&r>s.max?{success:!1,error:e("runtime-error","Number must be at most "+s.max)}:{success:!0,data:r}}})}(s||{}),boolean:()=>t?n():r({validate:t=>"boolean"!=typeof t?{success:!1,error:e("type-mismatch","Expected boolean, received "+typeof t)}:{success:!0,data:t}}),object:e=>s(e),array:s=>function(s){return t?n():r({validate:t=>{if(!Array.isArray(t))return{success:!1,error:e("type-mismatch","Expected array, received "+typeof t)};const r=[];for(let n=0;t.length>n;n++){const a=s.validate(t[n]);if(!a.success)return{success:!1,error:e("runtime-error",a.error.message,a.error.path?`${n}.${a.error.path}`:""+n)};r.push(a.data)}return{success:!0,data:r}}})}(s),tuple:s=>function(s){return t?n():r({validate:t=>{if(!Array.isArray(t))return{success:!1,error:e("type-mismatch","Expected array, received "+typeof t)};if(t.length!==s.length)return{success:!1,error:e("runtime-error",`Expected tuple of length ${s.length}, received length ${t.length}`)};const r=[];for(let n=0;s.length>n;n++){const a=s[n].validate(t[n]);if(!a.success)return{success:!1,error:e("runtime-error",a.error.message,a.error.path?`${n}.${a.error.path}`:""+n)};r.push(a.data)}return{success:!0,data:r}}})}(s),union:s=>function(s){return t?n():r({validate:t=>{const r=[];for(const e of s){const n=e.validate(t);if(n.success)return n;r.push(n.error.message)}return{success:!1,error:e("type-mismatch","Value does not match any union type")}}})}(s),literal:s=>{return a=s,t?n():r({validate:t=>t===a?{success:!0,data:t}:{success:!1,error:e("runtime-error",`Expected ${JSON.stringify(a)}, received ${JSON.stringify(t)}`)}});var a},custom:(e,t)=>a(e,t),record:(s,a)=>function(s,a){return t?n():r({validate:t=>{if("object"!=typeof t||null===t||Array.isArray(t))return{success:!1,error:e("type-mismatch","Expected record object, received "+typeof t)};const r=t,n={};for(const[t,o]of Object.entries(r)){const r=s.validate(t);if(!r.success)return{success:!1,error:e("invalid-argument",`Invalid key "${t}": ${r.error.message}`,t)};const c=a.validate(o);if(!c.success)return{success:!1,error:e("runtime-error",c.error.message,c.error.path?`${t}.${c.error.path}`:t)};n[t]=c.data}return{success:!0,data:n}}})}(s,a),enum:s=>function(s){return t?n():r({validate:t=>"string"!=typeof t&&"number"!=typeof t&&"boolean"!=typeof t?{success:!1,error:e("type-mismatch","Expected string, received "+typeof t)}:s.includes(t)?{success:!0,data:t}:{success:!1,error:e("runtime-error",`Expected one of [${s.join(", ")}], received "${t}"`)}})}(s),function:()=>a(e=>"function"==typeof e,"Expected function"),unknown:()=>n(),any:()=>n(),null:()=>a(e=>null===e,"Expected null"),undefined:()=>a(e=>void 0===e,"Expected undefined"),instanceOf:e=>a(t=>t instanceof e,"Expected instance of "+e.name),instanceof:e=>a(t=>t instanceof e,"Expected instance of "+e.name)},c=o;o.object({socket:c.object({url:o.string().url(),protocols:o.array(o.string()).default([]),reconnect:c.object({enabled:o.boolean().default(!0),maxAttempts:o.number().default(5),delay:o.number().default(1e3),backoff:c.enum(["linear","exponential"]).default("exponential"),maxDelay:o.number().default(3e4)}).default({}),heartbeat:o.object({enabled:o.boolean().default(!1),interval:o.number().default(3e4),message:o.string().default("ping"),timeout:o.number().default(5e3)}).default({}),compression:o.boolean().default(!1),binaryType:c.enum(["blob","arraybuffer"]).default("blob")}),eventHandlers:o.array(o.object({event:c.enum(["open","close","error","message"]),filter:o.string().optional(),commands:o.array(o.any()),options:c.object({once:o.boolean().default(!1),debounce:o.number().optional(),throttle:o.number().optional()}).default({})})).default([]),messageHandling:o.object({format:c.enum(["json","text","binary"]).default("json"),validation:c.object({enabled:o.boolean().default(!0),schema:o.any().optional()}).default({}),queue:o.object({enabled:o.boolean().default(!0),maxSize:o.number().default(100),persistence:o.boolean().default(!1)}).default({})}).default({}),context:o.object({variables:c.record(o.string(),o.any()).default({}),me:o.any().optional(),it:o.any().optional(),target:o.any().optional()}).default({}),options:o.object({enableAutoConnect:o.boolean().default(!0),enableMessageQueue:o.boolean().default(!0),enableErrorHandling:o.boolean().default(!0),maxConnections:o.number().default(5),connectionTimeout:o.number().default(1e4)}).default({}),environment:c.enum(["frontend","backend","universal"]).default("frontend"),debug:o.boolean().default(!1)}),o.object({contextId:o.string(),timestamp:o.number(),category:o.literal("Frontend"),capabilities:o.array(o.string()),state:c.enum(["ready","connecting","connected","disconnecting","disconnected","error"]),connection:c.object({connect:o.any(),disconnect:o.any(),reconnect:o.any(),isConnected:o.any(),getState:o.any(),getConnectionInfo:o.any()}),messaging:o.object({send:o.any(),sendJSON:o.any(),sendBinary:o.any(),subscribe:o.any(),unsubscribe:o.any(),getMessageHistory:o.any()}),events:o.object({addHandler:o.any(),removeHandler:o.any(),emit:o.any(),getHandlers:o.any()}),queue:o.object({add:o.any(),process:o.any(),clear:o.any(),getSize:o.any(),getPending:o.any()}),errors:o.object({handle:o.any(),getErrorHistory:o.any(),clearErrors:o.any(),setErrorHandler:o.any()})});var i=Object.freeze({__proto__:null});export{i as s,o as v,c as z};
+//# sourceMappingURL=feature-sockets-3PFuvCVY.js.map

package/dist/chunks/feature-webworker-DTm_eh-E.js

@@ -0,0 +1,2 @@
+import{v as e,z as a}from"./feature-sockets-3PFuvCVY.js";e.object({worker:a.object({script:e.string().min(1),type:a.enum(["module","classic"]).default("classic"),name:e.string().optional(),credentials:a.enum(["omit","same-origin","include"]).default("same-origin"),inline:e.boolean().default(!1)}),messaging:e.object({format:a.enum(["json","text","binary"]).default("json"),serialization:a.enum(["structured-clone","json"]).default("structured-clone"),transferables:e.array(e.string()).default([]),validation:a.object({enabled:e.boolean().default(!0),schema:e.any().optional()}).default({}),queue:e.object({enabled:e.boolean().default(!0),maxSize:e.number().min(0).default(100),persistence:e.boolean().default(!1)}).default({})}).default({}),eventHandlers:e.array(e.object({event:a.enum(["message","error","messageerror"]),commands:e.array(e.any()).min(1),filter:e.string().optional(),options:a.object({throttle:e.number().optional(),debounce:e.number().optional()}).optional()})).default([]),context:e.object({variables:a.record(e.string(),e.any()).default({}),me:e.any().optional(),it:e.any().optional(),target:e.any().optional()}).default({}),options:e.object({enableAutoStart:e.boolean().default(!0),enableMessageQueue:e.boolean().default(!0),enableErrorHandling:e.boolean().default(!0),maxWorkers:e.number().default(4),workerTimeout:e.number().default(3e4),terminationTimeout:e.number().default(5e3)}).default({}),environment:a.enum(["frontend","backend","universal"]).default("frontend"),debug:e.boolean().default(!1)}),e.object({contextId:e.string(),timestamp:e.number(),category:e.literal("Frontend"),capabilities:e.array(e.string()),state:a.enum(["ready","starting","running","terminating","terminated","error"]),workers:a.object({create:e.any(),terminate:e.any(),restart:e.any(),getWorker:e.any(),listWorkers:e.any(),getWorkerInfo:e.any()}),messaging:e.object({send:e.any(),sendJSON:e.any(),sendBinary:e.any(),broadcast:e.any(),getMessageHistory:e.any(),subscribe:e.any(),unsubscribe:e.any()}),events:e.object({addHandler:e.any(),removeHandler:e.any(),getHandlers:e.any(),emit:e.any()}),queue:e.object({add:e.any(),process:e.any(),getSize:e.any(),getPending:e.any(),clear:e.any()}),errors:e.object({handle:e.any(),getErrorHistory:e.any(),clearErrors:e.any(),setErrorHandler:e.any()})});
+//# sourceMappingURL=feature-webworker-DTm_eh-E.js.map

package/dist/commands/advanced/async.d.ts

@@ -0,0 +1,28 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface AsyncCommandInput {
+    commands: any[];
+}
+export interface AsyncCommandOutput {
+    commandCount: number;
+    results: any[];
+    executed: boolean;
+    duration: number;
+}
+export declare class AsyncCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, _evaluator: ExpressionEvaluator, _context: ExecutionContext): Promise<AsyncCommandInput>;
+    execute(input: AsyncCommandInput, context: TypedExecutionContext): Promise<AsyncCommandOutput>;
+    private executeCommandsAsync;
+    private executeCommand;
+    private getCommandName;
+}
+export declare const createAsyncCommand: () => AsyncCommand;
+export default AsyncCommand;
+//# sourceMappingURL=async.d.ts.map

package/dist/commands/advanced/js.d.ts

@@ -0,0 +1,28 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface JsCommandInput {
+    code: string;
+    parameters?: string[];
+}
+export interface JsCommandOutput {
+    result: any;
+    executed: boolean;
+    codeLength: number;
+    parameters?: string[];
+    preserveArrayResult: true;
+}
+export declare class JsCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, _evaluator: ExpressionEvaluator, _context: ExecutionContext): Promise<JsCommandInput>;
+    execute(input: JsCommandInput, context: TypedExecutionContext): Promise<JsCommandOutput>;
+    private createExecutionContext;
+}
+export declare const createJsCommand: () => JsCommand;
+export default JsCommand;
+//# sourceMappingURL=js.d.ts.map

package/dist/commands/animation/measure.d.ts

@@ -0,0 +1,31 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface MeasureCommandInput {
+    target?: string | HTMLElement;
+    property?: string;
+    variable?: string;
+}
+export interface MeasureCommandOutput {
+    result: number;
+    wasAsync: boolean;
+    element: HTMLElement;
+    property: string;
+    value: number;
+    unit: string;
+    stored?: boolean;
+}
+export declare class MeasureCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<MeasureCommandInput>;
+    execute(input: MeasureCommandInput, context: TypedExecutionContext): Promise<MeasureCommandOutput>;
+    private getMeasurement;
+}
+export declare const createMeasureCommand: () => MeasureCommand;
+export default MeasureCommand;
+//# sourceMappingURL=measure.d.ts.map

package/dist/commands/animation/settle.d.ts

@@ -0,0 +1,26 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface SettleCommandInput {
+    target?: string | HTMLElement;
+    timeout?: number | string;
+}
+export interface SettleCommandOutput {
+    element: HTMLElement;
+    settled: boolean;
+    timeout: number;
+    duration: number;
+}
+export declare class SettleCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<SettleCommandInput>;
+    execute(input: SettleCommandInput, context: TypedExecutionContext): Promise<SettleCommandOutput>;
+}
+export declare const createSettleCommand: () => SettleCommand;
+export default SettleCommand;
+//# sourceMappingURL=settle.d.ts.map

package/dist/commands/animation/take.d.ts

@@ -0,0 +1,28 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface TakeCommandInput {
+    property: string;
+    source: unknown;
+    target?: unknown;
+}
+export interface TakeCommandOutput {
+    targetElement: HTMLElement;
+    property: string;
+    value: unknown;
+}
+export declare class TakeCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<TakeCommandInput>;
+    execute(input: TakeCommandInput, context: TypedExecutionContext): Promise<TakeCommandOutput>;
+    private takeProperty;
+    private putProperty;
+}
+export declare const createTakeCommand: () => TakeCommand;
+export default TakeCommand;
+//# sourceMappingURL=take.d.ts.map

package/dist/commands/animation/transition.d.ts

@@ -0,0 +1,31 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface TransitionCommandInput {
+    target?: string | HTMLElement;
+    property: string;
+    value: string | number;
+    duration?: number | string;
+    timingFunction?: string;
+}
+export interface TransitionCommandOutput {
+    element: HTMLElement;
+    property: string;
+    fromValue: string;
+    toValue: string;
+    duration: number;
+    completed: boolean;
+}
+export declare class TransitionCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<TransitionCommandInput>;
+    execute(input: TransitionCommandInput, context: TypedExecutionContext): Promise<TransitionCommandOutput>;
+}
+export declare const createTransitionCommand: () => TransitionCommand;
+export default TransitionCommand;
+//# sourceMappingURL=transition.d.ts.map

package/dist/commands/async/fetch.d.ts

@@ -0,0 +1,44 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export type FetchResponseType = 'text' | 'json' | 'html' | 'response' | 'blob' | 'arrayBuffer';
+export interface FetchResponseTypeConfig {
+    accept?: string;
+    handler: (response: Response, context: TypedExecutionContext) => Promise<unknown>;
+}
+export declare function registerFetchResponseType(name: string, config: FetchResponseTypeConfig): void;
+export declare function getCustomResponseType(name: string): FetchResponseTypeConfig | undefined;
+export interface FetchCommandInput {
+    url: string;
+    responseType: string;
+    options: RequestInit;
+}
+export interface FetchCommandOutput {
+    status: number;
+    statusText: string;
+    headers: Headers;
+    data: any;
+    url: string;
+    duration: number;
+}
+export declare class FetchCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<FetchCommandInput>;
+    execute(input: FetchCommandInput, context: TypedExecutionContext): Promise<FetchCommandOutput>;
+    private parseURL;
+    private parseResponseType;
+    private parseRequestOptions;
+    private parseHeaders;
+    private parseBody;
+    private handleResponse;
+    private parseHTML;
+    private dispatchEvent;
+}
+export declare const createFetchCommand: () => FetchCommand;
+export default FetchCommand;
+//# sourceMappingURL=fetch.d.ts.map

package/dist/commands/async/wait.d.ts

@@ -0,0 +1,41 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface WaitTimeInput {
+    type: 'time';
+    milliseconds: number;
+}
+export interface WaitEventInput {
+    type: 'event';
+    eventName: string;
+    target?: EventTarget;
+    destructure?: string[];
+}
+export interface WaitRaceInput {
+    type: 'race';
+    conditions: (WaitTimeInput | WaitEventInput)[];
+}
+export type WaitCommandInput = WaitTimeInput | WaitEventInput | WaitRaceInput;
+export interface WaitCommandOutput {
+    type: 'time' | 'event';
+    result: number | Event;
+    duration: number;
+}
+export declare class WaitCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<WaitCommandInput>;
+    execute(input: WaitCommandInput, context: TypedExecutionContext): Promise<WaitCommandOutput>;
+    private parseTimeWait;
+    private parseEventWait;
+    private parseEventArrayWait;
+    private parseRaceCondition;
+    private executeRace;
+}
+export declare const createWaitCommand: () => WaitCommand;
+export default WaitCommand;
+//# sourceMappingURL=wait.d.ts.map

package/dist/commands/behaviors/install.d.ts

@@ -0,0 +1,41 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+export interface InstallCommandInput {
+    behaviorName: string;
+    parameters?: Record<string, unknown>;
+    target?: unknown;
+}
+export interface InstallCommandOutput {
+    success: boolean;
+    behaviorName: string;
+    installedCount: number;
+    instances: unknown[];
+}
+export declare class InstallCommand {
+    readonly name = "install";
+    static readonly metadata: {
+        readonly description: "Install a behavior on an element with optional parameters";
+        readonly syntax: readonly ["install <BehaviorName>", "install <BehaviorName> on <element>", "install <BehaviorName>(param: value)", "install <BehaviorName>(param: value) on <element>"];
+        readonly examples: readonly ["install Removable", "install Draggable on #box", "install Tooltip(text: \"Help\", position: \"top\")", "install Sortable(axis: \"y\") on .list", "install MyBehavior(foo: 42) on the first <div/>"];
+        readonly category: "behaviors";
+        readonly sideEffects: readonly ["behavior-installation", "element-modification"];
+    };
+    get metadata(): {
+        readonly description: "Install a behavior on an element with optional parameters";
+        readonly syntax: readonly ["install <BehaviorName>", "install <BehaviorName> on <element>", "install <BehaviorName>(param: value)", "install <BehaviorName>(param: value) on <element>"];
+        readonly examples: readonly ["install Removable", "install Draggable on #box", "install Tooltip(text: \"Help\", position: \"top\")", "install Sortable(axis: \"y\") on .list", "install MyBehavior(foo: 42) on the first <div/>"];
+        readonly category: "behaviors";
+        readonly sideEffects: readonly ["behavior-installation", "element-modification"];
+    };
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<InstallCommandInput>;
+    execute(input: InstallCommandInput, context: TypedExecutionContext): Promise<InstallCommandOutput>;
+    private resolveTarget;
+    private behaviorExists;
+    private installBehavior;
+}
+export declare function createInstallCommand(): InstallCommand;
+//# sourceMappingURL=install.d.ts.map

package/dist/commands/content/append.d.ts

@@ -0,0 +1,27 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface AppendCommandInput {
+    content: unknown;
+    target?: string | HTMLElement | unknown[];
+}
+export interface AppendCommandOutput {
+    result: unknown;
+    targetType: 'result' | 'variable' | 'array' | 'element' | 'string';
+    target?: string | HTMLElement;
+}
+export declare class AppendCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<AppendCommandInput>;
+    execute(input: AppendCommandInput, context: TypedExecutionContext): Promise<AppendCommandOutput>;
+    private resolveDOMElement;
+    private resolveContextRef;
+}
+export declare const createAppendCommand: () => AppendCommand;
+export default AppendCommand;
+//# sourceMappingURL=append.d.ts.map

package/dist/commands/control-flow/break.d.ts

@@ -0,0 +1,15 @@
+import { ControlFlowSignalBase } from './signal-base';
+export interface BreakCommandInput {
+}
+export interface BreakCommandOutput {
+    broken: true;
+    timestamp: number;
+}
+export declare class BreakCommand extends ControlFlowSignalBase {
+    protected readonly signalType: "break";
+    protected readonly errorMessage = "BREAK_LOOP";
+    protected readonly errorFlag = "isBreak";
+}
+export declare const createBreakCommand: () => BreakCommand;
+export default BreakCommand;
+//# sourceMappingURL=break.d.ts.map

package/dist/commands/control-flow/continue.d.ts

@@ -0,0 +1,15 @@
+import { ControlFlowSignalBase } from './signal-base';
+export interface ContinueCommandInput {
+}
+export interface ContinueCommandOutput {
+    continued: true;
+    timestamp: number;
+}
+export declare class ContinueCommand extends ControlFlowSignalBase {
+    protected readonly signalType: "continue";
+    protected readonly errorMessage = "CONTINUE_LOOP";
+    protected readonly errorFlag = "isContinue";
+}
+export declare const createContinueCommand: () => ContinueCommand;
+export default ContinueCommand;
+//# sourceMappingURL=continue.d.ts.map

package/dist/commands/control-flow/exit.d.ts

@@ -0,0 +1,15 @@
+import { ControlFlowSignalBase } from './signal-base';
+export interface ExitCommandInput {
+}
+export interface ExitCommandOutput {
+    exited: boolean;
+    timestamp: number;
+}
+export declare class ExitCommand extends ControlFlowSignalBase {
+    protected readonly signalType: "exit";
+    protected readonly errorMessage = "EXIT_COMMAND";
+    protected readonly errorFlag = "isExit";
+}
+export declare const createExitCommand: () => ExitCommand;
+export default ExitCommand;
+//# sourceMappingURL=exit.d.ts.map

package/dist/commands/control-flow/halt.d.ts

@@ -0,0 +1,25 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface HaltCommandInput {
+    target?: unknown;
+}
+export interface HaltCommandOutput {
+    halted: true;
+    timestamp: number;
+    eventHalted?: boolean;
+}
+export declare class HaltCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<HaltCommandInput>;
+    execute(input: HaltCommandInput, context: TypedExecutionContext): Promise<HaltCommandOutput>;
+    private isEvent;
+}
+export declare const createHaltCommand: () => HaltCommand;
+export default HaltCommand;
+//# sourceMappingURL=halt.d.ts.map

package/dist/commands/control-flow/if.d.ts

@@ -0,0 +1,45 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export type ConditionalMode = 'if' | 'unless';
+export interface ConditionalCommandInput {
+    mode: ConditionalMode;
+    condition: unknown;
+    thenCommands: ASTNode | ASTNode[];
+    elseCommands?: ASTNode | ASTNode[];
+}
+export interface IfCommandInput extends ConditionalCommandInput {
+}
+export interface UnlessCommandInput {
+    condition: unknown;
+    commands: ASTNode[];
+}
+export interface ConditionalCommandOutput {
+    mode: ConditionalMode;
+    conditionResult: boolean;
+    executedBranch: 'then' | 'else' | 'none';
+    result: unknown;
+}
+export interface IfCommandOutput extends ConditionalCommandOutput {
+}
+export declare class ConditionalCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+        commandName?: string;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<ConditionalCommandInput>;
+    execute(input: ConditionalCommandInput, context: TypedExecutionContext): Promise<ConditionalCommandOutput>;
+    private executeCommandsOrBlock;
+    private executeBlock;
+    private executeCommands;
+}
+export declare const createConditionalCommand: () => ConditionalCommand;
+export { ConditionalCommand as IfCommand };
+export declare const createIfCommand: () => ConditionalCommand;
+export { ConditionalCommand as UnlessCommand };
+export declare const createUnlessCommand: () => ConditionalCommand;
+export default ConditionalCommand;
+//# sourceMappingURL=if.d.ts.map

package/dist/commands/control-flow/repeat.d.ts

@@ -0,0 +1,35 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface RepeatCommandInput {
+    type: 'for' | 'times' | 'while' | 'until' | 'until-event' | 'forever';
+    variable?: string;
+    collection?: unknown[];
+    condition?: unknown;
+    count?: number;
+    indexVariable?: string;
+    commands?: unknown;
+    eventName?: string;
+    eventTarget?: EventTarget;
+}
+export interface RepeatCommandOutput {
+    type: string;
+    iterations: number;
+    completed: boolean;
+    lastResult?: unknown;
+    interrupted?: boolean;
+}
+export declare class RepeatCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<RepeatCommandInput>;
+    execute(input: RepeatCommandInput, context: TypedExecutionContext): Promise<RepeatCommandOutput>;
+    private executeCommands;
+}
+export declare const createRepeatCommand: () => RepeatCommand;
+export default RepeatCommand;
+//# sourceMappingURL=repeat.d.ts.map

package/dist/commands/control-flow/return.d.ts

@@ -0,0 +1,23 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface ReturnCommandInput {
+    value?: unknown;
+}
+export interface ReturnCommandOutput {
+    returnValue: unknown;
+    timestamp: number;
+}
+export declare class ReturnCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<ReturnCommandInput>;
+    execute(input: ReturnCommandInput, context: TypedExecutionContext): Promise<ReturnCommandOutput>;
+}
+export declare const createReturnCommand: () => ReturnCommand;
+export default ReturnCommand;
+//# sourceMappingURL=return.d.ts.map

package/dist/commands/control-flow/signal-base.d.ts

@@ -0,0 +1,25 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import type { DecoratedCommand, CommandMetadata } from '../decorators';
+export type SignalType = 'break' | 'continue' | 'exit';
+export interface SignalCommandInput {
+    signalType: SignalType;
+}
+export interface SignalCommandOutput {
+    signalType: SignalType;
+    timestamp: number;
+}
+export declare abstract class ControlFlowSignalBase implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    protected abstract readonly signalType: SignalType;
+    protected abstract readonly errorMessage: string;
+    protected abstract readonly errorFlag: string;
+    parseInput(_raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, _evaluator: ExpressionEvaluator, _context: ExecutionContext): Promise<SignalCommandInput>;
+    execute(_input: SignalCommandInput, _context: TypedExecutionContext): Promise<SignalCommandOutput>;
+}
+//# sourceMappingURL=signal-base.d.ts.map

package/dist/commands/control-flow/throw.d.ts

@@ -0,0 +1,22 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface ThrowCommandInput {
+    message: string | Error | unknown;
+}
+export interface ThrowCommandOutput {
+    error: Error;
+}
+export declare class ThrowCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<ThrowCommandInput>;
+    execute(input: ThrowCommandInput, _context: TypedExecutionContext): Promise<ThrowCommandOutput>;
+}
+export declare const createThrowCommand: () => ThrowCommand;
+export default ThrowCommand;
+//# sourceMappingURL=throw.d.ts.map

package/dist/commands/control-flow/unless.d.ts

@@ -0,0 +1,3 @@
+export { ConditionalCommand as UnlessCommand, createUnlessCommand, type UnlessCommandInput, type ConditionalCommandOutput as UnlessCommandOutput, } from './if';
+export { ConditionalCommand as default } from './if';
+//# sourceMappingURL=unless.d.ts.map

package/dist/commands/data/decrement.d.ts

@@ -0,0 +1,3 @@
+export { NumericModifyCommand as DecrementCommand, createDecrementCommand, type DecrementCommandInput, } from './increment';
+export { NumericModifyCommand as default } from './increment';
+//# sourceMappingURL=decrement.d.ts.map