@evolu/common 7.2.2 → 7.3.0

package/src/local-first/Storage.ts

@@ -26,13 +26,13 @@ import {
   TypeError,
 } from "../Type.js";
 import {
-  OwnerError,
   Owner,
+  OwnerError,
   OwnerId,
   OwnerIdBytes,
   OwnerWriteKey,
 } from "./Owner.js";
-import { systemColumns } from "./Schema.js";
+import { systemColumnsWithId } from "./Schema.js";
 import { orderTimestampBytes, Timestamp, TimestampBytes } from "./Timestamp.js";
 
 export interface StorageConfig {
@@ -256,16 +256,11 @@ export interface CrdtMessage {
 export const DbChangeValues = record(String, SqliteValue);
 export type DbChangeValues = typeof DbChangeValues.Type;
 
-// "createdAt" and "updatedAt" are derived from Timestamp.
-// "id" and "isDeleted" are encoded separately to save bytes
-// "ownerId" is part of the protocol message
-const forbiddenSystemColumns = systemColumns.concat("id");
-
 export const ValidDbChangeValues = brand(
   "ValidDbChangeValues",
   DbChangeValues,
   (value) => {
-    const invalidColumns = forbiddenSystemColumns.filter((key) => key in value);
+    const invalidColumns = systemColumnsWithId.filter((key) => key in value);
     if (invalidColumns.length > 0)
       return err<ValidDbChangeValuesError>({
         type: "ValidDbChangeValues",

package/src/local-first/Sync.ts

@@ -1,10 +1,11 @@
 import {
+  appendToArray,
   firstInArray,
   isNonEmptyReadonlyArray,
   NonEmptyArray,
   NonEmptyReadonlyArray,
 } from "../Array.js";
-import { assert } from "../Assert.js";
+import { assert, assertNonEmptyReadonlyArray } from "../Assert.js";
 import { Brand } from "../Brand.js";
 import { ConsoleDep } from "../Console.js";
 import {
@@ -15,7 +16,7 @@ import {
 import { eqArrayNumber } from "../Eq.js";
 import { createTransferableError, TransferableError } from "../Error.js";
 import { constFalse, constTrue } from "../Function.js";
-import { objectToEntries } from "../Object.js";
+import { createRecord, getProperty, objectToEntries } from "../Object.js";
 import { RandomDep } from "../Random.js";
 import { createResources } from "../Resources.js";
 import { err, ok, Result } from "../Result.js";
@@ -26,22 +27,23 @@ import {
   sqliteBooleanToBoolean,
   SqliteDep,
   SqliteError,
-  sqliteFalse,
   SqliteValue,
 } from "../Sqlite.js";
 import { AbortError, createMutex } from "../Task.js";
 import { TimeDep } from "../Time.js";
 import {
+  Boolean,
   DateIso,
+  Id,
   IdBytes,
   idBytesToId,
   idToIdBytes,
   PositiveInt,
 } from "../Type.js";
 import { CreateWebSocketDep, WebSocket } from "../WebSocket.js";
-import type { AppOwnerDep, PostMessageDep } from "./Db.js";
 import {
   AppOwner,
+  AppOwnerDep,
   Owner,
   OwnerId,
   OwnerIdBytes,
@@ -62,7 +64,7 @@ import {
   ProtocolTimestampMismatchError,
   SubscriptionFlags,
 } from "./Protocol.js";
-import { MutationChange } from "./Schema.js";
+import { DbSchemaDep, MutationChange, systemColumns } from "./Schema.js";
 import {
   BaseSqliteStorage,
   CrdtMessage,
@@ -71,7 +73,6 @@ import {
   getOwnerUsage,
   getTimestampInsertStrategy,
   Storage,
-  StorageInsertTimestampStrategy,
   StorageWriteError,
   updateOwnerUsage,
 } from "./Storage.js";
@@ -81,6 +82,7 @@ import {
   receiveTimestamp,
   sendTimestamp,
   Timestamp,
+  TimestampBytes,
   timestampBytesToTimestamp,
   TimestampConfigDep,
   TimestampCounterOverflowError,
@@ -158,7 +160,8 @@ export const createSync =
     deps: ClockDep &
       ConsoleDep &
       CreateWebSocketDep &
-      PostMessageDep &
+      DbSchemaDep &
+      // PostMessageDep &
       RandomBytesDep &
       RandomDep &
       SqliteDep &
@@ -325,7 +328,6 @@ export const createSync =
           resources.addConsumer(owner, transports);
         } else {
           const result = resources.removeConsumer(owner, transports);
-
           if (!result.ok) {
             deps.console.warn("[sync]", "Failed to remove consumer", {
               transports,
@@ -446,13 +448,13 @@ export interface ClientStorageDep {
 const createClientStorage =
   (
     deps: ClockDep &
+      DbSchemaDep &
       GetSyncOwnerDep &
       RandomDep &
       SqliteDep &
       SymmetricCryptoDep &
       TimeDep &
-      TimestampConfigDep &
-      PostMessageDep,
+      TimestampConfigDep,
   ) =>
   (config: {
     onError: (
@@ -486,7 +488,7 @@ const createClientStorage =
         const ownerId = ownerIdBytesToOwnerId(ownerIdBytes);
 
         // Everything is sync now, but we will need async crypto in the future.
-        const writeResult = await mutex.withLock<
+        const result = await mutex.withLock<
           boolean,
           | AbortError
           | ProtocolInvalidDataError
@@ -538,19 +540,13 @@ const createClientStorage =
             }
 
             if (isNonEmptyReadonlyArray(messages)) {
-              const applyMessagesResult = applyMessages({ ...deps, storage })(
+              const result = applyMessages({ ...deps, storage })(
                 owner.id,
                 messages,
               );
-              if (!applyMessagesResult.ok) return applyMessagesResult;
+              if (!result.ok) return result;
             }
 
-            // // Apply local mutations atomically with approved messages
-            // for (const change of localMutations) {
-            //   const result = applyLocalOnlyChange(deps)(change);
-            //   if (!result.ok) return result;
-            // }
-
             return deps.clock.save(clockTimestamp);
           });
 
@@ -559,9 +555,9 @@ const createClientStorage =
           return ok(true);
         })();
 
-        if (!writeResult.ok) {
-          if (writeResult.error.type !== "AbortError") {
-            config.onError(writeResult.error);
+        if (!result.ok) {
+          if (result.error.type !== "AbortError") {
+            config.onError(result.error);
           }
           return err<StorageWriteError>({ type: "StorageWriteError", ownerId });
         }
@@ -577,26 +573,34 @@ const createClientStorage =
         if (!owner) return null;
 
         const result = deps.sqlite.exec<{
-          table: string;
-          id: IdBytes;
-          column: string;
-          value: SqliteValue;
+          readonly table: string;
+          readonly id: IdBytes;
+          readonly column: string;
+          readonly value: SqliteValue;
         }>(sql`
           select "table", "id", "column", "value"
           from evolu_history
+          where "ownerId" = ${ownerId} and "timestamp" = ${timestamp}
+          union all
+          select "table", "id", "column", "value"
+          from evolu_message_quarantine
           where "ownerId" = ${ownerId} and "timestamp" = ${timestamp};
         `);
+
         if (!result.ok) {
           config.onError(result.error);
           return null;
         }
 
         const { rows } = result.value;
-        assert(rows.length > 0, "Rows must not be empty");
+        assertNonEmptyReadonlyArray(
+          rows,
+          "Every timestamp must have rows in evolu_history or quarantine",
+        );
 
-        const { table, id } = rows[0];
-        const values: Record<string, SqliteValue> = {};
-        let isInsert = false;
+        const { table, id } = firstInArray(rows);
+        const values = createRecord<string, SqliteValue>();
+        let isInsert;
         let isDelete: boolean | null = null;
 
         for (const r of rows) {
@@ -606,10 +610,13 @@ const createClientStorage =
             case "createdAt":
               isInsert = true;
               break;
+            case "updatedAt":
+              isInsert = false;
+              break;
             case "isDeleted":
               assert(
                 SqliteBoolean.is(r.value),
-                "isDeleted column must contain a valid SqliteBoolean (0 or 1)",
+                "isDeleted column must contain a valid SqliteBoolean",
               );
               isDelete = sqliteBooleanToBoolean(r.value);
               break;
@@ -618,6 +625,8 @@ const createClientStorage =
           }
         }
 
+        assert(Boolean.is(isInsert), "isInsert must be in evolu_history");
+
         const message: CrdtMessage = {
           timestamp: timestampBytesToTimestamp(timestamp),
           change: DbChange.orThrow({
@@ -643,6 +652,24 @@ const createTransportKey = (transport: OwnerTransport): TransportKey => {
   return `${transport.type}:${transport.url}` as TransportKey;
 };
 
+const dbChangeToColumns = (change: DbChange, now: DateIso) => {
+  let values = objectToEntries(change.values);
+
+  // SystemColumns are not encoded in change.values.
+  values = appendToArray(values, [
+    change.isInsert ? "createdAt" : "updatedAt",
+    now,
+  ]);
+  if (change.isDelete != null) {
+    values = appendToArray(values, [
+      "isDeleted",
+      booleanToSqliteBoolean(change.isDelete),
+    ]);
+  }
+
+  return values;
+};
+
 export const applyLocalOnlyChange =
   (deps: SqliteDep & TimeDep & AppOwnerDep) =>
   (change: MutationChange): Result<void, SqliteError> => {
@@ -653,23 +680,16 @@ export const applyLocalOnlyChange =
       `);
       if (!result.ok) return result;
     } else {
-      const now = deps.time.nowIso();
       const ownerId = deps.appOwner.id;
+      const columns = dbChangeToColumns(change, deps.time.nowIso());
 
-      let entries = objectToEntries(change.values);
-      if (change.isDelete !== null) {
-        entries = [...entries, ["isDeleted", sqliteFalse]];
-      }
-
-      for (const [column, value] of entries) {
+      for (const [column, value] of columns) {
         const result = deps.sqlite.exec(sql.prepared`
           insert into ${sql.identifier(change.table)}
-            ("ownerId", "id", ${sql.identifier(column)}, createdAt, updatedAt)
-          values (${ownerId}, ${change.id}, ${value}, ${now}, ${now})
+            ("ownerId", "id", ${sql.identifier(column)})
+          values (${ownerId}, ${change.id}, ${value})
           on conflict ("ownerId", "id") do update
-            set
-              ${sql.identifier(column)} = ${value},
-              updatedAt = ${now};
+            set ${sql.identifier(column)} = ${value};
         `);
         if (!result.ok) return result;
       }
@@ -679,129 +699,150 @@ export const applyLocalOnlyChange =
   };
 
 const applyMessages =
-  (deps: ClientStorageDep & ClockDep & RandomDep & SqliteDep) =>
+  (deps: ClientStorageDep & ClockDep & DbSchemaDep & RandomDep & SqliteDep) =>
   (
     ownerId: OwnerId,
     messages: NonEmptyReadonlyArray<CrdtMessage>,
   ): Result<void, SqliteError> => {
     const ownerIdBytes = ownerIdToOwnerIdBytes(ownerId);
 
-    const usageResult = getOwnerUsage(deps)(
+    const usage = getOwnerUsage(deps)(
       ownerIdBytes,
       timestampToTimestampBytes(firstInArray(messages).timestamp),
     );
-    if (!usageResult.ok) return usageResult;
-
-    let { firstTimestamp, lastTimestamp } = usageResult.value;
-
-    for (const message of messages) {
-      const date = timestampToDateIso(message.timestamp);
-      const result1 = applyMessageToAppTable(deps)(ownerIdBytes, message, date);
-      if (!result1.ok) return result1;
-
-      const timestamp = timestampToTimestampBytes(message.timestamp);
+    if (!usage.ok) return usage;
+
+    let { firstTimestamp, lastTimestamp } = usage.value;
+
+    for (const { timestamp, change } of messages) {
+      const columns = dbChangeToColumns(change, timestampToDateIso(timestamp));
+      const idBytes = idToIdBytes(change.id);
+      const timestampBytes = timestampToTimestampBytes(timestamp);
+
+      for (const [column, value] of columns) {
+        if (validateColumnValue(deps)(change.table, column, value)) {
+          const result = applyColumnChange(deps)(
+            ownerIdBytes,
+            ownerId,
+            change.table,
+            idBytes,
+            change.id,
+            column,
+            value,
+            timestampBytes,
+          );
+          if (!result.ok) return result;
+        } else {
+          const result = deps.sqlite.exec(sql.prepared`
+            insert into evolu_message_quarantine
+              ("ownerId", "timestamp", "table", "id", "column", "value")
+            values
+              (
+                ${ownerIdBytes},
+                ${timestampBytes},
+                ${change.table},
+                ${idBytes},
+                ${column},
+                ${value}
+              )
+            on conflict do nothing;
+          `);
+          if (!result.ok) return result;
+        }
+      }
 
       let strategy;
       [strategy, firstTimestamp, lastTimestamp] = getTimestampInsertStrategy(
-        timestamp,
+        timestampBytes,
         firstTimestamp,
         lastTimestamp,
       );
 
-      const result2 = applyMessageToTimestampAndHistoryTables(deps)(
+      const result = deps.storage.insertTimestamp(
         ownerIdBytes,
-        message,
+        timestampBytes,
         strategy,
-        date,
       );
-      if (!result2.ok) return result2;
+      if (!result.ok) return result;
     }
 
     /**
-     * TODO: Implement proper storedBytes tracking for client using encrypted
-     * message sizes (need to figure out how to reuse received or postpone
-     * client...).
+     * TODO: Implement proper storedBytes tracking for client using received and
+     * sent encrypted message sizes.
      */
-    const updateUsage = updateOwnerUsage(deps)(
+    return updateOwnerUsage(deps)(
       ownerIdBytes,
       1 as PositiveInt, // Placeholder until proper tracking implemented
       firstTimestamp,
       lastTimestamp,
     );
-    if (!updateUsage.ok) return updateUsage;
+  };
 
-    return ok();
+/**
+ * System columns that can appear in sync messages. Excludes `ownerId` because
+ * it's handled separately (stored per-row, not per-column in messages).
+ */
+const systemColumnsWithoutOwnerId = systemColumns.difference(
+  new Set(["ownerId"]),
+);
+
+const validateColumnValue =
+  (deps: DbSchemaDep) =>
+  (table: string, column: string, _value: SqliteValue): boolean => {
+    const schemaColumns = getProperty(deps.dbSchema.tables, table);
+    return (
+      schemaColumns != null &&
+      (systemColumnsWithoutOwnerId.has(column) || schemaColumns.has(column))
+    );
   };
 
-const applyMessageToAppTable =
+const applyColumnChange =
   (deps: SqliteDep) =>
   (
     ownerIdBytes: OwnerIdBytes,
-    message: CrdtMessage,
-    date: DateIso,
-  ): Result<void, SqliteError> => {
-    const ownerId = ownerIdBytesToOwnerId(ownerIdBytes);
-    const columns = dbChangeToColumns(message.change, date);
-
-    for (const [column, value] of columns) {
-      const result = deps.sqlite.exec(sql.prepared`
-        with
-          existingTimestamp as (
-            select 1
-            from evolu_history
-            where
-              "ownerId" = ${ownerIdBytes}
-              and "table" = ${message.change.table}
-              and "id" = ${idToIdBytes(message.change.id)}
-              and "column" = ${column}
-              and "timestamp" >= ${timestampToTimestampBytes(message.timestamp)}
-            limit 1
-          )
-        insert into ${sql.identifier(message.change.table)}
-          ("ownerId", "id", ${sql.identifier(column)}, updatedAt)
-        select ${ownerId}, ${message.change.id}, ${value}, ${date}
-        where not exists (select 1 from existingTimestamp)
-        on conflict ("ownerId", "id") do update
-          set
-            ${sql.identifier(column)} = ${value},
-            updatedAt = ${date}
-          where not exists (select 1 from existingTimestamp);
-      `);
-
-      if (!result.ok) return result;
-    }
-
-    return ok();
-  };
-
-export const applyMessageToTimestampAndHistoryTables =
-  (deps: ClientStorageDep & SqliteDep) =>
-  (
-    ownerId: OwnerIdBytes,
-    message: CrdtMessage,
-    strategy: StorageInsertTimestampStrategy,
-    date: DateIso,
+    ownerId: OwnerId,
+    table: string,
+    idBytes: IdBytes,
+    id: Id,
+    column: string,
+    value: SqliteValue,
+    timestampBytes: TimestampBytes,
   ): Result<void, SqliteError> => {
-    const timestamp = timestampToTimestampBytes(message.timestamp);
-    const id = idToIdBytes(message.change.id);
-
-    const result = deps.storage.insertTimestamp(ownerId, timestamp, strategy);
+    const result = deps.sqlite.exec(sql.prepared`
+      with
+        existingTimestamp as (
+          select 1
+          from evolu_history
+          where
+            "ownerId" = ${ownerIdBytes}
+            and "table" = ${table}
+            and "id" = ${idBytes}
+            and "column" = ${column}
+            and "timestamp" >= ${timestampBytes}
+          limit 1
+        )
+      insert into ${sql.identifier(table)}
+        ("ownerId", "id", ${sql.identifier(column)})
+      select ${ownerId}, ${id}, ${value}
+      where not exists (select 1 from existingTimestamp)
+      on conflict ("ownerId", "id") do update
+        set ${sql.identifier(column)} = ${value}
+        where not exists (select 1 from existingTimestamp);
+    `);
     if (!result.ok) return result;
 
-    const columns = dbChangeToColumns(message.change, date);
-
-    for (const [column, value] of columns) {
+    {
       const result = deps.sqlite.exec(sql.prepared`
         insert into evolu_history
           ("ownerId", "table", "id", "column", "value", "timestamp")
         values
           (
-            ${ownerId},
-            ${message.change.table},
-            ${id},
+            ${ownerIdBytes},
+            ${table},
+            ${idBytes},
             ${column},
             ${value},
-            ${timestamp}
+            ${timestampBytes}
           )
         on conflict do nothing;
       `);
@@ -811,19 +852,58 @@ export const applyMessageToTimestampAndHistoryTables =
     return ok();
   };
 
-const dbChangeToColumns = (
-  change: DbChange,
-  date: DateIso,
-): Array<[string, SqliteValue | DateIso]> => {
-  const entries = [...objectToEntries(change.values)];
-  if (change.isInsert) {
-    entries.push(["createdAt", date]);
-  }
-  if (change.isDelete !== null) {
-    entries.push(["isDeleted", booleanToSqliteBoolean(change.isDelete)]);
-  }
-  return entries;
-};
+/**
+ * Attempts to apply quarantined messages that may now be valid after a schema
+ * update. Messages are quarantined when they reference tables or columns that
+ * don't exist in the current schema (e.g., from a newer app version).
+ */
+export const tryApplyQuarantinedMessages =
+  (deps: DbSchemaDep & SqliteDep) => (): Result<void, SqliteError> => {
+    const rows = deps.sqlite.exec<{
+      readonly ownerId: OwnerIdBytes;
+      readonly timestamp: TimestampBytes;
+      readonly table: string;
+      readonly id: IdBytes;
+      readonly column: string;
+      readonly value: SqliteValue;
+    }>(sql`
+      select "ownerId", "timestamp", "table", "id", "column", "value"
+      from evolu_message_quarantine;
+    `);
+    if (!rows.ok) return rows;
+
+    for (const row of rows.value.rows) {
+      if (!validateColumnValue(deps)(row.table, row.column, row.value))
+        continue;
+
+      const result = applyColumnChange(deps)(
+        row.ownerId,
+        ownerIdBytesToOwnerId(row.ownerId),
+        row.table,
+        row.id,
+        idBytesToId(row.id),
+        row.column,
+        row.value,
+        row.timestamp,
+      );
+      if (!result.ok) return result;
+
+      {
+        const result = deps.sqlite.exec(sql`
+          delete from evolu_message_quarantine
+          where
+            "ownerId" = ${row.ownerId}
+            and "timestamp" = ${row.timestamp}
+            and "table" = ${row.table}
+            and "id" = ${row.id}
+            and "column" = ${row.column};
+        `);
+        if (!result.ok) return result;
+      }
+    }
+
+    return ok();
+  };
 
 /**
  * TODO: Rework for the new owners API.

package/src/local-first/Timestamp.ts

@@ -336,8 +336,21 @@ export const timestampBytesToTimestamp = (
   return { millis: Number(millis), counter, nodeId } as Timestamp;
 };
 
+/**
+ * An {@link Order} for {@link TimestampBytes}.
+ *
+ * This `Order` uses lexicographic byte order to compare serialized
+ * {@link TimestampBytes} produced by {@link timestampToTimestampBytes}. See
+ * {@link orderUint8Array} for the underlying implementation.
+ */
 export const orderTimestampBytes: Order<TimestampBytes> = orderUint8Array;
 
+/**
+ * Convert a {@link Timestamp} to an ISO 8601 {@link DateIso} string.
+ *
+ * The conversion uses the timestamp's `millis` (a {@link Millis} value) and
+ * `Date.prototype.toISOString()` to produce a `DateIso`.
+ */
 export const timestampToDateIso = (timestamp: Timestamp): DateIso =>
-  // `as DateIso` is safe because the timestamp is always valid
+  // `as DateIso` is safe because Timestamp guarantees a valid `millis`
   new Date(timestamp.millis).toISOString() as DateIso;

package/src/local-first/index.ts

@@ -5,7 +5,6 @@
  */
 
 export * from "./Db.js";
-export * from "./Diff.js";
 export * from "./Evolu.js";
 export * from "./Owner.js";
 export * from "./Platform.js";

package/dist/src/local-first/Diff.d.ts

@@ -1,43 +0,0 @@
-import { Query, Row } from "./Query.js";
-export interface QueryPatches {
-    readonly query: Query;
-    readonly patches: ReadonlyArray<Patch>;
-}
-export type Patch = ReplaceAllPatch | ReplaceAtPatch;
-export interface ReplaceAllPatch {
-    readonly op: "replaceAll";
-    readonly value: ReadonlyArray<Row>;
-}
-export interface ReplaceAtPatch {
-    readonly op: "replaceAt";
-    readonly index: number;
-    readonly value: Row;
-}
-export declare const applyPatches: (patches: ReadonlyArray<Patch>, current: ReadonlyArray<Row>) => ReadonlyArray<Row>;
-/**
- * We detect only changes in the whole result and in-place edits. In the future,
- * we will add more heuristics. We will probably not implement the Myers diff
- * algorithm because it's faster to rerender all than to compute many detailed
- * patches. We will only implement logic a developer would implement manually,
- * if necessary.
- */
-export declare const makePatches: (previousRows: ReadonlyArray<Row> | undefined, nextRows: ReadonlyArray<Row>) => ReadonlyArray<Patch>;
-/**
- * A unique identifier prepended to JSON-encoded strings. This allows safe
- * detection and parsing of only those columns that require JSON.parse.
- *
- * The identifier is a cryptographically random Evolu Id, ensuring uniqueness
- * and preventing malicious actors from inserting fake data that could be
- * misinterpreted as JSON by the application.
- *
- * Note: The same queries created by different browser tabs will have different
- * identifiers and thus be considered different and cached separately. This is
- * usually not a big deal, but if needed, the DB cache can be optimized by
- * passing the kyselyJsonIdentifier into the DB worker during initialization,
- * allowing queries to be grouped and recognized across tabs or sessions.
- *
- * See: https://github.com/kysely-org/kysely/issues/1372#issuecomment-2702773948
- */
-export declare const kyselyJsonIdentifier: string & import("../Brand.js").Brand<"Id">;
-export declare const parseSqliteJsonArray: <T>(arr: ReadonlyArray<T>) => ReadonlyArray<T>;
-//# sourceMappingURL=Diff.d.ts.map

package/dist/src/local-first/Diff.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Diff.d.ts","sourceRoot":"","sources":["../../../src/local-first/Diff.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAExC,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;CACxC;AAED,MAAM,MAAM,KAAK,GAAG,eAAe,GAAG,cAAc,CAAC;AAErD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,YAAY,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC;CACrB;AAED,eAAO,MAAM,YAAY,GACvB,SAAS,aAAa,CAAC,KAAK,CAAC,EAC7B,SAAS,aAAa,CAAC,GAAG,CAAC,KAC1B,aAAa,CAAC,GAAG,CAUP,CAAC;AAEd;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GACtB,cAAc,aAAa,CAAC,GAAG,CAAC,GAAG,SAAS,EAC5C,UAAU,aAAa,CAAC,GAAG,CAAC,KAC3B,aAAa,CAAC,KAAK,CA6BrB,CAAC;AAUF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB,4CAE/B,CAAC;AAEH,eAAO,MAAM,oBAAoB,GAAI,CAAC,EACpC,KAAK,aAAa,CAAC,CAAC,CAAC,KACpB,aAAa,CAAC,CAAC,CAMjB,CAAC"}