@pgflow/client 0.0.0-test-snapshot-releases-8d5d9bc1-20250922101013 → 0.0.0-testsnap-9294d743-20251207205914

package/dist/src/lib/FlowStep.js

@@ -0,0 +1,244 @@
+import { createNanoEvents } from 'nanoevents';
+import { FlowStepStatus } from './types.js';
+/**
+ * Represents a single step in a flow run
+ */
+export class FlowStep {
+    #state;
+    #events = createNanoEvents();
+    #statusPrecedence = {
+        [FlowStepStatus.Created]: 0,
+        [FlowStepStatus.Started]: 1,
+        [FlowStepStatus.Completed]: 2,
+        [FlowStepStatus.Failed]: 3,
+    };
+    /**
+     * Creates a new FlowStep instance
+     *
+     * @param initialState - Initial state for the step
+     */
+    constructor(initialState) {
+        this.#state = initialState;
+    }
+    /**
+     * Get the run ID this step belongs to
+     */
+    get run_id() {
+        return this.#state.run_id;
+    }
+    /**
+     * Get the step slug
+     */
+    get step_slug() {
+        return this.#state.step_slug;
+    }
+    /**
+     * Get the current status
+     */
+    get status() {
+        return this.#state.status;
+    }
+    /**
+     * Get the started_at timestamp
+     */
+    get started_at() {
+        return this.#state.started_at;
+    }
+    /**
+     * Get the completed_at timestamp
+     */
+    get completed_at() {
+        return this.#state.completed_at;
+    }
+    /**
+     * Get the failed_at timestamp
+     */
+    get failed_at() {
+        return this.#state.failed_at;
+    }
+    /**
+     * Get the step output
+     */
+    get output() {
+        return this.#state.output;
+    }
+    /**
+     * Get the error object
+     */
+    get error() {
+        return this.#state.error;
+    }
+    /**
+     * Get the error message
+     */
+    get error_message() {
+        return this.#state.error_message;
+    }
+    /**
+     * Register an event handler for a step event
+     *
+     * @param event - Event type to listen for
+     * @param callback - Callback function to execute when event is emitted
+     * @returns Function to unsubscribe from the event
+     */
+    on(event, callback) {
+        return this.#events.on(event, callback);
+    }
+    /**
+     * Wait for the step to reach a specific status
+     *
+     * @param targetStatus - The status to wait for
+     * @param options - Optional timeout and abort signal
+     * @returns Promise that resolves with the step instance when the status is reached
+     */
+    waitForStatus(targetStatus, options) {
+        const timeoutMs = options?.timeoutMs ?? 5 * 60 * 1000; // Default 5 minutes
+        const { signal } = options || {};
+        // If we already have the target status, resolve immediately
+        if (this.status === targetStatus) {
+            return Promise.resolve(this);
+        }
+        // Otherwise, wait for the status to change
+        return new Promise((resolve, reject) => {
+            let timeoutId;
+            let cleanedUp = false;
+            // Set up timeout if provided
+            if (timeoutMs > 0) {
+                timeoutId = setTimeout(() => {
+                    if (cleanedUp)
+                        return; // Prevent firing if already cleaned up
+                    cleanedUp = true;
+                    unbind();
+                    reject(new Error(`Timeout waiting for step ${this.step_slug} to reach status '${targetStatus}'`));
+                }, timeoutMs);
+            }
+            // Set up abort signal if provided
+            let abortCleanup;
+            if (signal) {
+                const abortHandler = () => {
+                    if (cleanedUp)
+                        return; // Prevent double cleanup
+                    cleanedUp = true;
+                    if (timeoutId)
+                        clearTimeout(timeoutId);
+                    unbind();
+                    reject(new Error(`Aborted waiting for step ${this.step_slug} to reach status '${targetStatus}'`));
+                };
+                signal.addEventListener('abort', abortHandler);
+                abortCleanup = () => {
+                    signal.removeEventListener('abort', abortHandler);
+                };
+            }
+            // Subscribe to all events
+            const unbind = this.on('*', (event) => {
+                if (event.status === targetStatus) {
+                    if (cleanedUp)
+                        return; // Prevent double cleanup
+                    cleanedUp = true;
+                    if (timeoutId)
+                        clearTimeout(timeoutId);
+                    if (abortCleanup)
+                        abortCleanup();
+                    unbind();
+                    resolve(this);
+                }
+            });
+        });
+    }
+    /**
+     * Apply state from database snapshot (no events emitted)
+     * Used when initializing state from start_flow_with_states() or get_run_with_states()
+     *
+     * @internal This method is only intended for use by PgflowClient.
+     * Applications should not call this directly.
+     */
+    applySnapshot(row) {
+        // Direct state assignment from database row (no event conversion)
+        this.#state.status = row.status;
+        this.#state.started_at = row.started_at ? new Date(row.started_at) : null;
+        this.#state.completed_at = row.completed_at ? new Date(row.completed_at) : null;
+        this.#state.failed_at = row.failed_at ? new Date(row.failed_at) : null;
+        this.#state.error_message = row.error_message;
+        this.#state.error = row.error_message ? new Error(row.error_message) : null;
+        // Note: output is not stored in step_states table, remains null
+    }
+    /**
+     * Updates the step state based on an event
+     *
+     * @internal This method is only intended for use by FlowRun and tests.
+     * Applications should not call this directly - state updates should come from
+     * database events through the PgflowClient.
+     *
+     * TODO: After v1.0, make this method private and refactor tests to use PgflowClient
+     * with event emission instead of direct state manipulation.
+     */
+    updateState(event) {
+        // Validate event is for this step
+        if (event.step_slug !== this.#state.step_slug) {
+            return false;
+        }
+        // Validate event is for this run
+        if (event.run_id !== this.#state.run_id) {
+            return false;
+        }
+        // Check if the event status has higher precedence than current status
+        if (!this.#shouldUpdateStatus(this.#state.status, event.status)) {
+            return false;
+        }
+        // Update state based on event type using narrowing type guards
+        switch (event.status) {
+            case FlowStepStatus.Started:
+                this.#state = {
+                    ...this.#state,
+                    status: FlowStepStatus.Started,
+                    started_at: typeof event.started_at === 'string' ? new Date(event.started_at) : new Date(),
+                };
+                this.#events.emit('started', event);
+                break;
+            case FlowStepStatus.Completed:
+                this.#state = {
+                    ...this.#state,
+                    status: FlowStepStatus.Completed,
+                    completed_at: typeof event.completed_at === 'string' ? new Date(event.completed_at) : new Date(),
+                    output: event.output,
+                };
+                this.#events.emit('completed', event);
+                break;
+            case FlowStepStatus.Failed:
+                this.#state = {
+                    ...this.#state,
+                    status: FlowStepStatus.Failed,
+                    failed_at: typeof event.failed_at === 'string' ? new Date(event.failed_at) : new Date(),
+                    error_message: typeof event.error_message === 'string' ? event.error_message : 'Unknown error',
+                    error: new Error(typeof event.error_message === 'string' ? event.error_message : 'Unknown error'),
+                };
+                this.#events.emit('failed', event);
+                break;
+            default: {
+                // Exhaustiveness check - ensures all event statuses are handled
+                event;
+                return false;
+            }
+        }
+        // Also emit to the catch-all listener
+        this.#events.emit('*', event);
+        return true;
+    }
+    /**
+     * Determines if a status should be updated based on precedence
+     *
+     * @param currentStatus - Current status
+     * @param newStatus - New status
+     * @returns true if the status should be updated, false otherwise
+     */
+    #shouldUpdateStatus(currentStatus, newStatus) {
+        // Don't allow changes to terminal states
+        if (currentStatus === FlowStepStatus.Completed || currentStatus === FlowStepStatus.Failed) {
+            return false; // Terminal states should never change
+        }
+        const currentPrecedence = this.#statusPrecedence[currentStatus];
+        const newPrecedence = this.#statusPrecedence[newStatus];
+        // Only allow transitions to higher precedence non-terminal status
+        return newPrecedence > currentPrecedence;
+    }
+}

package/dist/src/lib/PgflowClient.d.ts

@@ -0,0 +1,75 @@
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { AnyFlow, ExtractFlowInput } from '@pgflow/dsl';
+import type { IFlowClient, BroadcastRunEvent, BroadcastStepEvent, Unsubscribe } from './types.js';
+import { FlowRun } from './FlowRun.js';
+/**
+ * Client for interacting with pgflow
+ */
+export declare class PgflowClient<TFlow extends AnyFlow = AnyFlow> implements IFlowClient<TFlow> {
+    #private;
+    /**
+     * Creates a new PgflowClient instance
+     *
+     * @param supabaseClient - Supabase client instance
+     * @param opts - Optional configuration
+     */
+    constructor(supabaseClient: SupabaseClient, opts?: {
+        realtimeStabilizationDelayMs?: number;
+        schedule?: typeof setTimeout;
+    });
+    /**
+     * Start a flow with optional run_id
+     *
+     * @param flow_slug - Flow slug to start
+     * @param input - Input data for the flow
+     * @param run_id - Optional run ID (will be generated if not provided)
+     * @returns Promise that resolves with the FlowRun instance
+     */
+    startFlow<TSpecificFlow extends TFlow>(flow_slug: string, input: ExtractFlowInput<TSpecificFlow>, run_id?: string): Promise<FlowRun<TSpecificFlow>>;
+    /**
+     * Dispose a specific flow run
+     *
+     * @param runId - Run ID to dispose
+     */
+    dispose(runId: string): void;
+    /**
+     * Dispose all flow runs
+     */
+    disposeAll(): void;
+    /**
+     * Fetch flow definition metadata
+     */
+    fetchFlowDefinition(flow_slug: string): Promise<{
+        flow: import("pkgs/core/dist/types.js").FlowRow;
+        steps: import("pkgs/core/dist/types.js").StepRow[];
+    }>;
+    /**
+     * Register a callback for run events
+     * @returns Function to unsubscribe from the event
+     */
+    onRunEvent(callback: (event: BroadcastRunEvent) => void): Unsubscribe;
+    /**
+     * Register a callback for step events
+     * @returns Function to unsubscribe from the event
+     */
+    onStepEvent(callback: (event: BroadcastStepEvent) => void): Unsubscribe;
+    /**
+     * Subscribe to a flow run's events
+     */
+    subscribeToRun(run_id: string): Promise<() => void>;
+    /**
+     * Fetch current state of a run and its steps
+     */
+    getRunWithStates(run_id: string): Promise<{
+        run: import("pkgs/core/dist/types.js").RunRow;
+        steps: import("pkgs/core/dist/types.js").StepStateRow[];
+    }>;
+    /**
+     * Get a flow run by ID
+     *
+     * @param run_id - ID of the run to get
+     * @returns Promise that resolves with the FlowRun instance or null if not found
+     */
+    getRun<TSpecificFlow extends TFlow = TFlow>(run_id: string): Promise<FlowRun<TSpecificFlow> | null>;
+}
+//# sourceMappingURL=PgflowClient.d.ts.map

package/dist/src/lib/PgflowClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PgflowClient.d.ts","sourceRoot":"","sources":["../../../src/lib/PgflowClient.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE7D,OAAO,KAAK,EACV,WAAW,EAEX,iBAAiB,EACjB,kBAAkB,EAClB,WAAW,EAEZ,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC;;GAEG;AACH,qBAAa,YAAY,CAAC,KAAK,SAAS,OAAO,GAAG,OAAO,CAAE,YAAW,WAAW,CAAC,KAAK,CAAC;;IAOtF;;;;;OAKG;gBAED,cAAc,EAAE,cAAc,EAC9B,IAAI,GAAE;QACJ,4BAA4B,CAAC,EAAE,MAAM,CAAC;QACtC,QAAQ,CAAC,EAAE,OAAO,UAAU,CAAC;KACzB;IA4BR;;;;;;;OAOG;IACG,SAAS,CAAC,aAAa,SAAS,KAAK,EACzC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,gBAAgB,CAAC,aAAa,CAAC,EACtC,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;IAwDlC;;;;OAIG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAc5B;;OAEG;IACH,UAAU,IAAI,IAAI;IAQlB;;OAEG;IACG,mBAAmB,CAAC,SAAS,EAAE,MAAM;;;;IAI3C;;;OAGG;IACH,UAAU,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAAG,WAAW;IAIrE;;;OAGG;IACH,WAAW,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAAG,WAAW;IAIvE;;OAEG;IACG,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC;IAIzD;;OAEG;IACG,gBAAgB,CAAC,MAAM,EAAE,MAAM;;;;IAIrC;;;;;OAKG;IACG,MAAM,CAAC,aAAa,SAAS,KAAK,GAAG,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC;CA6E1G"}

package/dist/src/lib/PgflowClient.js

@@ -0,0 +1,227 @@
+import { v4 as uuidv4 } from 'uuid';
+import { FlowRunStatus } from './types.js';
+import { SupabaseBroadcastAdapter } from './SupabaseBroadcastAdapter.js';
+import { FlowRun } from './FlowRun.js';
+import { toTypedRunEvent, toTypedStepEvent } from './eventAdapters.js';
+/**
+ * Client for interacting with pgflow
+ */
+export class PgflowClient {
+    #supabase;
+    #realtimeAdapter;
+    // Use the widest event type - keeps the compiler happy but
+    // still provides the structural API we need (updateState/step/...)
+    #runs = new Map();
+    /**
+     * Creates a new PgflowClient instance
+     *
+     * @param supabaseClient - Supabase client instance
+     * @param opts - Optional configuration
+     */
+    constructor(supabaseClient, opts = {}) {
+        this.#supabase = supabaseClient;
+        this.#realtimeAdapter = new SupabaseBroadcastAdapter(supabaseClient, {
+            stabilizationDelayMs: opts.realtimeStabilizationDelayMs,
+            schedule: opts.schedule,
+        });
+        // Set up global event listeners - properly typed
+        this.#realtimeAdapter.onRunEvent((event) => {
+            const run = this.#runs.get(event.run_id);
+            if (run) {
+                // Convert broadcast event to typed event before updating state
+                run.updateState(toTypedRunEvent(event));
+            }
+        });
+        this.#realtimeAdapter.onStepEvent((event) => {
+            const run = this.#runs.get(event.run_id);
+            if (run) {
+                // Always materialize the step before updating to avoid event loss
+                // This ensures we cache all steps even if they were never explicitly requested
+                const stepSlug = event.step_slug;
+                run.step(stepSlug).updateState(toTypedStepEvent(event));
+            }
+        });
+    }
+    /**
+     * Start a flow with optional run_id
+     *
+     * @param flow_slug - Flow slug to start
+     * @param input - Input data for the flow
+     * @param run_id - Optional run ID (will be generated if not provided)
+     * @returns Promise that resolves with the FlowRun instance
+     */
+    async startFlow(flow_slug, input, run_id) {
+        // Generate a run_id if not provided
+        const id = run_id || uuidv4();
+        // Create initial state for the flow run
+        const initialState = {
+            run_id: id,
+            flow_slug,
+            status: FlowRunStatus.Started,
+            input: input,
+            output: null,
+            error: null,
+            error_message: null,
+            started_at: null,
+            completed_at: null,
+            failed_at: null,
+            remaining_steps: -1, // Use -1 to indicate unknown until first snapshot arrives
+        };
+        // Create the flow run instance
+        const run = new FlowRun(initialState);
+        // Store the run
+        this.#runs.set(id, run);
+        // Set up subscription for run and step events (wait for subscription confirmation)
+        await this.#realtimeAdapter.subscribeToRun(id);
+        // Start the flow with the predetermined run_id (only after subscription is ready)
+        const { data, error } = await this.#supabase.schema('pgflow').rpc('start_flow_with_states', {
+            flow_slug: flow_slug,
+            input: input,
+            run_id: id
+        });
+        if (error) {
+            // Clean up subscription and run instance
+            this.dispose(id);
+            throw error;
+        }
+        // Apply the run state snapshot (no events)
+        if (data.run) {
+            run.applySnapshot(data.run);
+        }
+        // Apply step state snapshots (no events)
+        if (data.steps && Array.isArray(data.steps)) {
+            for (const stepState of data.steps) {
+                run.step(stepState.step_slug).applySnapshot(stepState);
+            }
+        }
+        return run;
+    }
+    /**
+     * Dispose a specific flow run
+     *
+     * @param runId - Run ID to dispose
+     */
+    dispose(runId) {
+        const run = this.#runs.get(runId);
+        if (run) {
+            // First unsubscribe from the realtime adapter
+            this.#realtimeAdapter.unsubscribe(runId);
+            // Then dispose the run
+            run.dispose();
+            // Finally remove from the runs map
+            this.#runs.delete(runId);
+        }
+    }
+    /**
+     * Dispose all flow runs
+     */
+    disposeAll() {
+        for (const runId of this.#runs.keys()) {
+            this.dispose(runId);
+        }
+    }
+    // Delegate IFlowRealtime methods to the adapter
+    /**
+     * Fetch flow definition metadata
+     */
+    async fetchFlowDefinition(flow_slug) {
+        return this.#realtimeAdapter.fetchFlowDefinition(flow_slug);
+    }
+    /**
+     * Register a callback for run events
+     * @returns Function to unsubscribe from the event
+     */
+    onRunEvent(callback) {
+        return this.#realtimeAdapter.onRunEvent(callback);
+    }
+    /**
+     * Register a callback for step events
+     * @returns Function to unsubscribe from the event
+     */
+    onStepEvent(callback) {
+        return this.#realtimeAdapter.onStepEvent(callback);
+    }
+    /**
+     * Subscribe to a flow run's events
+     */
+    async subscribeToRun(run_id) {
+        return await this.#realtimeAdapter.subscribeToRun(run_id);
+    }
+    /**
+     * Fetch current state of a run and its steps
+     */
+    async getRunWithStates(run_id) {
+        return this.#realtimeAdapter.getRunWithStates(run_id);
+    }
+    /**
+     * Get a flow run by ID
+     *
+     * @param run_id - ID of the run to get
+     * @returns Promise that resolves with the FlowRun instance or null if not found
+     */
+    async getRun(run_id) {
+        // Check if we already have this run cached
+        const existingRun = this.#runs.get(run_id);
+        if (existingRun) {
+            return existingRun;
+        }
+        try {
+            // Fetch the run state from the database
+            const { run, steps } = await this.getRunWithStates(run_id);
+            if (!run) {
+                return null;
+            }
+            // Validate required fields
+            if (!run.run_id || !run.flow_slug || !run.status) {
+                throw new Error('Invalid run data: missing required fields');
+            }
+            // Validate status is a valid FlowRunStatus
+            const validStatuses = Object.values(FlowRunStatus);
+            if (!validStatuses.includes(run.status)) {
+                throw new Error(`Invalid run data: invalid status '${run.status}'`);
+            }
+            // Create flow run with minimal initial state
+            const initialState = {
+                run_id: run.run_id,
+                flow_slug: run.flow_slug,
+                status: run.status,
+                input: run.input,
+                output: null,
+                error: null,
+                error_message: null,
+                started_at: null,
+                completed_at: null,
+                failed_at: null,
+                remaining_steps: 0,
+            };
+            // Create the flow run instance
+            const flowRun = new FlowRun(initialState);
+            // Apply the complete state from database snapshot
+            flowRun.applySnapshot(run);
+            // Store the run
+            this.#runs.set(run_id, flowRun);
+            // Set up subscription for run and step events
+            await this.#realtimeAdapter.subscribeToRun(run_id);
+            // Initialize steps from snapshot
+            if (steps && Array.isArray(steps)) {
+                for (const stepState of steps) {
+                    // Validate step has required fields
+                    if (!stepState.step_slug || !stepState.status) {
+                        throw new Error('Invalid step data: missing required fields');
+                    }
+                    // Apply snapshot state directly (no events)
+                    flowRun.step(stepState.step_slug).applySnapshot(stepState);
+                }
+            }
+            return flowRun;
+        }
+        catch (error) {
+            console.error('Error getting run:', error);
+            // Re-throw if it's a validation error
+            if (error instanceof Error && (error.message.includes('Invalid run data') || error.message.includes('Invalid step data'))) {
+                throw error;
+            }
+            return null;
+        }
+    }
+}

package/dist/src/lib/SupabaseBroadcastAdapter.d.ts

@@ -0,0 +1,65 @@
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { FlowRow, StepRow, RunRow, StepStateRow } from '@pgflow/core';
+import type { IFlowRealtime, BroadcastRunEvent, BroadcastStepEvent, Unsubscribe } from './types.js';
+/**
+ * Adapter to handle realtime communication with Supabase
+ */
+export declare class SupabaseBroadcastAdapter implements IFlowRealtime {
+    #private;
+    /**
+     * Creates a new instance of SupabaseBroadcastAdapter
+     *
+     * @param supabase - Supabase client instance
+     */
+    constructor(supabase: SupabaseClient, opts?: {
+        reconnectDelayMs?: number;
+        stabilizationDelayMs?: number;
+        schedule?: typeof setTimeout;
+    });
+    /**
+     * Fetches flow definition metadata from the database
+     *
+     * @param flow_slug - Flow slug to fetch
+     */
+    fetchFlowDefinition(flow_slug: string): Promise<{
+        flow: FlowRow;
+        steps: StepRow[];
+    }>;
+    /**
+     * Registers a callback for run events
+     *
+     * @param callback - Function to call when run events are received
+     * @returns Function to unsubscribe from the event
+     */
+    onRunEvent(callback: (event: BroadcastRunEvent) => void): Unsubscribe;
+    /**
+     * Registers a callback for step events
+     *
+     * @param callback - Function to call when step events are received
+     * @returns Function to unsubscribe from the event
+     */
+    onStepEvent(callback: (event: BroadcastStepEvent) => void): Unsubscribe;
+    /**
+     * Subscribes to a flow run's events
+     *
+     * @param run_id - Run ID to subscribe to
+     * @returns Function to unsubscribe
+     */
+    subscribeToRun(run_id: string): Promise<() => void>;
+    /**
+     * Unsubscribes from a run's events
+     *
+     * @param run_id - Run ID to unsubscribe from
+     */
+    unsubscribe(run_id: string): void;
+    /**
+     * Fetches current state of a run and its steps
+     *
+     * @param run_id - Run ID to fetch
+     */
+    getRunWithStates(run_id: string): Promise<{
+        run: RunRow;
+        steps: StepStateRow[];
+    }>;
+}
+//# sourceMappingURL=SupabaseBroadcastAdapter.d.ts.map

package/dist/src/lib/SupabaseBroadcastAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SupabaseBroadcastAdapter.d.ts","sourceRoot":"","sources":["../../../src/lib/SupabaseBroadcastAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC7E,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE3E,OAAO,KAAK,EACV,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,WAAW,EACZ,MAAM,YAAY,CAAC;AAQpB;;GAEG;AACH,qBAAa,wBAAyB,YAAW,aAAa;;IAS5D;;;;OAIG;gBAED,QAAQ,EAAE,cAAc,EACxB,IAAI,GAAE;QACJ,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,oBAAoB,CAAC,EAAE,MAAM,CAAC;QAC9B,QAAQ,CAAC,EAAE,OAAO,UAAU,CAAC;KACzB;IAmLR;;;;OAIG;IACG,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QACpD,IAAI,EAAE,OAAO,CAAC;QACd,KAAK,EAAE,OAAO,EAAE,CAAC;KAClB,CAAC;IAiCF;;;;;OAKG;IACH,UAAU,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAAG,WAAW;IAYrE;;;;;OAKG;IACH,WAAW,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAAG,WAAW;IAevE;;;;;OAKG;IACG,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC;IAgEzD;;;;OAIG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAIjC;;;;OAIG;IACG,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;QAC9C,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE,YAAY,EAAE,CAAC;KACvB,CAAC;CAiCH"}