alchemy 2.0.0-beta.70 → 2.0.0-beta.71

package/src/SQL/ConnectionSource.ts

@@ -0,0 +1,101 @@
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import * as Output from "../Output.ts";
+import type { RuntimeContext } from "../RuntimeContext.ts";
+import { sha256 } from "../Util/sha256.ts";
+
+/**
+ * A database connection-string source, in every shape alchemy hands them
+ * out:
+ *
+ * - a literal / `Redacted` string
+ * - a resource Output (Neon `project.connectionUri`, PlanetScale
+ *   `role.connectionUrl`, Prisma `connection.databaseUrl`, ...) — bound
+ *   into the host environment at deploy and read back at runtime
+ * - a runtime-only Effect (Cloudflare Hyperdrive's per-invocation
+ *   `connectionString`)
+ */
+export type ConnectionSource =
+  | string
+  | Redacted.Redacted<string>
+  | Output.Output<string>
+  | Output.Output<Redacted.Redacted<string>>
+  | Effect.Effect<Redacted.Redacted<string>, never, RuntimeContext>;
+
+/**
+ * The deploy-resolvable subset of {@link ConnectionSource}: literals and
+ * resource Outputs. Runtime-only Effects (Hyperdrive) are excluded —
+ * deploy-time consumers (migrations, seeds) need a value that resolves
+ * during stack evaluation.
+ */
+export type StaticConnectionSource = Exclude<
+  ConnectionSource,
+  Effect.Effect<Redacted.Redacted<string>, never, RuntimeContext>
+>;
+
+const toRedacted = (
+  value: string | Redacted.Redacted<string>,
+): Redacted.Redacted<string> =>
+  typeof value === "string" ? Redacted.make(value) : value;
+
+/**
+ * Resolve a {@link ConnectionSource} to its runtime accessor effect.
+ *
+ * Outputs are yielded NOW (binding into the host environment during a
+ * host init, or recording an Action capture during an Action init) and
+ * the returned accessor reads the resolved value back later; Effects pass
+ * through untouched; literals wrap.
+ */
+export const resolveConnectionSource = (
+  source: ConnectionSource,
+): Effect.Effect<Effect.Effect<Redacted.Redacted<string>>> =>
+  Effect.gen(function* () {
+    if (Output.isOutput(source)) {
+      const accessor = yield* source;
+      return Effect.map(
+        accessor as Effect.Effect<string | Redacted.Redacted<string>>,
+        toRedacted,
+      );
+    }
+    if (Effect.isEffect(source)) {
+      return source as Effect.Effect<Redacted.Redacted<string>>;
+    }
+    return Effect.succeed(toRedacted(source));
+  }) as Effect.Effect<Effect.Effect<Redacted.Redacted<string>>>;
+
+/**
+ * Pick the deploy-resolvable source for deploy-time work (migrations,
+ * seeds): an explicit override wins, `false` disables, and the primary
+ * source is a valid default only when it is itself deploy-resolvable.
+ */
+export const staticConnectionSource = (
+  source: ConnectionSource,
+  override: StaticConnectionSource | false | undefined,
+): StaticConnectionSource | undefined => {
+  if (override === false) {
+    return undefined;
+  }
+  if (override !== undefined) {
+    return override;
+  }
+  return Effect.isEffect(source) && !Output.isOutput(source)
+    ? undefined
+    : (source as StaticConnectionSource);
+};
+
+/**
+ * Non-secret digest of a connection source — a sha256 Output suitable for
+ * persisted identity inputs (e.g. a migration Action's diff key) where the
+ * connection string itself must never be stored.
+ */
+export const connectionSourceDigest = (
+  source: StaticConnectionSource,
+): Output.Output<string> => {
+  const digest = (value: string | Redacted.Redacted<string>) =>
+    sha256(typeof value === "string" ? value : Redacted.value(value));
+  return Output.isOutput(source)
+    ? (Output.mapEffect(digest)(
+        source as Output.Output<string | Redacted.Redacted<string>>,
+      ) as Output.Output<string>)
+    : (Output.fromEffect(digest(source)) as Output.Output<string>);
+};

package/src/SQL/MySQLDriver.ts

@@ -0,0 +1,49 @@
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import type * as Scope from "effect/Scope";
+import type { Pool, PoolOptions } from "mysql2/promise";
+
+/**
+ * Lazily load the `mysql2/promise` driver (an optional peer dependency of
+ * alchemy) with a descriptive failure when it isn't installed. The
+ * promise flavor is the canonical surface — its `.pool` property exposes
+ * the callback pool for consumers (like Kysely) that drive that API.
+ */
+export const importMySql = (): Promise<typeof import("mysql2/promise")> =>
+  import("mysql2/promise")
+    .then((mod) =>
+      (mod as { default?: { createPool?: unknown } }).default?.createPool !==
+      undefined
+        ? (mod as unknown as { default: typeof import("mysql2/promise") })
+            .default
+        : mod,
+    )
+    .catch((cause) => {
+      throw new Error(
+        "Failed to load the 'mysql2' driver. Install the optional peer dependency 'mysql2' to connect to MySQL.",
+        { cause },
+      );
+    });
+
+/**
+ * Open a raw `mysql2/promise` pool on the current `Scope` — `pool.end()`
+ * runs when the scope closes. Pair with `makeExecutionMemo` for the
+ * one-pool-per-event shape workerd and Lambda require.
+ *
+ * `connectionLimit` defaults to 1: per-execution pools never need more
+ * than one connection.
+ */
+export const openMySQLPool = (
+  url: Effect.Effect<Redacted.Redacted<string>>,
+  config?: Omit<PoolOptions, "uri">,
+): Effect.Effect<Pool, never, Scope.Scope> =>
+  Effect.gen(function* () {
+    const mysql = yield* Effect.promise(importMySql);
+    const uri = Redacted.value(yield* url);
+    return yield* Effect.acquireRelease(
+      Effect.sync(() =>
+        mysql.createPool({ uri, connectionLimit: 1, ...config }),
+      ),
+      (pool) => Effect.promise(() => pool.end()),
+    );
+  });

package/src/SQL/PostgresDriver.ts

@@ -0,0 +1,45 @@
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import type * as Scope from "effect/Scope";
+import type { Pool, PoolConfig } from "pg";
+
+/**
+ * Lazily load the raw `pg` driver (an optional peer dependency of
+ * alchemy) with a descriptive failure when it isn't installed. CJS/ESM
+ * interop is normalized — callers always get the module's named surface.
+ */
+export const importPg = (): Promise<typeof import("pg")> =>
+  import("pg")
+    .then((mod) =>
+      (mod as { default?: { Pool?: unknown } }).default?.Pool !== undefined
+        ? (mod as unknown as { default: typeof import("pg") }).default
+        : mod,
+    )
+    .catch((cause) => {
+      throw new Error(
+        "Failed to load the 'pg' driver. Install the optional peer dependency 'pg' to connect to Postgres.",
+        { cause },
+      );
+    });
+
+/**
+ * Open a raw `pg.Pool` on the current `Scope` — `pool.end()` runs when the
+ * scope closes. Pair with `makeExecutionMemo` for the one-pool-per-event
+ * shape workerd and Lambda require (see `SQL/Postgres.ts` for the
+ * effect-sql equivalent).
+ *
+ * `max` defaults to 1: per-execution pools never need more than one
+ * connection.
+ */
+export const openPostgresPool = (
+  url: Effect.Effect<Redacted.Redacted<string>>,
+  config?: Omit<PoolConfig, "connectionString">,
+): Effect.Effect<Pool, never, Scope.Scope> =>
+  Effect.gen(function* () {
+    const pg = yield* Effect.promise(importPg);
+    const connectionString = Redacted.value(yield* url);
+    return yield* Effect.acquireRelease(
+      Effect.sync(() => new pg.Pool({ connectionString, max: 1, ...config })),
+      (pool) => Effect.promise(() => pool.end()),
+    );
+  });

package/src/State/LocalState.ts

@@ -215,6 +215,30 @@ export const makeLocalState = () =>
                 }
               }),
             ),
+            // Deleting the last stage leaves an empty `{stack}/` husk that
+            // `listStacks` would keep reporting forever (and durable
+            // per-test scratch stacks would accumulate one per test). Prune
+            // it when no stages remain. The read-then-remove is not racy:
+            // nothing recreates a stage dir concurrently with the session
+            // that is deleting it (same invariant as recoverMissingDir).
+            Effect.tap(() => {
+              if (stage === undefined) return Effect.void;
+              const stackDir = path.join(stateDir, stack);
+              return fs.readDirectory(stackDir).pipe(
+                Effect.flatMap((entries) =>
+                  entries.length === 0
+                    ? fs
+                        .remove(stackDir, { recursive: true })
+                        .pipe(
+                          Effect.tap(() =>
+                            Effect.sync(() => created.delete(stackDir)),
+                          ),
+                        )
+                    : Effect.void,
+                ),
+                Effect.ignore,
+              );
+            }),
           );
         }),
       list: (request) =>

package/src/State/ResourceState.ts

@@ -68,8 +68,12 @@ interface BaseResourceState {
    *
    * `undefined` means either a mode-agnostic provider (single
    * implementation serves both dev and deploy) or a legacy row written
-   * before modes were persisted — both are treated as "whatever the
-   * current run's mode is" (no replacement churn).
+   * before modes were persisted — both acted on the real cloud, so an
+   * unstamped row is assumed **live**, unless its attrs carry a local
+   * identity marker (`dev:`-prefixed ids) proving it was reconciled
+   * locally, in which case it is assumed **local** (see `stampedMode`).
+   * Same-mode runs see no churn; a run in the other mode replaces it like
+   * any stamped row.
    */
   providerMode?: ProviderMode;
 }

package/src/State/StateEncoding.ts

@@ -18,6 +18,21 @@ export const REDACTED_MARKER = "__redacted__";
  */
 export const DURATION_MARKER = "__duration__";
 
+/**
+ * JSON marker used to tag a `Date` value when writing state. The reviver
+ * recognises objects with exactly this key and rebuilds a real `Date`
+ * instance on read, so a Date-typed prop read back out of persisted state
+ * (`olds` in provider `diff`/`delete`/`read`) is a `Date` again — not the
+ * bare ISO string `JSON.stringify` would otherwise leave behind.
+ */
+export const DATE_MARKER = "__date__";
+
+const decodeDate = (encoded: unknown): Date | undefined => {
+  if (typeof encoded !== "string") return undefined;
+  const date = new Date(encoded);
+  return Number.isNaN(date.getTime()) ? undefined : date;
+};
+
 const decodeDuration = (encoded: unknown): Duration.Duration | undefined => {
   if (encoded === null || typeof encoded !== "object") return undefined;
   const json = encoded as {
@@ -77,6 +92,16 @@ export const encodeState = (value: unknown): unknown => {
       [DURATION_MARKER]: value.toJSON(),
     };
   }
+  // Dates are serializable leaves and must round-trip: walking one
+  // structurally would persist `{}` (`Object.entries(new Date())` is empty)
+  // — and every later plan would then diff the empty object against the
+  // program's Date and churn a phantom update forever. Tag with our marker
+  // so the reviver rebuilds a real Date instance; rows written before the
+  // marker carry a bare ISO string, which `canonicalize` in Diff.ts still
+  // compares as equal to a live Date, so legacy rows never churn either.
+  if (value instanceof Date) {
+    return { [DATE_MARKER]: value.toJSON() };
+  }
   if (isResource(value)) {
     return {
       id: value.LogicalId,
@@ -110,6 +135,14 @@ export const reviveState = (_key: string, value: unknown): unknown => {
       const decoded = decodeDuration(obj[DURATION_MARKER]);
       if (decoded !== undefined) return decoded;
     }
+    // Exact single-key match only — unlike the legacy REDACTED/DURATION
+    // markers there is no pre-marker data to tolerate, so a user object
+    // that merely CONTAINS the key alongside other fields is never
+    // collapsed into a Date (mirrors reviveStateRecursive's strictness).
+    if (DATE_MARKER in obj && Object.keys(obj).length === 1) {
+      const decoded = decodeDate(obj[DATE_MARKER]);
+      if (decoded !== undefined) return decoded;
+    }
   }
   return value;
 };
@@ -133,6 +166,10 @@ export const reviveStateRecursive = (value: unknown): unknown => {
     const decoded = decodeDuration(obj[DURATION_MARKER]);
     if (decoded !== undefined) return decoded;
   }
+  if (keys.length === 1 && keys[0] === DATE_MARKER) {
+    const decoded = decodeDate(obj[DATE_MARKER]);
+    if (decoded !== undefined) return decoded;
+  }
   const result: Record<string, unknown> = {};
   for (const [k, v] of Object.entries(obj)) {
     result[k] = reviveStateRecursive(v);

package/src/Sync.ts

@@ -15,6 +15,7 @@ import { deepEqual } from "./Diff.ts";
 import { InstanceId } from "./InstanceId.ts";
 import type { Apply, Plan } from "./Plan.ts";
 import { findProviderByType, Provider } from "./Provider.ts";
+import { stampedMode } from "./ProviderMode.ts";
 import type { ResourceLike } from "./Resource.ts";
 import {
   isActionState,
@@ -187,9 +188,10 @@ export const sync = (
 
       // Observe with the provider variant of the mode that created the row —
       // a local dev worker's state must be read by the local provider.
+      // Legacy unstamped rows infer "local" from a `dev:` identity marker.
       const provider = yield* findProviderByType(
         resourceType,
-        old.providerMode,
+        stampedMode(old),
       );
       if (!provider.read) {
         return yield* skip(
@@ -445,7 +447,7 @@ export const plan = (stack: {
       // switches modes — a local ⇄ live switch is a plan-time replacement).
       const provider = yield* findProviderByType(
         persisted.resourceType,
-        persisted.providerMode,
+        stampedMode(persisted),
       );
       const action =
         r.action === "drifted"

package/src/Test/Alchemy.ts

@@ -9,6 +9,7 @@
  * concurrency + timeouts itself.
  */
 import {
+  currentFile,
   exclusiveOf,
   registerHook,
   registerTest,
@@ -166,14 +167,20 @@ export const make = <ROut = any>(options: MakeOptions<ROut>): TestApi => {
   const wrapProvider = (
     name: string,
     fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
+    file: string | undefined,
   ) => {
-    const scratch = Core.scratchStack(options, name);
+    // Durable, file-namespaced scratch state (`.alchemy/state`). A run that
+    // dies mid-delete — e.g. the runner abandons teardown 10s after a test
+    // timeout while a CloudFront disable-wait is still in flight — leaves
+    // its `deleting` rows on disk, so the NEXT run's leading
+    // `stack.destroy()` (or the ensuring teardown below) resumes and drains
+    // them instead of planning "no changes" and silently orphaning the
+    // cloud resource.
+    const scratch = Core.scratchStack(options, name, file);
     // Guarantee teardown. `test.provider` has no built-in cleanup, so a body
     // that fails (assertion, API error like a 409/Unauthorized) or is
     // interrupted (timeout) BEFORE its trailing `stack.destroy()` would
-    // otherwise leak every cloud resource it deployed: the scratch's
-    // in-memory state is discarded with the process, so no later run can
-    // reclaim the orphan (only an account-wide `nuke` can).
+    // otherwise leak every cloud resource it deployed.
     // `scratch.destroy()` is idempotent — a no-op when the body already
     // destroyed, and it reclaims the orphans otherwise. `Effect.ensuring`
     // runs the finalizer on success, failure, AND interruption.
@@ -193,15 +200,19 @@ export const make = <ROut = any>(options: MakeOptions<ROut>): TestApi => {
     fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
     opts: TestOptions | undefined,
     mode: "run" | "skip",
-  ) =>
+  ) => {
+    // Captured at registration (module evaluation during collection) — the
+    // AsyncLocalStorage file context is gone by the time the body runs.
+    const file = currentFile();
     registerTest({
       name,
       mode,
       exclusive: exclusiveOf(opts),
       retry: retryOf(opts),
       timeout: timeoutOf(opts),
-      body: mode === "skip" ? undefined : () => wrapProvider(name, fn),
+      body: mode === "skip" ? undefined : () => wrapProvider(name, fn, file),
     });
+  };
 
   const provider = ((name, fn, opts) => {
     addProvider(name, fn, opts, "run");

package/src/Test/Core.ts

@@ -316,11 +316,21 @@ export const destroy = (
 /**
  * In-test scratch stack handed to `test.provider(name, (stack) => ...)`.
  *
- * Each scratch stack owns a private in-memory state store that is shared
- * between successive `deploy`/`destroy` calls AND visible to the user's test
- * body (so `yield* State` / `state.get(...)` see the same store the deploys
+ * Each scratch stack owns a private state store that is shared between
+ * successive `deploy`/`destroy` calls AND visible to the user's test body
+ * (so `yield* State` / `state.get(...)` see the same store the deploys
  * mutated). This makes create / update / replace / delete paths exercisable
- * without polluting `.alchemy/` or other tests in the same file.
+ * without polluting other tests in the same file.
+ *
+ * When the adapter can name the test file (the alchemy-test runner), the
+ * store is DURABLE — rows live under `.alchemy/state/{file}-{test}/{stage}`
+ * on disk. Durability is what makes an interrupted destroy recoverable: the
+ * engine persists a `deleting` row before every `provider.delete` and only
+ * drops it on success, so a run killed mid-delete (e.g. the runner's
+ * teardown-abandonment after a test timeout) leaves resumable rows that the
+ * NEXT run's leading `stack.destroy()` (or the `Effect.ensuring` teardown)
+ * picks up and drains. An in-memory scratch dies with the process, silently
+ * orphaning every cloud resource whose delete was still in flight.
  */
 export interface ScratchStack<ROut = any> {
   readonly name: string;
@@ -347,24 +357,41 @@ const sanitizeStackName = (name: string) =>
   name.replaceAll(/[^a-zA-Z0-9_]/g, "-").replace(/-+/g, "-");
 
 /**
- * Build a fresh `ScratchStack` for `test.provider`. Allocates a private
- * in-memory state store so the test is isolated from `.alchemy/` and from
- * other tests in the same file.
+ * Turn a test-file path (relative to the run root) into a stack-name
+ * namespace: `test/AWS/Website/Router.test.ts` -> `AWS/Website/Router`.
+ * Test names repeat across files (e.g. "create and delete bucket with
+ * default props"), so the durable per-test store MUST be namespaced by file
+ * or two concurrently-running same-named tests would read, write and — far
+ * worse — destroy each other's rows.
+ */
+const scratchNamespace = (file: string) =>
+  file.replace(/^test[/\\]/, "").replace(/\.test\.ts$/, "");
+
+/**
+ * Build a fresh `ScratchStack` for `test.provider`.
+ *
+ * With `file` (the registration-time test file, supplied by the
+ * alchemy-test adapter): the store is the durable `.alchemy/state` local
+ * store and the stack name is namespaced by file so interrupted destroys
+ * leave resumable rows for the next run (see {@link ScratchStack}).
+ *
+ * Without `file` (bun/vitest adapters, which cannot name their file at
+ * registration time): falls back to a private in-memory store — isolated,
+ * but discarded with the process.
  */
 export const scratchStack = <ROut>(
   options: MakeOptions<ROut>,
   name: string,
+  file?: string,
 ): ScratchStack<ROut> => {
   const stage = options.stage ?? "test";
-  const stackName = sanitizeStackName(name);
-  const inMemory: Record<
-    string,
-    Record<string, Record<string, State.ResourceState>>
-  > = {};
-  const stateLayer = Layer.succeed(
-    State.State,
-    State.InMemoryService(inMemory),
+  const stackName = sanitizeStackName(
+    file === undefined ? name : `${scratchNamespace(file)}-${name}`,
   );
+  const stateLayer: Layer.Layer<State.State> =
+    file === undefined
+      ? Layer.succeed(State.State, State.InMemoryService({}))
+      : Layer.provide(State.localState(), PlatformServices);
 
   const buildAndApply = (effect: Effect.Effect<any, any, any>) =>
     (effect as Effect.Effect<any, any, never>).pipe(

package/lib/Drizzle/DurableObject.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DurableObject.d.ts","sourceRoot":"","sources":["../../src/Drizzle/DurableObject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,cAAc,MAAM,oCAAoC,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,KAAK,eAAe,MAAM,8BAA8B,CAAC;AAEhE,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,kBAAkB,EAAE,MAAM,6CAA6C,CAAC;AAEjF;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5C,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/C;AAED,MAAM,WAAW,mBAAmB,CAClC,UAAU,SAAS,YAAY,GAAG,cAAc,CAChD,SAAQ,IAAI,CACZ,eAAe,CAAC,2BAA2B,CAAC,UAAU,CAAC,EACvD,SAAS,CACV;IACC;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,uBAAuB,GAAG,SAAS,CAAC;CAC3D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH,eAAO,MAAM,aAAa,GACxB,UAAU,SAAS,YAAY;;4DA2B/B,CAAC"}

package/lib/Drizzle/DurableObject.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DurableObject.js","sourceRoot":"","sources":["../../src/Drizzle/DurableObject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,cAAc,MAAM,oCAAoC,CAAC;AAErE,OAAO,KAAK,eAAe,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,OAAO,EAAE,MAAM,uCAAuC,CAAC;AAChE,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,kBAAkB,EAAE,MAAM,6CAA6C,CAAC;AAyBjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,EAAE,CAAC,uBAAuB,CAAC,CAAC,QAAQ,CAAC,EAEvE,MAAwC;IACxC,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,kBAAkB,CAAC;IACxC,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC;IAClC,MAAM,EAAE,UAAU,EAAE,GAAG,aAAa,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC;IACtD,oEAAoE;IACpE,sEAAsE;IACtE,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;IACvE,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC,eAAe,CAAC,gBAAgB,CAAC;QACjD,GAAI,aAGF;QACF,OAAO;KACR,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC;IACzC,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC7B,qEAAqE;QACrE,oEAAoE;QACpE,sDAAsD;QACtD,KAAK,CAAC,CAAC,OAAO,CAAC,EAAE,EAAE;YACjB,UAAU,EAAE,UAAU,CAAC,UAAU;YACjC,GAAG,CAAC,UAAU,CAAC,eAAe,KAAK,SAAS;gBAC1C,CAAC,CAAC,EAAE,eAAe,EAAE,UAAU,CAAC,eAAe,EAAE;gBACjD,CAAC,CAAC,EAAE,CAAC;SACR,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACxB,CAAC;IACD,OAAO,EAAE,CAAC;AACZ,CAAC,CAAC,CAAC"}