experimental-a2 0.18.1 → 0.20.0

package/src/postgres-schema.ts

@@ -0,0 +1,80 @@
+/**
+ * The Postgres schema contract. A2 never runs DDL in a Postgres database:
+ * `sql/postgres/schema.sql` (and `notifications.sql` for
+ * `listenConnectionString`) create the tables, and a store checks the
+ * recorded version before its first query.
+ */
+
+import { A2Error } from './errors.ts'
+import type { PostgresClient } from './store-postgres.ts'
+
+/** The `a2_schema` version this release needs; `schema.sql` records it. */
+export const POSTGRES_SCHEMA_VERSION = 1
+
+const PACKAGE = 'node_modules/experimental-a2'
+
+const apply = (file: string): string =>
+  `apply ${PACKAGE}/sql/postgres/${file} to this database`
+
+const SEE_DOCS = `See ${PACKAGE}/docs/stores/04-postgres.mdx.`
+
+const VERSION = 'select version from a2_schema'
+const VERSION_AND_TRIGGERS = `select version, (select count(*) from pg_trigger
+   where (tgname = 'a2_notify_events' and tgrelid = to_regclass('a2_events'))
+      or (tgname = 'a2_notify_presence' and tgrelid = to_regclass('a2_presence')))
+  as notify_triggers from a2_schema`
+
+/** Explains a failed version read, or returns undefined when the schema is not the cause. */
+const diagnose = async (
+  client: PostgresClient,
+): Promise<A2Error | undefined> => {
+  const [found] = (
+    await client.query(`select
+      to_regclass('a2_schema') is not null as marked,
+      to_regclass('a2_events') is not null as installed,
+      has_table_privilege(to_regclass('a2_schema'), 'select') as readable`)
+  ).rows
+  if (!found) return undefined
+  if (!found['marked'])
+    return new A2Error(
+      'STORE_NOT_CONFIGURED',
+      found['installed']
+        ? `This Postgres database has A2's tables but no a2_schema version. That is expected once after upgrading from a release that created its tables at runtime, and your events are untouched. A2 doesn't create or change tables at runtime: ${apply('schema.sql')}. ${SEE_DOCS}`
+        : `A2's tables aren't in this Postgres database, and A2 doesn't create tables at runtime: ${apply('schema.sql')}. ${SEE_DOCS}`,
+    )
+  if (found['readable'] === false)
+    return new A2Error(
+      'STORE_NOT_CONFIGURED',
+      `The role this store connects as can't read a2_schema. Apply schema.sql as that role, or grant it select on a2_schema and select, insert, update, and delete on A2's other tables. ${SEE_DOCS}`,
+    )
+  return undefined
+}
+
+/** Reads the schema version (and, with a listener, the triggers) in one query that takes no lock a writer holds. */
+export const checkPostgresSchema = async ({
+  client,
+  listen,
+}: {
+  client: PostgresClient
+  listen: boolean
+}): Promise<void> => {
+  let row: Record<string, unknown> | undefined
+  try {
+    row = (await client.query(listen ? VERSION_AND_TRIGGERS : VERSION)).rows[0]
+  } catch (err) {
+    throw (await diagnose(client).catch(() => undefined)) ?? err
+  }
+  const version = Number(row?.['version'] ?? 0)
+  if (version < POSTGRES_SCHEMA_VERSION) {
+    throw new A2Error(
+      'STORE_NOT_CONFIGURED',
+      `This Postgres database has A2 schema version ${version}, and this release of experimental-a2 needs version ${POSTGRES_SCHEMA_VERSION}: ${apply('schema.sql')}. ${SEE_DOCS}`,
+    )
+  }
+  if (listen && Number(row?.['notify_triggers']) < 2) {
+    throw new A2Error(
+      'STORE_NOT_CONFIGURED',
+      `listenConnectionString needs A2's notification triggers, which aren't in this Postgres database. After schema.sql, ${apply('notifications.sql')}. ${SEE_DOCS}`,
+    )
+  }
+}

package/src/scheduler-qstash.ts

@@ -497,8 +497,11 @@ const readBoundedBody = async (
   return new TextDecoder().decode(bytes)
 }
 
-const storeUnavailable = (error: unknown): error is A2Error =>
-  error instanceof A2Error && error.code === 'STORE_UNAVAILABLE'
+// A store that isn't set up yet (Postgres before schema.sql, a missing driver)
+// is fixed without changing the task, so its work waits like any outage.
+const storeOutage = (error: unknown): error is A2Error =>
+  error instanceof A2Error &&
+  (error.code === 'STORE_UNAVAILABLE' || error.code === 'STORE_NOT_CONFIGURED')
 
 const response = {
   ok: (): Response => new Response('ok'),
@@ -888,7 +891,7 @@ export function qstash(options: QStashSchedulerOptions = {}): A2Scheduler {
               await deliverSchedulerAppend(server, task)
             else await deliverSchedulerClear(server, task)
           } catch (error) {
-            if (!storeUnavailable(error)) throw error
+            if (!storeOutage(error)) throw error
             await sendStoreOutageSuccessor(task, outage)
           }
           return response.ok()
@@ -906,13 +909,17 @@ export function qstash(options: QStashSchedulerOptions = {}): A2Scheduler {
                 outcome: 'unknown' as const,
               }
         } catch (error) {
-          if (!storeUnavailable(error)) throw error
+          if (!storeOutage(error)) throw error
           await sendStoreOutageSuccessor(task, outage)
           return response.ok()
         }
         if (result.settled) return response.ok()
 
-        if (result.outcome === 'busy' || result.outcome === 'stalled') {
+        if (
+          result.outcome === 'busy' ||
+          result.outcome === 'stalled' ||
+          result.outcome === 'failed'
+        ) {
           if (result.schedulerArm) await result.schedulerArm
           else {
             await sendTask({

package/src/scheduler-vercel.ts

@@ -14,7 +14,8 @@
  *   the configured deployment scope for sending and receiving.
  * - `handler(...servers)` is the delivery route: look up the server for
  *   the contract named in the message and drain it. Settled drains ack;
- *   contention and handler failure arm a later watchdog before acking.
+ *   contention, handler failure, and a drain that throws after arming its
+ *   successor all ack once a later watchdog is durable.
  *
  * `@vercel/queue` is an optional peer dependency, imported lazily. The
  * `transport` option is the injection seam — tests run a real little
@@ -100,12 +101,9 @@ export type VercelQueuesOptions = {
 /** Vercel Queues rejects shorter visibility changes. */
 const MIN_VISIBILITY_SECONDS = 30
 
-/** Vercel Queues' maximum message retention and delivery delay. */
+/** Vercel Queues' maximum message retention; its default is a day. */
 const MAX_RETENTION_SECONDS = 7 * 24 * 60 * 60
 
-/** Leave the final retention day for delivery and retries. */
-const MAX_DELAY_SECONDS = 6 * 24 * 60 * 60
-
 const TOPIC_PATTERN = /^[A-Za-z0-9_-]+$/
 const RETRYABLE_HTTP_CLIENT_STATUSES = new Set([408, 409, 425, 429])
 /** The SDK's send path maps these statuses to name-only error instances. */
@@ -257,14 +255,6 @@ export function vercelQueues(options: VercelQueuesOptions = {}): A2Scheduler {
       0,
       Math.ceil((deliveryTargetAt - nowMs) / 1_000),
     )
-    if (deliveryDelaySeconds > MAX_DELAY_SECONDS) {
-      throw classifySchedulerSendFailure(
-        new RangeError(
-          'vercelQueues() tasks cannot be delayed more than 6 days',
-        ),
-        'terminal',
-      )
-    }
     const message: SchedulerTask = { ...task, dueAt }
     const idempotencyKey =
       task.kind === 'drain'
@@ -353,9 +343,14 @@ export function vercelQueues(options: VercelQueuesOptions = {}): A2Scheduler {
               }
           if (result.settled) return
 
-          if (result.outcome === 'busy' || result.outcome === 'stalled') {
-            // The live owner arms its own claim windows, and the store holds
-            // a failed event until its retry time. Ensure a later slot here
+          if (
+            result.outcome === 'busy' ||
+            result.outcome === 'stalled' ||
+            result.outcome === 'failed'
+          ) {
+            // The live owner arms its own claim windows, the store holds
+            // a failed event until its retry time, and a drain that failed
+            // after claiming armed its successor. Ensure a later slot here
             // as well before relinquishing this durable delivery. If the queue is down, the
             // throw leaves the current message unacked for visibility-timeout
             // redelivery.

package/src/server.ts

@@ -50,6 +50,7 @@ import {
 } from './stream-buffer.ts'
 import type {
   A2Store,
+  CompleteAttemptResult,
   AppendEvent,
   Event,
   EventCause,
@@ -1004,7 +1005,7 @@ export function createServer<
     const signal = createDrainSignal()
     const p = new Promise<void>((resolve) => {
       queueMicrotask(() => {
-        void drainSession(sessionId, watchdogDueAt, signal)
+        void drainSession(sessionId, { watchdogDueAt, signal })
           .then(() => resolve())
           .catch(() => resolve())
       })
@@ -2931,8 +2932,16 @@ export function createServer<
 
   const drainSession = (
     sessionId: string,
-    watchdogDueAt?: number,
-    signal?: DrainSignal,
+    {
+      watchdogDueAt,
+      signal,
+      handOffFailure = false,
+    }: {
+      watchdogDueAt?: number | undefined
+      signal?: DrainSignal | undefined
+      /** Return a failure after arming as `failed` instead of throwing it. */
+      handOffFailure?: boolean
+    } = {},
   ): Promise<DrainResult> =>
     telemetry.span(
       'a2.drain',
@@ -3131,7 +3140,8 @@ export function createServer<
                   }
                 | undefined
               let handlerSignal = supersedeSignal
-              let returned: ReturnedEvent[]
+              let completion: CompleteAttemptResult
+              let completing = false
               try {
                 if (registration?.abortOn) {
                   subscription = await subscribeAbort(
@@ -3158,7 +3168,32 @@ export function createServer<
                   await subscription.close()
                   subscription = undefined
                 }
-                returned = await returnedEvents(sessionId, event, result)
+                const returned = await returnedEvents(sessionId, event, result)
+                await renewal
+                completing = true
+                completion = await telemetry.span(
+                  'a2.commit',
+                  {
+                    'a2.contract': name,
+                    'a2.session_id': sessionId,
+                    'a2.commit.operation': 'complete',
+                    'a2.commit.index': event.index,
+                    'a2.commit.attempt': event.attemptCount,
+                  },
+                  async (commitSpan) => {
+                    const committed = await store.completeAttempt({
+                      sessionId: ns,
+                      index: event.index,
+                      attempt: event.attemptCount,
+                      events: returned,
+                    })
+                    commitSpan.setAttribute(
+                      'a2.commit.outcome',
+                      committed.outcome,
+                    )
+                    return committed
+                  },
+                )
               } catch (err) {
                 if (supersedeSignal.aborted && err === supersedeSignal.reason) {
                   // The handler surrendered to its own abort — identity, not
@@ -3172,6 +3207,14 @@ export function createServer<
                     appendsEvents: false,
                   }
                 }
+                const refused =
+                  completing &&
+                  err instanceof A2Error &&
+                  err.code === 'PARTIAL_DUPLICATE_BATCH'
+                // A store that cannot record the completion is not the
+                // handler failing: the claim lapses, and the claim that takes
+                // it over counts it. A returned batch it refuses is.
+                if (completing && !refused) throw err
                 // Everything else — including a store fence rejection — is
                 // adjudicated by failAttempt, which is itself fenced: a
                 // genuinely superseded attempt gets 'superseded' back with
@@ -3192,11 +3235,14 @@ export function createServer<
                       index: event.index,
                       attempt: event.attemptCount,
                       error: describeError(err),
-                      // A NonRetriableError is terminal on its first throw:
-                      // deterministic failures should not burn the retry
-                      // budget before dead-lettering.
+                      // A NonRetriableError is terminal on its first throw,
+                      // and so is a refused batch, whose retry returns the
+                      // same ids: deterministic failures should not burn the
+                      // retry budget before dead-lettering.
                       maxFailures:
-                        err instanceof NonRetriableError ? 1 : MAX_FAILURES,
+                        err instanceof NonRetriableError || refused
+                          ? 1
+                          : MAX_FAILURES,
                       retryAfterMs: failureRetryDelayMs(event.failureCount + 1),
                     })
                     commitSpan.setAttribute('a2.commit.outcome', result.outcome)
@@ -3212,27 +3258,6 @@ export function createServer<
               } finally {
                 await subscription?.close()
               }
-              await renewal
-              const completion = await telemetry.span(
-                'a2.commit',
-                {
-                  'a2.contract': name,
-                  'a2.session_id': sessionId,
-                  'a2.commit.operation': 'complete',
-                  'a2.commit.index': event.index,
-                  'a2.commit.attempt': event.attemptCount,
-                },
-                async (commitSpan) => {
-                  const result = await store.completeAttempt({
-                    sessionId: ns,
-                    index: event.index,
-                    attempt: event.attemptCount,
-                    events: returned,
-                  })
-                  commitSpan.setAttribute('a2.commit.outcome', result.outcome)
-                  return result
-                },
-              )
               eventSpan.setAttribute(
                 'a2.event.outcome',
                 completion.outcome === 'completed'
@@ -3252,7 +3277,7 @@ export function createServer<
               return {
                 status: 'processed',
                 opensLane: event.lane !== null,
-                appendsEvents: returned.length > 0,
+                appendsEvents: completion.events.length > 0,
               }
             },
           )
@@ -3424,6 +3449,12 @@ export function createServer<
             if (signal) signal.closed = true
             break
           }
+        } catch (error) {
+          // The successor armed for this drain's claims drains the session
+          // again, so the scheduler delivery need not stay as a second retry.
+          if (!handOffFailure || schedulerArm === undefined) throw error
+          span.recordError(error)
+          outcome = 'failed'
         } finally {
           if (signal) signal.closed = true
           stopRenewing = true
@@ -3525,7 +3556,10 @@ export function createServer<
     },
     schedulerDrain: (sessionId, opts) => {
       assertSessionId(sessionId)
-      return drainSession(sessionId, opts?.watchdogDueAt)
+      return drainSession(sessionId, {
+        watchdogDueAt: opts?.watchdogDueAt,
+        handOffFailure: true,
+      })
     },
     schedulerAppend: async (sessionId, events, originIndex) => {
       if (!scheduler) {

package/src/store-postgres.ts

@@ -27,9 +27,9 @@ import { pollPresence } from './store-presence-polling.ts'
 import {
   postgresNotifications,
   postgresNotificationChannel,
-  POSTGRES_NOTIFICATIONS_SQL,
   type PostgresListenerConnection,
 } from './postgres-notifications.ts'
+import { checkPostgresSchema } from './postgres-schema.ts'
 import { retryableLazy } from './retryable-lazy.ts'
 import { postgresNotificationScope } from './postgres-notification-scope.ts'
 import { postgresPoolClient } from './postgres-pool.ts'
@@ -92,91 +92,6 @@ export type PostgresStore = A2Store & {
   close(): Promise<void>
 }
 
-const SCHEMA = `
-create table if not exists a2_events (
-  session_id   text    not null,
-  idx          bigint  not null,
-  event_type   text    not null,
-  payload      jsonb   not null,
-  event_id     text    not null,
-  created_at   bigint  not null,
-  cause        jsonb,
-  lane         text,
-  lane_ready   boolean not null default false,
-  processed_at bigint,
-  processed_by_attempt integer,
-  returned_event_ids jsonb,
-  first_claimed_at bigint,
-  last_claimed_at bigint,
-  attempt_count integer not null default 0,
-  failure_count integer not null default 0,
-  last_failed_at bigint,
-  last_failed_attempt integer,
-  last_error   text,
-  failed_at    bigint,
-  claim_holder text,
-  claim_expires_at bigint,
-  primary key (session_id, idx)
-);
-
-create unique index if not exists a2_events_event_id on a2_events (event_id);
-create index if not exists a2_events_unprocessed
-  on a2_events (session_id, idx) where processed_at is null;
-create index if not exists a2_events_lane_pending
-  on a2_events (session_id, lane, idx) where processed_at is null;
-create index if not exists a2_events_dispatch_ready
-  on a2_events (session_id, idx)
-  where lane_ready and processed_at is null and failed_at is null;
-create index if not exists a2_events_claim_expiry
-  on a2_events (session_id, claim_expires_at)
-  where lane_ready and processed_at is null and failed_at is null;
-
-create table if not exists a2_snapshots (
-  session_id   text   not null,
-  reducer_name text   not null,
-  up_to_index  bigint not null,
-  state        jsonb  not null,
-  updated_at   bigint not null,
-  primary key (session_id, reducer_name)
-);
-
-create table if not exists a2_snapshot_history (
-  session_id   text   not null,
-  reducer_name text   not null,
-  up_to_index  bigint not null,
-  state        jsonb  not null,
-  updated_at   bigint not null,
-  primary key (session_id, reducer_name, up_to_index)
-);
-
-create table if not exists a2_snapshot_pins (
-  session_id   text   not null,
-  event_index  bigint not null,
-  reducer_name text   not null,
-  up_to_index  bigint not null,
-  primary key (session_id, event_index, reducer_name, up_to_index)
-);
-
-create index if not exists a2_snapshot_pins_checkpoint
-  on a2_snapshot_pins (session_id, reducer_name, up_to_index);
-
-create table if not exists a2_clears (
-  session_id  text   primary key,
-  clear_index bigint not null
-);
-
-create table if not exists a2_presence (
-  ns          text   not null,
-  participant text   not null,
-  field       text   not null,
-  value       jsonb  not null,
-  seen        bigint not null,
-  at          bigint not null,
-  expires_at  bigint not null,
-  primary key (ns, participant, field)
-);
-`
-
 const asNumber = (value: unknown): number => Number(value) // bigint columns arrive as strings
 
 /**
@@ -281,37 +196,6 @@ const wrap = async <T>(fn: () => Promise<T>): Promise<T> => {
 
 const jsonb = (value: unknown): string => JSON.stringify(value) ?? 'null'
 
-const initializeSchema = async ({
-  client,
-  listen,
-}: {
-  client: PostgresClient
-  listen: boolean
-}): Promise<void> => {
-  const schema = SCHEMA + (listen ? POSTGRES_NOTIFICATIONS_SQL : '')
-  if (!client.connect) {
-    await client.query(schema)
-    return
-  }
-
-  const conn = await client.connect()
-  try {
-    await conn.query('begin')
-    // `if not exists` does not serialize concurrent catalog writes. Every
-    // serverless isolate takes the same transaction-scoped lock before DDL.
-    await conn.query(
-      "select pg_advisory_xact_lock(hashtext('a2:postgres:schema'))",
-    )
-    await conn.query(schema)
-    await conn.query('commit')
-  } catch (err) {
-    await conn.query('rollback').catch(() => {})
-    throw err
-  } finally {
-    conn.release()
-  }
-}
-
 const loadPg = async () =>
   import('pg').catch(() => {
     throw new A2Error(
@@ -420,12 +304,10 @@ export function postgres(options: PostgresStoreOptions = {}): PostgresStore {
     try {
       const listen = Boolean(options.listenConnectionString)
       const resource = lease.value
-      if (injected) await initializeSchema({ client: resource.client, listen })
-      else
-        await resource.initialize({
-          schema: SCHEMA + (listen ? POSTGRES_NOTIFICATIONS_SQL : ''),
-          run: () => initializeSchema({ client: resource.client, listen }),
-        })
+      await resource.initialize({
+        key: listen ? 'schema+triggers' : 'schema',
+        run: () => checkPostgresSchema({ client: resource.client, listen }),
+      })
       return lease
     } catch (error) {
       if (!injected) await lease.release().catch(() => {})

package/dist/ai-BMLlI2Ff.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ai-BMLlI2Ff.d.ts","names":[],"sources":["../src/ai-message-base.ts","../src/ai-control.ts","../src/ai-client-state.ts","../src/ai-projector.ts","../src/ai-progress-batches.ts","../src/ai-message-projection.ts","../src/ai.ts"],"mappings":";;;;KAGK;EAAc;;EAAsB;;EAAmB;;KACvD,aAAa,eAAe;KAC5B;EAAa,OAAO;;EAAiC,QAAQ;;KAEtD;EACV;EACA,SAAS;EACT,QAAQ,eAAe;;;;KCIb,UAAU,UAAU,YAAY;EAC1C;EACA,SAAS;EACT;EACA;;KAGU,eAAe,UAAU,YAAY;EAC3C;EAAgB,SAAS;EAAG;;EAC5B;EAAgB,SAAS;;EACzB;EAAgB;EAAiB;;EACjC;EAAkB;;EAElB;EACA;EACA;EACA;;EAEA;EAAgB;EAAgB;;EAChC;EAAiB;EAAgB,SAAS;EAAG;;EAC7C;EAAiB;;EACjB;;EACA;EAAuB,QAAQ;;EAC/B;EAAoB,UAAU;;EAC9B;EAAiB,UAAU;;EAC3B;EAAyB,SAAS;;EAClC;EAAiB,SAAS;;EAC1B;EAAqB,SAAS;;KAExB;EACV;EACA;EACA;EACA;;KAUU,WAAW,UAAU,YAAY;EAC3C;EACA,OAAO,UAAU;EACjB;;KA+BU;EAAa;EAAc;EAAY;;KACvC;EACV;EACA;EACA;EACA;EACA;EACA;EACA,QAAQ;;KAGE;EACV;EACA;EACA,MAAM;EACN,YAAY;;KAYF;EACV;EACA;EACA;EACA;IAAW;IAAe;IAAqB;;EAC/C;IAAS;IAAc;;;KAGb;EACV,SAAS;EACT;IACE;IACA;IACA,OAAO;IACP;IACA;IACA;IACA,eAAe;IACf;IACA;;;;;KCjIQ,aAAa,UAAU,aAAa,QAC9C,eAAe;EAEb;;KAYQ,oBAAoB,UAAU;EACxC;EACA,SAAS,aAAa;;;;KCfnB;EACH;EACA;EACA;EACA;EACA;EACA;EACA;;KAwJU;EACV,MAAM;EACN,WAAW;EACX,OAAO,eAAe;;;;KChJZ;EAAkB;EAAe,QAAQ;;KAChD,aAAa;EAAoB,MAAM;EAAY,OAAO;;KAEnD;EACV;EACA,MAAM;EACN,QAAQ,MAAM;;;;cCmgBH,mBAAoB;EAC/B;MACE,QAAQ;;;KCtcA;KAGA;KAEA,iBAAiB,YAAY;cAE5B,0BAA0B;KAU3B;EACV;EACA;EACA;EACA;EACA,QAAQ;;;KAIE;EACV;EACA;EACA,MAAM;;;;;;KASI,kBAAkB,UAAU,eAAa,KAAK;EACxD,OAAO,MAAM,qBAAqB;;KAGxB;EAA0B,WAAW;;KACrC;EAAyB;;KACzB,sBAAsB,UAAU;EAC1C,SAAS;;EAET;;KAEU;EAA4B;;KACnC;EACH;EACA;;EAEA;;KAEU,4BAA4B;EAEhC;EAAsB;;EACtB;EAAmB;;KAEf;EACV;IAAY;IAAgB;;EAC5B;EACA,QAAQ;EACR;EACA;;KAEU;EACV;EACA;EACA;;KAEU,wBAAwB;KACxB;EACV;EACA;EACA;EACA;EACA;;EAEA;EACA;;KAEU;;EAEV;EACA,QAAQ;;KAEE;EACV;EACA;EACA;EACA;EACA,eAAe;EACf,QAAQ;EACR;;KAEU;EACV;EACA;EACA;EACA;EACA;;EAEA;EACA;;KAEU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;KAEU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;KAEU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;;KAEU;EACV;EACA;EACA;EACA;EACA;EACA;;KAEU;EACV;EACA;EACA;EACA;EACA;EACA,WAAW;;KAED;EACV;EACA;EACA;EACA;EACA;EACA,OAAO;;KAEG;EACV;EACA;;KAEU;EAAkC;;KAClC;EACV;EACA,QAAQ;;KAEE;EACN;;EACA;EAAoB,QAAQ;;EAC5B;;KAEM;EACV;EACA;EACA;EACA;EACA;EACA;;KAEU,2BAA2B,UAAU;EAC/C;EACA;EACA;EACA,UAAU;EACV;EACA;EACA,QAAQ;;KAGE,YAAY,UAAU,cAAY;EAC5C,wBAAwB,iBAAiB,eAAe;EACxD,wBAAwB,iBAAiB;EACzC,sBAAsB,iBAAiB;EACvC,oBAAoB,iBAAiB;EACrC,+BAA+B,iBAAiB;EAChD,wBAAwB;IACtB;IACA;;EAEF,sBAAsB,iBAAiB;EACvC,qBAAqB,iBAAiB;EACtC,sBAAsB,iBAAiB,sBAAsB;EAC7D,wBAAwB,iBAAiB;EACzC,0BAA0B,iBAAiB;EAC3C,2BAA2B,iBAAiB;EAC5C,sBAAsB,iBAAiB;EACvC,yB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"}