@workflow/core 4.0.1-beta.4 → 4.0.1-beta.41

package/dist/runtime/helpers.js

@@ -0,0 +1,264 @@
+import { HealthCheckPayloadSchema } from '@workflow/world';
+import { monotonicFactory } from 'ulid';
+import * as Attribute from '../telemetry/semantic-conventions.js';
+import { getSpanKind, trace } from '../telemetry.js';
+import { getWorld } from './world.js';
+/** Default timeout for health checks in milliseconds */
+const DEFAULT_HEALTH_CHECK_TIMEOUT = 30_000;
+const generateId = monotonicFactory();
+/**
+ * Returns the stream name for a health check with the given correlation ID.
+ */
+function getHealthCheckStreamName(correlationId) {
+    return `__health_check__${correlationId}`;
+}
+/**
+ * Checks if the given message is a health check payload.
+ * If so, returns the parsed payload. Otherwise returns undefined.
+ */
+export function parseHealthCheckPayload(message) {
+    const result = HealthCheckPayloadSchema.safeParse(message);
+    if (result.success) {
+        return result.data;
+    }
+    return undefined;
+}
+/**
+ * Generates a fake runId for health check streams.
+ * This runId passes server validation but is not associated with a real run.
+ * The server skips run validation for streams starting with `__health_check__`.
+ */
+function generateHealthCheckRunId() {
+    return `wrun_${generateId()}`;
+}
+/**
+ * Handles a health check message by writing the result to the world's stream.
+ * The caller can listen to this stream to get the health check response.
+ *
+ * @param healthCheck - The parsed health check payload
+ * @param endpoint - Which endpoint is responding ('workflow' or 'step')
+ */
+export async function handleHealthCheckMessage(healthCheck, endpoint) {
+    const world = getWorld();
+    const streamName = getHealthCheckStreamName(healthCheck.correlationId);
+    const response = JSON.stringify({
+        healthy: true,
+        endpoint,
+        correlationId: healthCheck.correlationId,
+        timestamp: Date.now(),
+    });
+    // Use a fake runId that passes validation.
+    // The stream name includes the correlationId for identification.
+    // The server skips run validation for health check streams.
+    const fakeRunId = generateHealthCheckRunId();
+    await world.writeToStream(streamName, fakeRunId, response);
+    await world.closeStream(streamName, fakeRunId);
+}
+/**
+ * Performs a health check by sending a message through the queue pipeline
+ * and verifying it is processed by the specified endpoint.
+ *
+ * This function bypasses Deployment Protection on Vercel because it goes
+ * through the queue infrastructure rather than direct HTTP.
+ *
+ * @param world - The World instance to use for the health check
+ * @param endpoint - Which endpoint to health check: 'workflow' or 'step'
+ * @param options - Optional configuration for the health check
+ * @returns Promise resolving to health check result
+ */
+// Poll interval for health check retries (ms)
+const HEALTH_CHECK_POLL_INTERVAL = 100;
+// Per-read timeout to prevent blocking forever on local world's EventEmitter
+// (which doesn't work across processes)
+const HEALTH_CHECK_READ_TIMEOUT = 500;
+/**
+ * Read chunks from a stream with a timeout per read operation.
+ * Returns { chunks, timedOut } where timedOut indicates if a read timed out.
+ */
+async function readStreamWithTimeout(reader, readTimeout) {
+    const chunks = [];
+    let done = false;
+    let timedOut = false;
+    while (!done && !timedOut) {
+        const readPromise = reader.read();
+        const timeoutPromise = new Promise((resolve) => setTimeout(() => {
+            timedOut = true;
+            resolve({ done: true, value: undefined });
+        }, readTimeout));
+        const result = await Promise.race([readPromise, timeoutPromise]);
+        done = result.done;
+        if (result.value)
+            chunks.push(result.value);
+    }
+    return { chunks, timedOut };
+}
+/**
+ * Parse and validate a health check response from stream chunks.
+ * Returns the parsed response or null if invalid.
+ */
+function parseHealthCheckResponse(chunks) {
+    if (chunks.length === 0)
+        return null;
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const combined = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        combined.set(chunk, offset);
+        offset += chunk.length;
+    }
+    const responseText = new TextDecoder().decode(combined);
+    let response;
+    try {
+        response = JSON.parse(responseText);
+    }
+    catch {
+        return null;
+    }
+    if (typeof response !== 'object' ||
+        response === null ||
+        !('healthy' in response) ||
+        typeof response.healthy !== 'boolean') {
+        return null;
+    }
+    return { healthy: response.healthy };
+}
+export async function healthCheck(world, endpoint, options) {
+    const timeout = options?.timeout ?? DEFAULT_HEALTH_CHECK_TIMEOUT;
+    const correlationId = `hc_${generateId()}`;
+    const streamName = getHealthCheckStreamName(correlationId);
+    const queueName = endpoint === 'workflow'
+        ? '__wkf_workflow_health_check'
+        : '__wkf_step_health_check';
+    const startTime = Date.now();
+    try {
+        await world.queue(queueName, {
+            __healthCheck: true,
+            correlationId,
+        });
+        while (Date.now() - startTime < timeout) {
+            try {
+                const stream = await world.readFromStream(streamName);
+                const reader = stream.getReader();
+                const { chunks, timedOut } = await readStreamWithTimeout(reader, HEALTH_CHECK_READ_TIMEOUT);
+                if (timedOut) {
+                    try {
+                        reader.cancel();
+                    }
+                    catch {
+                        // Ignore cancel errors
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, HEALTH_CHECK_POLL_INTERVAL));
+                    continue;
+                }
+                const response = parseHealthCheckResponse(chunks);
+                if (response) {
+                    return response;
+                }
+                await new Promise((resolve) => setTimeout(resolve, HEALTH_CHECK_POLL_INTERVAL));
+            }
+            catch {
+                await new Promise((resolve) => setTimeout(resolve, HEALTH_CHECK_POLL_INTERVAL));
+            }
+        }
+        return {
+            healthy: false,
+            error: `Health check timed out after ${timeout}ms`,
+        };
+    }
+    catch (error) {
+        return {
+            healthy: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Loads all workflow run events by iterating through all pages of paginated results.
+ * This ensures that *all* events are loaded into memory before running the workflow.
+ * Events must be in chronological order (ascending) for proper workflow replay.
+ */
+export async function getAllWorkflowRunEvents(runId) {
+    const allEvents = [];
+    let cursor = null;
+    let hasMore = true;
+    const world = getWorld();
+    while (hasMore) {
+        // TODO: we're currently loading all the data with resolveRef behaviour. We need to update this
+        // to lazyload the data from the world instead so that we can optimize and make the event log loading
+        // much faster and memory efficient
+        const response = await world.events.list({
+            runId,
+            pagination: {
+                sortOrder: 'asc', // Required: events must be in chronological order for replay
+                cursor: cursor ?? undefined,
+            },
+        });
+        allEvents.push(...response.data);
+        hasMore = response.hasMore;
+        cursor = response.cursor;
+    }
+    return allEvents;
+}
+/**
+ * CORS headers for health check responses.
+ * Allows the observability UI to check endpoint health from a different origin.
+ */
+const HEALTH_CHECK_CORS_HEADERS = {
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'POST, OPTIONS, GET, HEAD',
+    'Access-Control-Allow-Headers': 'Content-Type',
+};
+/**
+ * Wraps a request/response handler and adds a health check "mode"
+ * based on the presence of a `__health` query parameter.
+ */
+export function withHealthCheck(handler) {
+    return async (req) => {
+        const url = new URL(req.url);
+        const isHealthCheck = url.searchParams.has('__health');
+        if (isHealthCheck) {
+            // Handle CORS preflight for health check
+            if (req.method === 'OPTIONS') {
+                return new Response(null, {
+                    status: 204,
+                    headers: HEALTH_CHECK_CORS_HEADERS,
+                });
+            }
+            return new Response(`Workflow DevKit "${url.pathname}" endpoint is healthy`, {
+                status: 200,
+                headers: {
+                    'Content-Type': 'text/plain',
+                    ...HEALTH_CHECK_CORS_HEADERS,
+                },
+            });
+        }
+        return await handler(req);
+    };
+}
+/**
+ * Queues a message to the specified queue with tracing.
+ */
+export async function queueMessage(world, ...args) {
+    const queueName = args[0];
+    await trace('queueMessage', {
+        attributes: Attribute.QueueName(queueName),
+        kind: await getSpanKind('PRODUCER'),
+    }, async (span) => {
+        const { messageId } = await world.queue(...args);
+        span?.setAttributes(Attribute.QueueMessageId(messageId));
+    });
+}
+/**
+ * Calculates the queue overhead time in milliseconds for a given message.
+ */
+export function getQueueOverhead(message) {
+    if (!message.requestedAt)
+        return;
+    try {
+        return Attribute.QueueOverheadMs(Date.now() - message.requestedAt.getTime());
+    }
+    catch {
+        return;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/runtime/helpers.ts"],"names":[],"mappings":"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"}

package/dist/runtime/resume-hook.d.ts

@@ -13,9 +13,10 @@ export declare function getHookByToken(token: string): Promise<Hook>;
  * This function is called externally (e.g., from an API route or server action)
  * to send data to a hook and resume the associated workflow run.
  *
- * @param token - The unique token identifying the hook
+ * @param tokenOrHook - The unique token identifying the hook, or the hook object itself
  * @param payload - The data payload to send to the hook
- * @returns Promise resolving to an object with the runId, or null if the hook doesn't exist
+ * @returns Promise resolving to the hook
+ * @throws Error if the hook is not found or if there's an error during the process
  *
  * @example
  *
@@ -25,17 +26,17 @@ export declare function getHookByToken(token: string): Promise<Hook>;
  *
  * export async function POST(request: Request) {
  *   const { token, data } = await request.json();
- *   const result = await resumeHook(token, data);
  *
- *   if (!result) {
+ *   try {
+ *     const hook = await resumeHook(token, data);
+ *     return Response.json({ runId: hook.runId });
+ *   } catch (error) {
  *     return new Response('Hook not found', { status: 404 });
  *   }
- *
- *   return Response.json({ runId: result.runId });
  * }
  * ```
  */
-export declare function resumeHook<T = any>(token: string, payload: T): Promise<Hook | null>;
+export declare function resumeHook<T = any>(tokenOrHook: string | Hook, payload: T): Promise<Hook>;
 /**
  * Resumes a webhook by sending a {@link https://developer.mozilla.org/en-US/docs/Web/API/Request | Request}
  * object to a hook identified by its token.
@@ -45,7 +46,8 @@ export declare function resumeHook<T = any>(token: string, payload: T): Promise<
  *
  * @param token - The unique token identifying the hook
  * @param request - The request to send to the hook
- * @returns Promise resolving to the response, or null if the hook doesn't exist
+ * @returns Promise resolving to the response
+ * @throws Error if the hook is not found or if there's an error during the process
  *
  * @example
  *
@@ -61,9 +63,12 @@ export declare function resumeHook<T = any>(token: string, payload: T): Promise<
  *     return new Response('Missing token', { status: 400 });
  *   }
  *
- *   const response = await resumeWebhook(token, request);
- *
- *   return response ?? new Response('Webhook not found', { status: 404 });
+ *   try {
+ *     const response = await resumeWebhook(token, request);
+ *     return response;
+ *   } catch (error) {
+ *     return new Response('Webhook not found', { status: 404 });
+ *   }
  * }
  * ```
  */

package/dist/runtime/resume-hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resume-hook.d.ts","sourceRoot":"","sources":["../../src/runtime/resume-hook.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAW5C;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAOjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,UAAU,CAAC,CAAC,GAAG,GAAG,EACtC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,CAAC,GACT,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAuEtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,QAAQ,CAAC,CAkDnB"}
+{"version":3,"file":"resume-hook.d.ts","sourceRoot":"","sources":["../../src/runtime/resume-hook.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAyB,MAAM,iBAAiB,CAAC;AAWnE;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAOjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,UAAU,CAAC,CAAC,GAAG,GAAG,EACtC,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,OAAO,EAAE,CAAC,GACT,OAAO,CAAC,IAAI,CAAC,CAkFf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,QAAQ,CAAC,CAkDnB"}

package/dist/runtime/resume-hook.js

@@ -4,6 +4,7 @@ import { dehydrateStepReturnValue, hydrateStepArguments, } from '../serializatio
 import { WEBHOOK_RESPONSE_WRITABLE } from '../symbols.js';
 import * as Attribute from '../telemetry/semantic-conventions.js';
 import { getSpanContextForTraceCarrier, trace } from '../telemetry.js';
+import { waitedUntil } from '../util.js';
 import { getWorld } from './world.js';
 /**
  * Get the hook by token to find the associated workflow run,
@@ -16,7 +17,7 @@ export async function getHookByToken(token) {
     const world = getWorld();
     const hook = await world.hooks.getByToken(token);
     if (typeof hook.metadata !== 'undefined') {
-        hook.metadata = hydrateStepArguments(hook.metadata, [], globalThis);
+        hook.metadata = hydrateStepArguments(hook.metadata, [], hook.runId);
     }
     return hook;
 }
@@ -26,9 +27,10 @@ export async function getHookByToken(token) {
  * This function is called externally (e.g., from an API route or server action)
  * to send data to a hook and resume the associated workflow run.
  *
- * @param token - The unique token identifying the hook
+ * @param tokenOrHook - The unique token identifying the hook, or the hook object itself
  * @param payload - The data payload to send to the hook
- * @returns Promise resolving to an object with the runId, or null if the hook doesn't exist
+ * @returns Promise resolving to the hook
+ * @throws Error if the hook is not found or if there's an error during the process
  *
  * @example
  *
@@ -38,69 +40,75 @@ export async function getHookByToken(token) {
  *
  * export async function POST(request: Request) {
  *   const { token, data } = await request.json();
- *   const result = await resumeHook(token, data);
  *
- *   if (!result) {
+ *   try {
+ *     const hook = await resumeHook(token, data);
+ *     return Response.json({ runId: hook.runId });
+ *   } catch (error) {
  *     return new Response('Hook not found', { status: 404 });
  *   }
- *
- *   return Response.json({ runId: result.runId });
  * }
  * ```
  */
-export async function resumeHook(token, payload) {
-    return trace('HOOK.resume', async (span) => {
-        const world = getWorld();
-        try {
-            const hook = await getHookByToken(token);
-            span?.setAttributes({
-                ...Attribute.HookToken(token),
-                ...Attribute.HookId(hook.hookId),
-                ...Attribute.WorkflowRunId(hook.runId),
-            });
-            // Dehydrate the payload for storage
-            const ops = [];
-            const dehydratedPayload = dehydrateStepReturnValue(payload, ops, globalThis);
-            waitUntil(Promise.all(ops));
-            // Create a hook_received event with the payload
-            await world.events.create(hook.runId, {
-                eventType: 'hook_received',
-                correlationId: hook.hookId,
-                eventData: {
-                    payload: dehydratedPayload,
-                },
-            });
-            const workflowRun = await world.runs.get(hook.runId);
-            span?.setAttributes({
-                ...Attribute.WorkflowName(workflowRun.workflowName),
-            });
-            const traceCarrier = workflowRun.executionContext?.traceCarrier;
-            if (traceCarrier) {
-                const context = await getSpanContextForTraceCarrier(traceCarrier);
-                if (context) {
-                    span?.addLink?.({ context });
+export async function resumeHook(tokenOrHook, payload) {
+    return await waitedUntil(() => {
+        return trace('HOOK.resume', async (span) => {
+            const world = getWorld();
+            try {
+                const hook = typeof tokenOrHook === 'string'
+                    ? await getHookByToken(tokenOrHook)
+                    : tokenOrHook;
+                span?.setAttributes({
+                    ...Attribute.HookToken(hook.token),
+                    ...Attribute.HookId(hook.hookId),
+                    ...Attribute.WorkflowRunId(hook.runId),
+                });
+                // Dehydrate the payload for storage
+                const ops = [];
+                const dehydratedPayload = dehydrateStepReturnValue(payload, ops, hook.runId);
+                // NOTE: Workaround instead of injecting catching undefined unhandled rejections in webhook bundle
+                waitUntil(Promise.all(ops).catch((err) => {
+                    if (err !== undefined)
+                        throw err;
+                }));
+                // Create a hook_received event with the payload
+                await world.events.create(hook.runId, {
+                    eventType: 'hook_received',
+                    correlationId: hook.hookId,
+                    eventData: {
+                        payload: dehydratedPayload,
+                    },
+                });
+                const workflowRun = await world.runs.get(hook.runId);
+                span?.setAttributes({
+                    ...Attribute.WorkflowName(workflowRun.workflowName),
+                });
+                const traceCarrier = workflowRun.executionContext?.traceCarrier;
+                if (traceCarrier) {
+                    const context = await getSpanContextForTraceCarrier(traceCarrier);
+                    if (context) {
+                        span?.addLink?.({ context });
+                    }
                 }
+                // Re-trigger the workflow against the deployment ID associated
+                // with the workflow run that the hook belongs to
+                await world.queue(`__wkf_workflow_${workflowRun.workflowName}`, {
+                    runId: hook.runId,
+                    // attach the trace carrier from the workflow run
+                    traceCarrier: workflowRun.executionContext?.traceCarrier ?? undefined,
+                }, {
+                    deploymentId: workflowRun.deploymentId,
+                });
+                return hook;
             }
-            // Re-trigger the workflow against the deployment ID associated
-            // with the workflow run that the hook belongs to
-            await world.queue(`__wkf_workflow_${workflowRun.workflowName}`, {
-                runId: hook.runId,
-                // attach the trace carrier from the workflow run
-                traceCarrier: workflowRun.executionContext?.traceCarrier ?? undefined,
-            }, {
-                deploymentId: workflowRun.deploymentId,
-            });
-            return hook;
-        }
-        catch (_err) {
-            // If hook not found, return null
-            span?.setAttributes({
-                ...Attribute.HookToken(token),
-                ...Attribute.HookFound(false),
-            });
-            // TODO: Check for specific error types
-            return null;
-        }
+            catch (err) {
+                span?.setAttributes({
+                    ...Attribute.HookToken(typeof tokenOrHook === 'string' ? tokenOrHook : tokenOrHook.token),
+                    ...Attribute.HookFound(false),
+                });
+                throw err;
+            }
+        });
     });
 }
 /**
@@ -112,7 +120,8 @@ export async function resumeHook(token, payload) {
  *
  * @param token - The unique token identifying the hook
  * @param request - The request to send to the hook
- * @returns Promise resolving to the response, or null if the hook doesn't exist
+ * @returns Promise resolving to the response
+ * @throws Error if the hook is not found or if there's an error during the process
  *
  * @example
  *
@@ -128,9 +137,12 @@ export async function resumeHook(token, payload) {
  *     return new Response('Missing token', { status: 400 });
  *   }
  *
- *   const response = await resumeWebhook(token, request);
- *
- *   return response ?? new Response('Webhook not found', { status: 404 });
+ *   try {
+ *     const response = await resumeWebhook(token, request);
+ *     return response;
+ *   } catch (error) {
+ *     return new Response('Webhook not found', { status: 404 });
+ *   }
  * }
  * ```
  */
@@ -159,7 +171,7 @@ export async function resumeWebhook(token, request) {
         // No `respondWith` value implies the default behavior of returning a 202
         response = new Response(null, { status: 202 });
     }
-    await resumeHook(hook.token, request);
+    await resumeHook(hook, request);
     if (responseReadable) {
         // Wait for the readable stream to emit one chunk,
         // which is the `Response` object
@@ -177,4 +189,4 @@ export async function resumeWebhook(token, request) {
     }
     return response;
 }
-//# sourceMappingURL=resume-hook.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runtime/start.d.ts

@@ -1,9 +1,19 @@
+import type { World } from '@workflow/world';
 import { Run } from '../runtime.js';
 export interface StartOptions {
     /**
      * The deployment ID to use for the workflow run.
+     *
+     * @deprecated This property should not be set in user code under normal circumstances.
+     * It is automatically inferred from environment variables when deploying to Vercel.
+     * Only set this if you are doing something advanced and know what you are doing.
      */
     deploymentId?: string;
+    /**
+     * The world to use for the workflow run creation,
+     * by default the world is inferred from the environment variables.
+     */
+    world?: World;
 }
 /**
  * Represents an imported workflow function.

package/dist/runtime/start.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../src/runtime/start.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAOpC,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,IAAI,CAC/D,GAAG,IAAI,EAAE,KAAK,KACX,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtB;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtD;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EACpD,QAAQ,EAAE,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC7D,IAAI,EAAE,KAAK,EACX,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AAEzB,wBAAgB,KAAK,CAAC,OAAO,EAC3B,QAAQ,EAAE,gBAAgB,CAAC,EAAE,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC1D,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC"}
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../src/runtime/start.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAyB,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACpE,OAAO,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAQpC,MAAM,WAAW,YAAY;IAC3B;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,IAAI,CAC/D,GAAG,IAAI,EAAE,KAAK,KACX,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtB;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtD;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EACpD,QAAQ,EAAE,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC7D,IAAI,EAAE,KAAK,EACX,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AAEzB,wBAAgB,KAAK,CAAC,OAAO,EAC3B,QAAQ,EAAE,gBAAgB,CAAC,EAAE,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC1D,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC"}