@cedarjs/jobs 7.0.1-next.314 → 7.0.1-next.466

package/dist/adapters/PrismaAdapter/PrismaAdapter.js

@@ -4,8 +4,19 @@ import {
   DEFAULT_MODEL_NAME,
   MAX_RUNTIME_GRACE_PERIOD
 } from "../../consts.js";
+import {
+  CedarJSJobsError,
+  JobIdNotFoundError,
+  JobNotActiveError
+} from "../../errors.js";
+import { nextCronRunAt } from "../../util.js";
 import { BaseAdapter } from "../BaseAdapter/BaseAdapter.js";
-import { ModelNameError } from "./errors.js";
+import {
+  KeyColumnMissingError,
+  ModelNameError,
+  PausedAtColumnMissingError
+} from "./errors.js";
+const MAX_KEY_RETRIES = 5;
 function isPrismaAdapterDelegate(value) {
   const candidate = value;
   return candidate !== null && typeof candidate === "object" && typeof candidate.findFirst === "function" && typeof candidate.updateMany === "function" && typeof candidate.delete === "function" && typeof candidate.update === "function" && typeof candidate.create === "function" && typeof candidate.deleteMany === "function";
@@ -27,11 +38,34 @@ function getActiveProvider(db) {
   }
   return provider;
 }
+function isUniqueViolation(e) {
+  return typeof e === "object" && e !== null && "code" in e && e.code === "P2002";
+}
+function isMissingKeyColumn(e) {
+  return e instanceof Error && e.name === "PrismaClientValidationError" && /Unknown (argument|field) `key`/.test(e.message);
+}
+function releaseKey(job) {
+  return job.key != null ? { key: null } : {};
+}
+function rowToJob(row) {
+  const { name, path, args } = JSON.parse(row.handler);
+  return { ...row, name, path, args };
+}
+function isMissingPausedAtColumn(e) {
+  return e instanceof Error && e.name === "PrismaClientValidationError" && /Unknown (argument|field) `pausedAt`/.test(e.message);
+}
 class PrismaAdapter extends BaseAdapter {
+  supportsUniqueKeys = true;
   db;
   model;
   accessor;
   provider;
+  /**
+   * Whether the model has a `pausedAt` column, so `find()` has to leave out
+   * paused jobs. Unknown until the first `find()`, which finds out by
+   * filtering on the column
+   */
+  #hasPausedAtColumn;
   constructor(options) {
     super(options);
     this.db = options.db;
@@ -54,92 +88,127 @@ class PrismaAdapter extends BaseAdapter {
     const maxRuntimeExpire = new Date(
       (/* @__PURE__ */ new Date()).getTime() - ((maxRuntime || DEFAULT_MAX_RUNTIME) + MAX_RUNTIME_GRACE_PERIOD) * 1e3
     );
-    const where = {
-      AND: [
-        {
-          OR: [
-            {
-              AND: [
-                { runAt: { lte: /* @__PURE__ */ new Date() } },
-                {
-                  OR: [
-                    { lockedAt: null },
-                    {
-                      lockedAt: {
-                        lt: maxRuntimeExpire
-                      }
+    const conditions = (withPausedAt) => [
+      {
+        OR: [
+          {
+            AND: [
+              { runAt: { lte: /* @__PURE__ */ new Date() } },
+              {
+                OR: [
+                  { lockedAt: null },
+                  {
+                    lockedAt: {
+                      lt: maxRuntimeExpire
                     }
-                  ]
-                }
-              ]
-            },
-            { lockedBy: processName }
-          ]
-        },
-        { failedAt: null }
-      ]
-    };
-    const whereWithQueue = where;
-    if (queues.length > 1 || queues[0] !== "*") {
-      Object.assign(whereWithQueue, {
-        AND: [...where.AND, { queue: { in: queues } }]
-      });
-    }
-    const job = await this.accessor.findFirst({
-      select: { id: true, attempts: true },
-      where: whereWithQueue,
+                  }
+                ]
+              }
+            ]
+          },
+          { lockedBy: processName }
+        ]
+      },
+      { failedAt: null },
+      ...withPausedAt ? [{ pausedAt: null }] : [],
+      // If queues is ['*'] then skip, otherwise add a WHERE...IN for the
+      // array of queue names
+      ...queues.length > 1 || queues[0] !== "*" ? [{ queue: { in: queues } }] : []
+    ];
+    const findCandidate = (withPausedAt) => this.accessor.findFirst({
+      where: { AND: conditions(withPausedAt) },
       orderBy: [{ priority: "asc" }, { runAt: "asc" }],
       take: 1
     });
+    let job;
+    if (this.#hasPausedAtColumn === false) {
+      job = await findCandidate(false);
+    } else {
+      try {
+        job = await findCandidate(true);
+        this.#hasPausedAtColumn = true;
+      } catch (e) {
+        if (!isMissingPausedAtColumn(e)) {
+          throw e;
+        }
+        this.#hasPausedAtColumn = false;
+        job = await findCandidate(false);
+      }
+    }
     if (job) {
-      const whereWithQueueAndId = Object.assign(whereWithQueue, {
-        AND: [...whereWithQueue.AND, { id: job.id }]
-      });
+      const whereWithId = {
+        AND: [...conditions(this.#hasPausedAtColumn === true), { id: job.id }]
+      };
       const { count } = await this.accessor.updateMany({
-        where: whereWithQueueAndId,
+        where: whereWithId,
         data: {
           lockedAt: /* @__PURE__ */ new Date(),
           lockedBy: processName,
-          attempts: job.attempts + 1
+          attempts: job.attempts + 1,
+          ...job.cron ? {} : releaseKey(job)
         }
       });
       if (count) {
         const data = await this.accessor.findFirst({ where: { id: job.id } });
-        const { name, path, args } = JSON.parse(data.handler);
-        return { ...data, name, path, args };
+        if (data) {
+          return rowToJob(data);
+        }
       }
     }
     return void 0;
   }
+  /**
+   * The `where` clause that matches the job's row only while it is still
+   * locked by the claim that `find()` returned as `job`.
+   *
+   * `lockedAt` identifies the claim: every claim sets it to the time of
+   * locking, and `find()` returns the value read back from the database, so
+   * it compares equal to the stored value regardless of the column's
+   * precision. Nothing else changes `lockedAt` while the job is locked, and
+   * a newer claim of the same job sets its own, different `lockedAt`. `attempts` alone
+   * is not unique per claim, because a successful run of a recurring job
+   * resets it to 0, and `lockedBy` is not unique either, because it names
+   * the worker process, which claims many jobs and can claim the same job
+   * again
+   */
+  #claimedBy(job) {
+    return {
+      id: job.id,
+      failedAt: null,
+      attempts: job.attempts,
+      lockedAt: job.lockedAt
+    };
+  }
   // Prisma queries are lazily evaluated and only sent to the db when they are
   // awaited, so do the await here to ensure they actually run (if the user
   // doesn't await the Promise then the queries will never be executed!)
   //
   // All of these updates/deletes are done with updateMany/deleteMany guarded
-  // on `failedAt: null` and on `attempts` still being this attempt's value,
-  // so the in-flight attempt's outcome can't overwrite or delete the row
-  // when:
+  // on `failedAt: null` and on the job still being locked by this attempt's
+  // claim (see `#claimedBy()`), so the in-flight attempt's outcome can't
+  // overwrite or delete the row when:
   // - the job was cancelled (or otherwise permanently failed) while this
   //   attempt was running (`failedAt` is no longer null), or
   // - the job was reclaimed by another worker because this attempt stalled
-  //   past `maxRuntime` plus the grace period (relocking increments
-  //   `attempts`, so this attempt's remembered value no longer matches).
-  // `lockedBy` can't serve as that second fence because worker process names
-  // are deterministic and reused across restarts
+  //   past `maxRuntime` plus the grace period, whether or not that newer
+  //   claim has finished by the time this attempt's outcome is written
   async success({ job, runAt, deleteJob }) {
     this.logger.debug(`[CedarJS Jobs] Job ${job.id} success`);
     if (deleteJob) {
       await this.accessor.deleteMany({
-        where: { id: job.id, failedAt: null, attempts: job.attempts }
+        where: this.#claimedBy(job)
       });
     } else {
       await this.accessor.updateMany({
-        where: { id: job.id, failedAt: null, attempts: job.attempts },
+        where: this.#claimedBy(job),
         data: {
           lockedAt: null,
           lockedBy: null,
           lastError: null,
-          runAt: runAt || null
+          runAt: runAt || null,
+          // A rescheduled (cron) job starts its next run with a clean slate,
+          // so `attempts` counts consecutive failures of a single run
+          ...runAt ? { attempts: 0 } : {}
         }
       });
     }
@@ -157,7 +226,7 @@ ${error.stack}`,
       runAt
     };
     await this.accessor.updateMany({
-      where: { id: job.id, failedAt: null, attempts: job.attempts },
+      where: this.#claimedBy(job),
       data
     });
   }
@@ -167,12 +236,13 @@ ${error.stack}`,
   async failure({ job, deleteJob, error }) {
     if (deleteJob) {
       await this.accessor.deleteMany({
-        where: { id: job.id, failedAt: null, attempts: job.attempts }
+        where: this.#claimedBy(job)
       });
     } else {
       const data = {
         failedAt: /* @__PURE__ */ new Date(),
-        runAt: null
+        runAt: null,
+        ...releaseKey(job)
       };
       if (error) {
         data.lastError = `${error.message}
@@ -180,14 +250,21 @@ ${error.stack}`,
 ${error.stack}`;
       }
       await this.accessor.updateMany({
-        where: { id: job.id, failedAt: null, attempts: job.attempts },
+        where: this.#claimedBy(job),
         data
       });
     }
   }
-  // Schedules a job by creating a new record in the background job table.
-  // Returns the created job so that callers get access to its `id` (to cancel
-  // it later, poll its status, etc.)
+  /**
+   * Schedules a job by creating a new record in the background job table.
+   * Returns the created job so that callers get access to its `id` (to cancel
+   * it later, poll its status, etc.)
+   *
+   * With a `key`, the `key` column's unique constraint makes sure only one
+   * queued job holds the key, also when several processes schedule at once.
+   * If the insert hits the constraint, the job that holds the key is
+   * returned with `alreadyQueued: true` instead
+   */
   async schedule({
     name,
     path,
@@ -195,19 +272,151 @@ ${error.stack}`;
     runAt,
     cron,
     queue,
-    priority
+    priority,
+    key
   }) {
-    const data = await this.accessor.create({
-      data: {
-        handler: JSON.stringify({ name, path, args }),
-        runAt,
-        cron,
-        queue,
-        priority
+    const job = { name, path, args };
+    const data = {
+      handler: JSON.stringify(job),
+      runAt,
+      cron,
+      queue,
+      priority,
+      ...key !== void 0 ? { key } : {}
+    };
+    if (key === void 0) {
+      return { ...await this.#create(data, job), alreadyQueued: false };
+    }
+    for (let attempt = 0; attempt <= MAX_KEY_RETRIES; attempt++) {
+      try {
+        return { ...await this.#create(data, job), alreadyQueued: false };
+      } catch (e) {
+        if (!isUniqueViolation(e)) {
+          throw e;
+        }
       }
-    });
-    const row = data;
-    return { ...row, name, path, args };
+      const queued = await this.accessor.findFirst({ where: { key } });
+      if (queued) {
+        return { ...rowToJob(queued), alreadyQueued: true };
+      }
+    }
+    throw new CedarJSJobsError(
+      `Could not schedule ${name} with the key \`${key}\`: the key was taken and released again ${MAX_KEY_RETRIES + 1} times in a row`
+    );
+  }
+  async #create(data, job) {
+    let row;
+    try {
+      row = await this.accessor.create({ data });
+    } catch (e) {
+      if (isMissingKeyColumn(e)) {
+        throw new KeyColumnMissingError(String(this.model));
+      }
+      throw e;
+    }
+    return { ...row, ...job };
+  }
+  /**
+   * Makes the stored declared schedules match `schedules`. Each schedule is
+   * one row, identified by its unique `key`, so concurrent syncs can't create
+   * duplicates: an insert that hits the unique constraint compares against
+   * (and if needed updates) the row the other sync created instead
+   */
+  async syncSchedules({
+    schedules,
+    keyPrefix
+  }) {
+    const result = {
+      created: [],
+      updated: [],
+      removed: [],
+      unchanged: []
+    };
+    if (!this.accessor.findMany) {
+      throw new ModelNameError(String(this.model));
+    }
+    let stored;
+    try {
+      stored = await this.accessor.findMany({
+        where: { key: { startsWith: keyPrefix } }
+      });
+    } catch (e) {
+      if (!isMissingKeyColumn(e)) {
+        throw e;
+      }
+      if (schedules.length === 0) {
+        return result;
+      }
+      throw new KeyColumnMissingError(String(this.model));
+    }
+    const storedByKey = new Map(stored.map((row) => [row.key, row]));
+    for (const schedule of schedules) {
+      const outcome = await this.#syncSchedule(
+        schedule,
+        storedByKey.get(schedule.key)
+      );
+      result[outcome].push(schedule.key);
+    }
+    const declared = new Set(schedules.map((schedule) => schedule.key));
+    const undeclared = stored.map((row) => row.key).filter((key) => !!key && !declared.has(key));
+    if (undeclared.length > 0) {
+      await this.accessor.deleteMany({ where: { key: { in: undeclared } } });
+      result.removed.push(...undeclared);
+    }
+    return result;
+  }
+  async #syncSchedule(schedule, stored) {
+    const { name, path, args, cron, runAt, queue, priority, key } = schedule;
+    const handler = JSON.stringify({ name, path, args });
+    let row = stored;
+    for (let attempt = 0; attempt <= MAX_KEY_RETRIES; attempt++) {
+      if (!row) {
+        try {
+          await this.accessor.create({
+            data: { handler, runAt, cron, queue, priority, key }
+          });
+          return "created";
+        } catch (e) {
+          if (!isUniqueViolation(e)) {
+            throw e;
+          }
+        }
+        row = await this.accessor.findFirst({ where: { key } });
+        if (!row) {
+          continue;
+        }
+      }
+      const changes = {};
+      if (row.handler !== handler) {
+        changes.handler = handler;
+      }
+      if (row.queue !== queue) {
+        changes.queue = queue;
+      }
+      if (row.priority !== priority) {
+        changes.priority = priority;
+      }
+      if (row.cron !== cron) {
+        changes.cron = cron;
+        if (!row.lockedAt) {
+          changes.runAt = runAt;
+        }
+      }
+      if (Object.keys(changes).length === 0) {
+        return "unchanged";
+      }
+      const { count } = await this.accessor.updateMany({
+        where: { id: row.id },
+        data: changes
+      });
+      if (count > 0) {
+        return "updated";
+      }
+      row = void 0;
+    }
+    throw new CedarJSJobsError(
+      `Could not sync the schedule \`${key}\`: it was created and removed again ${MAX_KEY_RETRIES + 1} times in a row`
+    );
   }
   /**
    * Cancels a job by marking it as permanently failed so no worker will pick
@@ -220,16 +429,148 @@ ${error.stack}`;
    */
   async cancel({ jobId }) {
     this.logger.debug(`[CedarJS Jobs] Cancelling job ${jobId}`);
+    const job = await this.accessor.findFirst({
+      where: { id: jobId }
+    });
     const { count } = await this.accessor.updateMany({
       where: { id: jobId, failedAt: null, runAt: { not: null } },
       data: {
         failedAt: /* @__PURE__ */ new Date(),
         lastError: "Job cancelled by user",
-        runAt: null
+        runAt: null,
+        ...releaseKey(job ?? {})
       }
     });
     return count > 0;
   }
+  /**
+   * Pauses a job by setting its `pausedAt`, which `find()` leaves out. A run
+   * in progress finishes, and `success()` and `error()` keep `pausedAt` when
+   * they reschedule the job
+   */
+  async pause({ jobId }) {
+    const row = await this.#findActive(jobId);
+    if (row.pausedAt) {
+      return { alreadyPaused: true, pausedAt: row.pausedAt };
+    }
+    const pausedAt = /* @__PURE__ */ new Date();
+    const { count } = await this.accessor.updateMany({
+      where: {
+        id: row.id,
+        pausedAt: null,
+        failedAt: null,
+        runAt: { not: null }
+      },
+      data: { pausedAt }
+    });
+    if (count === 0) {
+      const current = await this.#findActive(jobId);
+      if (!current.pausedAt) {
+        return this.pause({ jobId });
+      }
+      return { alreadyPaused: true, pausedAt: current.pausedAt };
+    }
+    return { alreadyPaused: false, pausedAt };
+  }
+  /**
+   * Resumes a paused job. A recurring job runs next at the next match of its
+   * cron from now, and, unless it's running, starts that run with a clean
+   * slate (`attempts` reset to 0, like after a successful run). A running
+   * job keeps its `attempts` and `runAt`: `attempts` identifies the run's
+   * claim (see `#claimedBy()`), and the worker sets the next run time when
+   * the run finishes, so a run that finishes while this write is under way
+   * keeps the run time it set, and the result's `runAt` is `null`. A one-off
+   * job keeps its `runAt`
+   */
+  async resume({ jobId }) {
+    const row = await this.#findActive(jobId);
+    if (!row.pausedAt) {
+      return { wasPaused: false, runAt: row.runAt };
+    }
+    const running = !!row.lockedAt;
+    const runAt = !row.cron ? row.runAt : running ? null : nextCronRunAt(row.cron);
+    const { count } = await this.accessor.updateMany({
+      where: {
+        id: row.id,
+        pausedAt: { not: null },
+        failedAt: null,
+        runAt: { not: null }
+      },
+      data: {
+        pausedAt: null,
+        ...row.cron && !running ? { runAt, attempts: 0 } : {}
+      }
+    });
+    if (count === 0) {
+      const current = await this.#findActive(jobId);
+      return { wasPaused: false, runAt: current.runAt };
+    }
+    return { wasPaused: true, runAt };
+  }
+  /**
+   * Reads a job that can be paused or resumed: one that hasn't completed or
+   * failed for good. The whole row is read, so `pausedAt` is on it exactly
+   * when the model has the column
+   */
+  async #findActive(jobId) {
+    const row = await this.accessor.findFirst({
+      where: { id: jobId }
+    });
+    if (!row) {
+      throw new JobIdNotFoundError(jobId);
+    }
+    if (!("pausedAt" in row)) {
+      throw new PausedAtColumnMissingError(String(this.model));
+    }
+    if (row.failedAt) {
+      throw new JobNotActiveError(jobId, "failed");
+    }
+    if (!row.runAt) {
+      throw new JobNotActiveError(jobId, "completed");
+    }
+    return row;
+  }
+  /**
+   * Lists the jobs that haven't completed or failed for good, the ones that
+   * run next first
+   */
+  async list({
+    limit,
+    queues,
+    paused
+  }) {
+    if (!this.accessor.findMany) {
+      throw new ModelNameError(String(this.model));
+    }
+    let rows;
+    try {
+      rows = await this.accessor.findMany({
+        where: {
+          failedAt: null,
+          runAt: { not: null },
+          ...queues && !(queues.length === 1 && queues[0] === "*") ? { queue: { in: queues } } : {},
+          ...paused ? { pausedAt: { not: null } } : {}
+        },
+        orderBy: [{ runAt: "asc" }, { id: "asc" }],
+        take: limit
+      });
+    } catch (e) {
+      if (paused && isMissingPausedAtColumn(e)) {
+        return [];
+      }
+      throw e;
+    }
+    return rows.map((row) => ({
+      id: row.id,
+      name: JSON.parse(row.handler).name,
+      queue: row.queue,
+      cron: row.cron ?? null,
+      runAt: row.runAt,
+      pausedAt: row.pausedAt ?? null,
+      running: !!row.lockedAt,
+      attempts: row.attempts
+    }));
+  }
   async clear() {
     await this.accessor.deleteMany();
   }

package/dist/adapters/PrismaAdapter/errors.d.ts

@@ -5,4 +5,18 @@ import { CedarJSJobsError } from '../../errors.js';
 export declare class ModelNameError extends CedarJSJobsError {
     constructor(name: string);
 }
+/**
+ * Thrown when a job is scheduled with a unique `key`, or jobs declare
+ * `schedules`, but the jobs model has no `key` column to store the key in
+ */
+export declare class KeyColumnMissingError extends CedarJSJobsError {
+    constructor(model: string);
+}
+/**
+ * Thrown when a job is paused or resumed, but the jobs model has no
+ * `pausedAt` column to store the pause in
+ */
+export declare class PausedAtColumnMissingError extends CedarJSJobsError {
+    constructor(model: string);
+}
 //# sourceMappingURL=errors.d.ts.map

package/dist/adapters/PrismaAdapter/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/adapters/PrismaAdapter/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAElD;;GAEG;AACH,qBAAa,cAAe,SAAQ,gBAAgB;gBACtC,IAAI,EAAE,MAAM;CAGzB"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/adapters/PrismaAdapter/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAElD;;GAEG;AACH,qBAAa,cAAe,SAAQ,gBAAgB;gBACtC,IAAI,EAAE,MAAM;CAGzB;AAED;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,gBAAgB;gBAC7C,KAAK,EAAE,MAAM;CAQ1B;AAED;;;GAGG;AACH,qBAAa,0BAA2B,SAAQ,gBAAgB;gBAClD,KAAK,EAAE,MAAM;CAO1B"}

package/dist/adapters/PrismaAdapter/errors.js

@@ -4,6 +4,22 @@ class ModelNameError extends CedarJSJobsError {
     super(`Model \`${name}\` not found in PrismaClient`);
   }
 }
+class KeyColumnMissingError extends CedarJSJobsError {
+  constructor(model) {
+    super(
+      `The \`${model}\` model has no \`key\` column, which unique job keys and declared schedules need. Add \`key String? @unique\` to the model in your Prisma schema and create a migration with \`yarn cedar prisma migrate dev\``
+    );
+  }
+}
+class PausedAtColumnMissingError extends CedarJSJobsError {
+  constructor(model) {
+    super(
+      `The \`${model}\` model has no \`pausedAt\` column, which pausing jobs needs. Add \`pausedAt DateTime?\` to the model in your Prisma schema and create a migration with \`yarn cedar prisma migrate dev\``
+    );
+  }
+}
 export {
-  ModelNameError
+  KeyColumnMissingError,
+  ModelNameError,
+  PausedAtColumnMissingError
 };

package/dist/bins/cedar-jobs-worker.d.ts

@@ -4,6 +4,17 @@ export declare const processName: ({ id, queues, }: {
     id: number;
     queues: string | string[];
 }) => string;
+/**
+ * The name a worker locks jobs with (`lockedBy`). A worker takes back any job
+ * locked under its own name, so the name has to be unique to this process:
+ * the process name alone is the same for the same worker config in every
+ * app server, on every host, and two workers sharing it would both run a job,
+ * and each one's result would hand the job back to the other to run again
+ */
+export declare const lockName: ({ id, queues, }: {
+    id: number;
+    queues: string | string[];
+}) => string;
 export declare const getWorker: ({ index, id, clear, workoff, }: {
     index: number;
     id: number;

package/dist/bins/cedar-jobs-worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cedar-jobs-worker.d.ts","sourceRoot":"","sources":["../../src/bins/cedar-jobs-worker.ts"],"names":[],"mappings":";AAWA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAwC/C,eAAO,MAAM,WAAW,GAAI,iBAGzB;IACD,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAC1B,WAEA,CAAA;AA0BD,eAAO,MAAM,SAAS,GAAU,gCAK7B;IACD,KAAK,EAAE,MAAM,CAAA;IACb,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;CACjB,oBAqBA,CAAA"}
+{"version":3,"file":"cedar-jobs-worker.d.ts","sourceRoot":"","sources":["../../src/bins/cedar-jobs-worker.ts"],"names":[],"mappings":";AAYA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAwC/C,eAAO,MAAM,WAAW,GAAI,iBAGzB;IACD,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAC1B,WAEA,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,iBAGtB;IACD,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAC1B,WAEA,CAAA;AA0BD,eAAO,MAAM,SAAS,GAAU,gCAK7B;IACD,KAAK,EAAE,MAAM,CAAA;IACb,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;CACjB,oBA+BA,CAAA"}