target-supabase-sdk 0.1.9 → 0.2.0

package/src/task/task-repo-validation.ts

@@ -0,0 +1,171 @@
+import { RepoManager, type RepoContextFailureReason } from "../repo/repo-manager";
+import { LoggerWithScope } from "../shared/log";
+import { bootstrapLocalTasks, type BootstrapLocalTasksOptions } from "./local-task-registry";
+import { ResultCode } from "./task.interface";
+import type { TaskRepoContext } from "./task-repo-context";
+
+export type TaskRepoValidationFailureReason =
+    | "MISSING_PARAMS"
+    | RepoContextFailureReason
+    | "PARAMS_VALIDATION_FAILED"
+    | "TASK_TYPE_KEY_MISMATCH";
+
+export type ValidateTaskRepoAndParamsInput = {
+    logger: LoggerWithScope;
+    taskTypeKey: string;
+    params: unknown;
+    /**
+     * When true, run {@link bootstrapLocalTasks} before resolve (CLI / Trigger / postTask).
+     * Worker paths should omit — {@link TaskManager.registerTasks} already bootstrapped.
+     */
+    bootstrapLocal?: boolean;
+    bootstrapLocalOptions?: BootstrapLocalTasksOptions;
+    /**
+     * When false, do not fetch Repo from Supabase if the task type is not locally registered.
+     * Default `true`. Align with {@link RegisterTasksOptions.includeRemote}.
+     */
+    includeRemote?: boolean;
+};
+
+export type ValidateTaskRepoAndParamsFailure = {
+    isValid: false;
+    code: ResultCode;
+    message: string;
+    reason: TaskRepoValidationFailureReason;
+    step: string;
+};
+
+export type ValidateTaskRepoAndParamsSuccess = {
+    isValid: true;
+    repoContext: TaskRepoContext;
+};
+
+export type ValidateTaskRepoAndParamsResult =
+    | ValidateTaskRepoAndParamsFailure
+    | ValidateTaskRepoAndParamsSuccess;
+
+function validateTaskParams(
+    validator: TaskRepoContext["taskParamsValidator"],
+    taskParams: unknown,
+    logger: LoggerWithScope
+): boolean {
+    try {
+        return validator(taskParams) === true;
+    } catch (error) {
+        logger.warn("taskParamsValidator 拋出異常", {
+            topic: "task",
+            data: { error: error instanceof Error ? error.message : error },
+        });
+        return false;
+    }
+}
+
+function invalid(params: {
+    reason: TaskRepoValidationFailureReason;
+    code: ResultCode;
+    message: string;
+    step: string;
+}): ValidateTaskRepoAndParamsFailure {
+    return { isValid: false, ...params };
+}
+
+/**
+ * Resolve task Repo context and validate `params` via `taskParamsValidator`.
+ *
+ * Repo resolution uses {@link RepoManager.getRepoContext}:
+ * local registry first; when no local entry and `includeRemote`, loads from Supabase.
+ */
+async function validateTaskRepoAndParams({
+    logger,
+    taskTypeKey,
+    params,
+    bootstrapLocal = false,
+    bootstrapLocalOptions,
+    includeRemote = true,
+}: ValidateTaskRepoAndParamsInput): Promise<ValidateTaskRepoAndParamsResult> {
+    if (params == null) {
+        return invalid({
+            reason: "MISSING_PARAMS",
+            code: ResultCode.PARAMS_NOT_VALID,
+            message: "任務缺少 params",
+            step: "params",
+        });
+    }
+
+    if (bootstrapLocal) {
+        const bootstrap = await bootstrapLocalTasks({
+            ...bootstrapLocalOptions,
+            forTaskTypeKey: taskTypeKey,
+        });
+        logger.debug("本地任務 bootstrap 完成", {
+            topic: "task",
+            data: {
+                taskTypeKey,
+                step: "local_bootstrap",
+                status: bootstrap.status,
+                registered: bootstrap.registered,
+                cached: bootstrap.cached ?? false,
+                message: bootstrap.message,
+            },
+        });
+    }
+
+    logger.debug("開始解析 Repo 上下文", {
+        topic: "task",
+        data: { taskTypeKey, step: "repo_load", includeRemote },
+    });
+
+    const {
+        context: repoContext,
+        error: repoError,
+        failureReason,
+        resolvedVia,
+    } = await RepoManager.getRepoContext<TaskRepoContext>({
+        logger,
+        taskTypeKey,
+        includeRemote,
+    });
+
+    if (repoContext == null) {
+        return invalid({
+            reason: failureReason ?? "REMOTE_REPO_LOAD_FAILED",
+            code: ResultCode.REPO_NOT_VALID,
+            message: repoError ?? "無法加載 Repo 上下文",
+            step: "repo_load",
+        });
+    }
+
+    logger.debug("Repo 上下文解析完成", {
+        topic: "task",
+        data: { taskTypeKey, step: "repo_load", resolvedVia },
+    });
+
+    if (repoContext.taskFn.taskTypeKey !== taskTypeKey) {
+        return invalid({
+            reason: "TASK_TYPE_KEY_MISMATCH",
+            code: ResultCode.REPO_NOT_VALID,
+            message: `taskFn.taskTypeKey (${repoContext.taskFn.taskTypeKey}) 與 task.value (${taskTypeKey}) 不一致`,
+            step: "task_type_key",
+        });
+    }
+
+    logger.debug("開始校驗任務參數", { topic: "task", data: { taskTypeKey, step: "params_validation" } });
+    if (!validateTaskParams(repoContext.taskParamsValidator, params, logger)) {
+        return invalid({
+            reason: "PARAMS_VALIDATION_FAILED",
+            code: ResultCode.PARAMS_NOT_VALID,
+            message: "任務參數校驗失敗",
+            step: "params_validation",
+        });
+    }
+
+    logger.debug("任務參數校驗通過", { topic: "task", data: { taskTypeKey, step: "params_validation" } });
+
+    return { isValid: true, repoContext };
+}
+
+const TaskRepoValidation = {
+    validate: validateTaskRepoAndParams,
+};
+
+export { TaskRepoValidation, validateTaskRepoAndParams };

package/src/task/task.api.ts

@@ -1,6 +1,6 @@
 import { createTarget, getPossibleTarget, QueryFilter, updateTargetDetails, validateWithSchema, isOptimisticLockError, OPTIMISTIC_LOCK_FAILED_MESSAGE } from "../core.api";
 import { generateResponse, type SupabaseResponse } from "../core.interface";
-import { createApiLogger, type LoggerWithContext } from "../shared/log/log-manager";
+import { createApiLogger, logManager, type LoggerWithScope } from "../shared/log";
 import { z } from "zod";
 import { CategoryTask, ResultCode, Task, TaskDetails, TaskStatus, TaskStatusAction } from "./task.interface";
 
@@ -44,8 +44,9 @@ const TASK_NODE_ID_FIELD = "details->>nodeId" as const;
 
 const taskIdSchema = z.string().trim().min(1);
 const nodeIdSchema = z.string().trim().min(1);
-/** Optional — orchestrator (e.g. NodeManager loop) passes its trace to correlate logs. */
+/** Optional — orchestrator (e.g. TaskNode loop) passes its trace to correlate logs. */
 const traceIdSchema = z.string().trim().min(1).optional();
+const traceParentIdSchema = z.string().trim().min(1).nullable().optional();
 
 const patchChangeTaskStatusBaseSchema = {
     id: taskIdSchema,
@@ -107,25 +108,6 @@ export const patchClaimTaskSchema = z.object({
 
 export type PatchClaimTaskPayload = z.infer<typeof patchClaimTaskSchema>;
 
-/** Initial status for a new task — OPEN (draft) or TODO (claimable by workers). */
-const postTaskInitialStatusSchema = z
-    .union([z.literal(TaskStatus.OPEN), z.literal(TaskStatus.TODO)])
-    .optional()
-    .default(TaskStatus.TODO);
-
-export const postTaskSchema = z.object({
-    name: z.string().trim().min(1),
-    /** Task type key — matches `task.value`, {@link patchClaimTask}, {@link Repo.value}, and local Repo registry. */
-    value: z.string().trim().min(1),
-    params: z.unknown(),
-    taskStatus: postTaskInitialStatusSchema,
-    tagList: z.array(z.string()).optional().default([]),
-    extra: z.string().optional(),
-    traceId: traceIdSchema,
-});
-
-export type PostTaskPayload = z.infer<typeof postTaskSchema>;
-
 // ─── Optimistic lock helpers ─────────────────────────────────────────────────
 
 function lockOnStatus(...allowed: TaskStatus[]): QueryFilter[] {
@@ -178,20 +160,20 @@ async function transitionTask({
 }
 
 function logTaskTransition(
-    logger: LoggerWithContext,
+    logger: LoggerWithScope,
     action: TaskStatusAction | "patchTaskProgress" | "patchClaimTask",
     task: Task,
-    context?: Record<string, unknown>
+    data?: Record<string, unknown>
 ): void {
     logger.info("任务状态迁移成功", {
         topic: "task",
-        context: {
+        data: {
             action,
             taskId: task.id,
             taskValue: task.value,
             status: task.details.status,
             nodeId: task.details.nodeId,
-            ...context,
+            ...data,
         },
     });
 }
@@ -314,7 +296,9 @@ export const patchChangeTaskStatus = validateWithSchema(
         }
         default: {
             const _exhaustive: never = action;
-            throw new Error(`[patchChangeTaskStatus] Unknown action: ${_exhaustive}`);
+            const message = `[patchChangeTaskStatus] Unknown action: ${String(_exhaustive)}`;
+            logger.error(message, { topic: "task", data: { action: String(_exhaustive) } });
+            return generateResponse.error(message);
         }
     }
 });
@@ -326,7 +310,7 @@ export const patchTaskProgress = validateWithSchema(
     patchTaskProgressSchema,
     "patchTaskProgressSchema"
 )(async ({ id, progress, nodeId, traceId }) => {
-    const logger = createApiLogger("patchTaskProgress", { traceId, nodeId });
+    const logger = createApiLogger("patchTaskProgress", { traceId, labels: { nodeId } });
     const data = await transitionTask({
         id,
         optimisticLockFilterList: lockOnDoingOwner(nodeId),
@@ -354,7 +338,7 @@ export const patchClaimTask = validateWithSchema(
     patchClaimTaskSchema,
     "patchClaimTaskSchema"
 )(async ({ nodeId, availableTaskList, traceId }): Promise<SupabaseResponse<Task | null>> => {
-    const logger = createApiLogger("patchClaimTask", { traceId, nodeId });
+    const logger = createApiLogger("patchClaimTask", { traceId, labels: { nodeId } });
 
     try {
         const { data: possibleTask } = await getPossibleTarget({
@@ -379,51 +363,7 @@ export const patchClaimTask = validateWithSchema(
             return generateResponse.error(OPTIMISTIC_LOCK_FAILED_MESSAGE, undefined, "OPTIMISTIC_LOCK") as SupabaseResponse<Task | null>;
         }
         const message = error instanceof Error ? error.message : String(error);
-        logger.error("認領任務失敗", { topic: "task", context: { error: message } });
+        logger.error("認領任務失敗", { topic: "task", data: { error: message } });
         return generateResponse.error(message) as SupabaseResponse<Task | null>;
     }
 });
-
-// ─── postTask ────────────────────────────────────────────────────────────────
-
-/**
- * Create a task row (scheduler / admin).
- *
- * `taskStatus` defaults to **TODO** (worker-claimable). Pass **OPEN** for draft tasks
- * that require {@link patchChangeTaskStatus} `publish` before workers can claim.
- */
-export const postTask = validateWithSchema(
-    postTaskSchema,
-    "postTaskSchema"
-)(async ({ name, value, params, taskStatus, tagList, extra, traceId }) => {
-    const logger = createApiLogger("postTask", { traceId });
-
-    const result = await createTarget<Task, PostTaskPayload>({
-        payload: { name, value, params, taskStatus, tagList, extra, traceId },
-        createFn: () => ({
-            name,
-            value,
-            category: CategoryTask.TASK,
-            tagList,
-            extra,
-            details: {
-                manifestVersion: 0,
-                status: taskStatus,
-                params,
-                progress: 0,
-                nodeId: null,
-            },
-        }),
-    });
-
-    logger.info("任務已創建", {
-        topic: "task",
-        context: {
-            taskId: result.data?.id,
-            taskTypeKey: value,
-            status: taskStatus,
-        },
-    });
-
-    return result;
-});

package/src/task/task.interface.ts

@@ -53,6 +53,8 @@ export interface TaskDetails {
     /** [0,100] */
     progress: number;
     nodeId: null | string;
+    /** Task lifecycle correlation id (written at postTask). */
+    traceId?: string;
     result?: {
         cost: number;
         code: ResultCode;

package/src/trigger/trigger.api.ts

@@ -0,0 +1,166 @@
+import { createTarget, scanTargetList, updateTargetDetails, validateWithSchema } from "../core.api";
+import { generateResponse, type SupabaseResponse } from "../core.interface";
+import { TaskStatus } from "../task/task.interface";
+import { createApiLogger } from "../shared/log";
+import { z } from "zod";
+import {
+    CategoryTrigger,
+    Trigger,
+    TriggerStatus,
+    type TriggerAction,
+    type TriggerSchedule,
+} from "./trigger.interface";
+
+const TRIGGER_STATUS_FIELD = "details->>status" as const;
+
+const traceIdSchema = z.string().trim().min(1).optional();
+
+const dailyScheduleSchema = z.object({
+    kind: z.literal("daily"),
+    hour: z.number().int().min(0).max(23),
+    minute: z.number().int().min(0).max(59),
+});
+
+const postTaskActionSchema = z.object({
+    kind: z.literal("post_task"),
+    taskTypeKey: z.string().trim().min(1),
+    taskParams: z.unknown(),
+    taskName: z.string().trim().min(1).optional(),
+    taskStatus: z.enum([TaskStatus.OPEN, TaskStatus.TODO]).optional(),
+});
+
+export const postTriggerSchema = z.object({
+    name: z.string().trim().min(1),
+    value: z.string().trim().min(1),
+    status: z.nativeEnum(TriggerStatus).optional().default(TriggerStatus.ENABLED),
+    schedule: dailyScheduleSchema,
+    action: postTaskActionSchema,
+    tagList: z.array(z.string()).optional().default([]),
+    traceId: traceIdSchema,
+});
+
+export type PostTriggerPayload = z.infer<typeof postTriggerSchema>;
+
+export const scanEnabledTriggersSchema = z.object({
+    traceId: traceIdSchema,
+});
+
+export type ScanEnabledTriggersPayload = z.infer<typeof scanEnabledTriggersSchema>;
+
+export const patchTriggerFiredSchema = z.object({
+    triggerId: z.string().trim().min(1),
+    fireKey: z.string().trim().min(1),
+    expectedLastFireKey: z.string().nullable().optional(),
+    traceId: traceIdSchema,
+});
+
+export type PatchTriggerFiredPayload = z.infer<typeof patchTriggerFiredSchema>;
+
+function enabledTriggerFilter() {
+    return [{ field: TRIGGER_STATUS_FIELD, operator: "eq" as const, value: TriggerStatus.ENABLED }];
+}
+
+/** List all ENABLED triggers (Phase 1: in-memory due check). */
+export const scanEnabledTriggers = validateWithSchema(
+    scanEnabledTriggersSchema,
+    "scanEnabledTriggersSchema"
+)(async ({ traceId }) => {
+    const logger = createApiLogger("scanEnabledTriggers", { traceId });
+
+    try {
+        const { data: triggerList } = await scanTargetList<Trigger>({
+            category: CategoryTrigger.TRIGGER,
+            filterList: enabledTriggerFilter(),
+            orderBy: { field: "created_at", ascending: true },
+        });
+
+        const rows = triggerList ?? [];
+        logger.info("已掃描 ENABLED Trigger", {
+            topic: "trigger",
+            data: { count: rows.length },
+        });
+
+        return generateResponse.success(rows);
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return generateResponse.error(message) as SupabaseResponse<Trigger[]>;
+    }
+});
+
+/** Create a trigger row (scheduler / admin). */
+export const postTrigger = validateWithSchema(
+    postTriggerSchema,
+    "postTriggerSchema"
+)(async ({ name, value, status, schedule, action, tagList, traceId }) => {
+    const logger = createApiLogger("postTrigger", { traceId });
+
+    const details = {
+        manifestVersion: 0,
+        status,
+        schedule: schedule as TriggerSchedule,
+        action: action as TriggerAction,
+        lastFiredAt: null,
+        lastFireKey: null,
+    };
+
+    const result = await createTarget<Trigger, PostTriggerPayload>({
+        payload: { name, value, status, schedule, action, tagList, traceId },
+        createFn: () => ({
+            name,
+            value,
+            category: CategoryTrigger.TRIGGER,
+            tagList,
+            details,
+        }),
+    });
+
+    logger.info("Trigger 已創建", {
+        topic: "trigger",
+        data: { triggerId: result.data?.id, triggerKey: value, status },
+    });
+
+    return result;
+});
+
+/**
+ * Mark trigger as fired for `fireKey`.
+ * When `expectedLastFireKey` is set, uses optimistic lock on that field.
+ */
+export const patchTriggerFired = validateWithSchema(
+    patchTriggerFiredSchema,
+    "patchTriggerFiredSchema"
+)(async ({ triggerId, fireKey, expectedLastFireKey, traceId }) => {
+    const logger = createApiLogger("patchTriggerFired", { traceId });
+    const now = Date.now();
+
+    try {
+        const optimisticLockFilterList =
+            expectedLastFireKey != null && expectedLastFireKey !== ""
+                ? [{ field: "details->>lastFireKey" as const, operator: "eq" as const, value: expectedLastFireKey }]
+                : [];
+
+        const data = await updateTargetDetails<Trigger, Trigger["details"]>({
+            id: triggerId,
+            optimisticLockFilterList,
+            updateFn: (current) => ({
+                ...current,
+                lastFireKey: fireKey,
+                lastFiredAt: now,
+            }),
+        });
+
+        logger.success("Trigger 觸發記錄已更新", {
+            topic: "trigger",
+            data: { triggerId, fireKey },
+        });
+
+        return generateResponse.success(data);
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.warn("Trigger 觸發記錄更新失敗", {
+            topic: "trigger",
+            data: { triggerId, fireKey, error: message },
+        });
+        return generateResponse.error(message);
+    }
+});

package/src/trigger/trigger.interface.ts

@@ -0,0 +1,50 @@
+import { Target } from "../core.interface";
+import { TaskStatus } from "../task/task.interface";
+
+export enum CategoryTrigger {
+    TRIGGER = "trigger",
+}
+
+export enum TriggerStatus {
+    ENABLED = "ENABLED",
+    DISABLED = "DISABLED",
+    PAUSED = "PAUSED",
+}
+
+/** Phase 1: daily fire at `hour`:`minute` UTC. */
+export interface TriggerDailySchedule {
+    kind: "daily";
+    hour: number;
+    minute: number;
+}
+
+export type TriggerSchedule = TriggerDailySchedule;
+
+export interface TriggerPostTaskAction {
+    kind: "post_task";
+    taskTypeKey: string;
+    taskParams: unknown;
+    taskName?: string;
+    taskStatus?: TaskStatus.OPEN | TaskStatus.TODO;
+}
+
+export type TriggerAction = TriggerPostTaskAction;
+
+export interface Trigger extends Target {
+    /** Human readable */
+    name: string;
+    /** Unique trigger key */
+    value: string;
+    details: TriggerDetails;
+    category: CategoryTrigger;
+}
+
+export interface TriggerDetails {
+    manifestVersion: number;
+    status: TriggerStatus;
+    schedule: TriggerSchedule;
+    action: TriggerAction;
+    lastFiredAt?: number | null;
+    /** Idempotency key for the last successful fire, e.g. `daily:2026-06-18` (UTC date). */
+    lastFireKey?: string | null;
+}

package/src/trigger/trigger.utils.ts

@@ -0,0 +1,56 @@
+import type { Trigger, TriggerDailySchedule } from "./trigger.interface";
+
+interface UtcDateParts {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+}
+
+function parseUtcDateParts(now: Date): UtcDateParts {
+    return {
+        year: now.getUTCFullYear(),
+        month: now.getUTCMonth() + 1,
+        day: now.getUTCDate(),
+        hour: now.getUTCHours(),
+        minute: now.getUTCMinutes(),
+    };
+}
+
+export function buildDailyFireKey(_schedule: TriggerDailySchedule, now: Date): string {
+    const { year, month, day } = parseUtcDateParts(now);
+    const yyyy = String(year).padStart(4, "0");
+    const mm = String(month).padStart(2, "0");
+    const dd = String(day).padStart(2, "0");
+    return `daily:${yyyy}-${mm}-${dd}`;
+}
+
+export function isDailyScheduleDue(
+    schedule: TriggerDailySchedule,
+    now: Date,
+    lastFireKey: string | null | undefined
+): boolean {
+    const parts = parseUtcDateParts(now);
+    if (parts.hour !== schedule.hour || parts.minute !== schedule.minute) {
+        return false;
+    }
+    const fireKey = buildDailyFireKey(schedule, now);
+    return lastFireKey !== fireKey;
+}
+
+export function isTriggerDue(trigger: Trigger, now: Date = new Date()): boolean {
+    const { schedule, lastFireKey } = trigger.details;
+    if (schedule.kind !== "daily") {
+        throw new Error(`Unsupported trigger schedule kind: ${String((schedule as { kind?: string }).kind)}`);
+    }
+    return isDailyScheduleDue(schedule, now, lastFireKey);
+}
+
+export function buildFireKey(trigger: Trigger, now: Date = new Date()): string {
+    const { schedule } = trigger.details;
+    if (schedule.kind !== "daily") {
+        throw new Error(`Unsupported trigger schedule kind: ${String((schedule as { kind?: string }).kind)}`);
+    }
+    return buildDailyFireKey(schedule, now);
+}

package/dist/node/node-manager.d.ts

@@ -1,48 +0,0 @@
-import { CommandType } from "../command/command.interface";
-import { NodeLoopContext } from "./node.interface";
-declare class NodeManager {
-    private static readonly HEARTBEAT_FAILURE_THRESHOLD;
-    private _localNodeId;
-    private _isNodeIdLocked;
-    private _availableTaskList;
-    private isRunning;
-    private loopCount;
-    private consecutiveHeartbeatFailures;
-    /** 進程生命週期 traceId — bootstrap / register / shutdown 共用 */
-    private readonly startupTraceId;
-    /** 進行中的 shutdown；並發/重複調用復用同一 Promise。 */
-    private shutdownPromise;
-    /** start() 冪等：重複調用復用同一 Promise。 */
-    private startPromise;
-    get availableTaskList(): readonly string[];
-    get localNodeId(): string | null;
-    set localNodeId(value: string);
-    constructor();
-    private getLogNodeId;
-    private isShuttingDown;
-    /** Fire-and-forget：供信號/致命路徑調用；shutdown Promise 內部吞掉 rejection，避免 unhandledRejection 遞迴。 */
-    private requestShutdown;
-    /** 啟動日誌 + SIGTERM/SIGINT/uncaughtException/unhandledRejection → shutdown */
-    private registerProcessLifecycle;
-    start(): Promise<void>;
-    private runStart;
-    runAsWorker(ctx: NodeLoopContext): Promise<void>;
-    /** 執行過程遇到未知錯誤以至於無法繼續執行時：DOING → OPEN（RESET），釋放已認領的任務。 */
-    private abortTaskRun;
-    /** Task 執行結束後更新 TaskStatus */
-    private finalizeTaskRun;
-    /**
-     * 關閉節點並退出進程。冪等：並發或重複調用復用同一進行中的 Promise，
-     * 避免重複 patchStopNode / process.exit。
-     */
-    shutdown(options?: {
-        trigger?: string;
-    }): Promise<void>;
-    private runShutdown;
-    /** @returns 心跳是否成功 */
-    heartbeat(ctx: NodeLoopContext): Promise<boolean>;
-    batchCommand(ctx: NodeLoopContext): Promise<void>;
-    executeCommand(cmd: CommandType): Promise<void>;
-}
-export { NodeManager };
-//# sourceMappingURL=node-manager.d.ts.map

package/dist/node/node-manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"node-manager.d.ts","sourceRoot":"","sources":["../../src/node/node-manager.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAO3D,OAAO,EAAE,eAAe,EAAc,MAAM,kBAAkB,CAAC;AAG/D,cAAM,WAAW;IACb,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,2BAA2B,CAAK;IAExD,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,kBAAkB,CAAgB;IAE1C,OAAO,CAAC,SAAS,CAAU;IAC3B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,4BAA4B,CAAK;IACzC,0DAA0D;IAC1D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,yCAAyC;IACzC,OAAO,CAAC,eAAe,CAA8B;IACrD,mCAAmC;IACnC,OAAO,CAAC,YAAY,CAA8B;IAElD,IAAI,iBAAiB,IAAI,SAAS,MAAM,EAAE,CAEzC;IAED,IAAI,WAAW,IAAI,MAAM,GAAG,IAAI,CAE/B;IACD,IAAI,WAAW,CAAC,KAAK,EAAE,MAAM,EAU5B;;IAQD,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,cAAc;IAItB,2FAA2F;IAC3F,OAAO,CAAC,eAAe;IAIvB,4EAA4E;IAC5E,OAAO,CAAC,wBAAwB;IAsD1B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAQd,QAAQ;IAyHhB,WAAW,CAAC,GAAG,EAAE,eAAe;IAwItC,yDAAyD;YAC3C,YAAY;IA8B1B,8BAA8B;YAChB,eAAe;IAoD7B;;;OAGG;IACG,QAAQ,CAAC,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;YAiC/C,WAAW;IAuCzB,sBAAsB;IAChB,SAAS,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC;IA+CjD,YAAY,CAAC,GAAG,EAAE,eAAe;IAgEjC,cAAc,CAAC,GAAG,EAAE,WAAW;CAWxC;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}