@rotorsoft/act-tck 1.17.0 → 1.18.0

package/dist/@types/cache-differential-tck.d.ts

@@ -0,0 +1,80 @@
+import type { Cache } from "@rotorsoft/act/types";
+/**
+ * One {@link Cache} implementation to feed into
+ * {@link runCacheDifferentialTck}. The harness drives the identical
+ * generated workload against all of them, then compares the observable
+ * `get()` snapshot after every operation.
+ */
+export type DifferentialCache = {
+    /** Display name used in assertion messages and the describe block. */
+    readonly name: string;
+    /**
+     * Produces the cache under test. Called once in `beforeAll`; the
+     * harness owns its lifecycle (`dispose`). Must return an empty cache
+     * with capacity for at least {@link CacheDifferentialTckOptions.streams}
+     * entries so nothing is evicted mid-comparison.
+     */
+    readonly factory: () => Cache | Promise<Cache>;
+};
+/**
+ * Options for {@link runCacheDifferentialTck}.
+ */
+export type CacheDifferentialTckOptions = {
+    /** Display name for the differential suite. */
+    readonly name: string;
+    /**
+     * Two or more caches to drive in lockstep and compare. The first entry
+     * is the reference; every other cache's observable `get()` snapshot
+     * must match it exactly after every operation.
+     */
+    readonly caches: ReadonlyArray<DifferentialCache>;
+    /**
+     * Base PRNG seed. Workload `r` of {@link CacheDifferentialTckOptions.runs}
+     * is built from `seed + r`, so the campaign is reproducible. Default
+     * `0xcac`.
+     */
+    readonly seed?: number;
+    /**
+     * Number of distinct streams (cache keys) per workload. Kept small so a
+     * bounded cache never evicts during the comparison. Default `6`.
+     */
+    readonly streams?: number;
+    /**
+     * How many independent randomized workloads to generate and compare,
+     * each from a distinct seed. Default `8`.
+     */
+    readonly runs?: number;
+};
+/**
+ * Cross-implementation differential contract for the {@link Cache} port
+ * (#1057).
+ *
+ * Where {@link runCacheTck} pins each method's contract against a single
+ * implementation, this harness drives a **family of randomized, seeded
+ * workloads** (`set` / `invalidate` / `clear`) against two or more caches
+ * in lockstep and asserts their observable `get()` snapshot is identical
+ * after **every** operation. A cache that mishandles overwrite ordering,
+ * leaks an invalidated key, or clears partially diverges from the
+ * reference on the exact operation that broke it — with the seed in the
+ * describe block for replay.
+ *
+ * Streams stay within the cache's capacity, so eviction (an adapter
+ * policy, not a contract guarantee) never enters the comparison.
+ *
+ * @example
+ * ```ts
+ * import { runCacheDifferentialTck } from "@rotorsoft/act-tck";
+ * import { InMemoryCache } from "@rotorsoft/act";
+ * import { RedisCache } from "../src/index.js";
+ *
+ * runCacheDifferentialTck({
+ *   name: "InMemory vs Redis",
+ *   caches: [
+ *     { name: "InMemoryCache", factory: () => new InMemoryCache({ maxSize: 1000 }) },
+ *     { name: "RedisCache", factory: () => new RedisCache({ url: process.env.REDIS_URL }) },
+ *   ],
+ * });
+ * ```
+ */
+export declare const runCacheDifferentialTck: (options: CacheDifferentialTckOptions) => void;
+//# sourceMappingURL=cache-differential-tck.d.ts.map

package/dist/@types/cache-differential-tck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-differential-tck.d.ts","sourceRoot":"","sources":["../../src/cache-differential-tck.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAc,MAAM,sBAAsB,CAAC;AAI9D;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;CAChD,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,2BAA2B,GAAG;IACxC,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;IAClD;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AA6FF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,uBAAuB,GAClC,SAAS,2BAA2B,KACnC,IAsCF,CAAC"}

package/dist/@types/index.d.ts

@@ -59,16 +59,22 @@
  * adapters keep passing until they explicitly opt in.
  */
 export type { Cache, CacheEntry, Logger, Store, StoreNotification, } from "@rotorsoft/act/types";
+export type { CacheDifferentialTckOptions, DifferentialCache, } from "./cache-differential-tck.js";
+export { runCacheDifferentialTck } from "./cache-differential-tck.js";
 export type { CacheTckOptions } from "./cache-tck.js";
 export { runCacheTck } from "./cache-tck.js";
 export type { CounterEvents } from "./fixtures/events.js";
 export { COUNTER_EVENT_NAMES, CounterSchemas, Decremented, Incremented, Reset, } from "./fixtures/events.js";
 export type { CommittedCounterEvent, CounterMessage, } from "./fixtures/helpers.js";
 export { actor, collect, dec, inc, reset, uid, } from "./fixtures/helpers.js";
+export type { DifferentialLogger, LoggerDifferentialTckOptions, } from "./logger-differential-tck.js";
+export { runLoggerDifferentialTck } from "./logger-differential-tck.js";
 export type { LoggerTckOptions } from "./logger-tck.js";
 export { runLoggerTck } from "./logger-tck.js";
 export type { StabilityTckOptions } from "./stability-tck.js";
 export { runStabilityTck } from "./stability-tck.js";
+export type { DifferentialStore, StoreDifferentialTckOptions, } from "./store-differential-tck.js";
+export { runStoreDifferentialTck } from "./store-differential-tck.js";
 export type { StorePropertyTckOptions } from "./store-property-tck.js";
 export { runStorePropertyTck } from "./store-property-tck.js";
 export type { StoreCapabilities, StoreTckOptions } from "./store-tck.js";

package/dist/@types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAOH,YAAY,EACV,KAAK,EACL,UAAU,EACV,MAAM,EACN,KAAK,EACL,iBAAiB,GAClB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,WAAW,EACX,WAAW,EACX,KAAK,GACN,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,qBAAqB,EACrB,cAAc,GACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,KAAK,EACL,OAAO,EACP,GAAG,EACH,GAAG,EACH,KAAK,EACL,GAAG,GACJ,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,YAAY,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,YAAY,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAOH,YAAY,EACV,KAAK,EACL,UAAU,EACV,MAAM,EACN,KAAK,EACL,iBAAiB,GAClB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,2BAA2B,EAC3B,iBAAiB,GAClB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,WAAW,EACX,WAAW,EACX,KAAK,GACN,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,qBAAqB,EACrB,cAAc,GACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,KAAK,EACL,OAAO,EACP,GAAG,EACH,GAAG,EACH,KAAK,EACL,GAAG,GACJ,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,kBAAkB,EAClB,4BAA4B,GAC7B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,YAAY,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,YAAY,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,YAAY,EACV,iBAAiB,EACjB,2BAA2B,GAC5B,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,YAAY,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/@types/logger-differential-tck.d.ts

@@ -0,0 +1,61 @@
+import type { Logger } from "@rotorsoft/act/types";
+/**
+ * One {@link Logger} implementation to feed into
+ * {@link runLoggerDifferentialTck}. The harness drives the identical call
+ * sequence against all of them and compares the **portable** observable
+ * contract — robustness (does a call throw?) and structural conformance
+ * (is `level` a non-empty string, does `child()` satisfy the contract).
+ */
+export type DifferentialLogger = {
+    /** Display name used in assertion messages and the describe block. */
+    readonly name: string;
+    /**
+     * Produces the logger under test. Called before each test; the harness
+     * owns its lifecycle (`dispose`).
+     */
+    readonly factory: () => Logger;
+};
+/**
+ * Options for {@link runLoggerDifferentialTck}.
+ */
+export type LoggerDifferentialTckOptions = {
+    /** Display name for the differential suite. */
+    readonly name: string;
+    /**
+     * Two or more loggers to drive in lockstep and compare. The first entry
+     * is the reference; every other logger must uphold the same portable
+     * observable contract under the identical call sequence.
+     */
+    readonly loggers: ReadonlyArray<DifferentialLogger>;
+};
+/**
+ * Cross-implementation differential contract for the {@link Logger} port
+ * (#1057).
+ *
+ * A logger has no portable return value to byte-compare — its output
+ * format is adapter-specific by design, which is exactly why
+ * {@link runLoggerTck} checks shape rather than bytes. The meaningful
+ * differential is therefore **robustness and structural parity**: driven
+ * through the identical call sequence (every level, both overloads, null
+ * and cyclic payloads, child spawning), do two implementations agree on
+ * what throws and what conforms? They must. A logger that throws on a
+ * cyclic payload the reference tolerates, or returns a non-conforming
+ * child, diverges from the reference vector.
+ *
+ * @example
+ * ```ts
+ * import { runLoggerDifferentialTck } from "@rotorsoft/act-tck";
+ * import { ConsoleLogger } from "@rotorsoft/act";
+ * import { PinoLogger } from "../src/index.js";
+ *
+ * runLoggerDifferentialTck({
+ *   name: "Console vs Pino",
+ *   loggers: [
+ *     { name: "ConsoleLogger", factory: () => new ConsoleLogger({ level: "trace" }) },
+ *     { name: "PinoLogger", factory: () => new PinoLogger({ level: "trace" }) },
+ *   ],
+ * });
+ * ```
+ */
+export declare const runLoggerDifferentialTck: (options: LoggerDifferentialTckOptions) => void;
+//# sourceMappingURL=logger-differential-tck.d.ts.map

package/dist/@types/logger-differential-tck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger-differential-tck.d.ts","sourceRoot":"","sources":["../../src/logger-differential-tck.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAGnD;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,MAAM,CAAC;CAChC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG;IACzC,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAAC;CACrD,CAAC;AAwDF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,wBAAwB,GACnC,SAAS,4BAA4B,KACpC,IA+BF,CAAC"}

package/dist/@types/store-differential-tck.d.ts

@@ -0,0 +1,93 @@
+import type { Store } from "@rotorsoft/act/types";
+/**
+ * One {@link Store} implementation to feed into
+ * {@link runStoreDifferentialTck}. The harness drops + seeds each store,
+ * replays the identical generated workload against all of them, then
+ * compares their normalized outputs.
+ */
+export type DifferentialStore = {
+    /** Display name used in assertion messages and the describe block. */
+    readonly name: string;
+    /**
+     * Produces the store under test. Called once in `beforeAll`; the
+     * harness owns its lifecycle (`drop` + `seed`, then `dispose`).
+     */
+    readonly factory: () => Store | Promise<Store>;
+};
+/**
+ * Options for {@link runStoreDifferentialTck}.
+ */
+export type StoreDifferentialTckOptions = {
+    /** Display name for the differential suite. */
+    readonly name: string;
+    /**
+     * Two or more stores to drive in lockstep and compare. The first
+     * entry is the reference; every other store's normalized output must
+     * match it exactly. Pass `InMemoryStore` as the reference and the
+     * durable adapter(s) as the comparands.
+     */
+    readonly stores: ReadonlyArray<DifferentialStore>;
+    /**
+     * Base PRNG seed. Workload `r` of {@link StoreDifferentialTckOptions.runs}
+     * is built from `seed + r`, so the whole fuzz campaign is reproducible:
+     * the same `seed` ⇒ the same family of workloads ⇒ any divergence is
+     * deterministically replayable. Default `0xac7`.
+     */
+    readonly seed?: number;
+    /**
+     * Number of distinct event-bearing streams per workload.
+     * Default `4`.
+     */
+    readonly streams?: number;
+    /**
+     * How many independent randomized workloads to generate and compare,
+     * each from a distinct seed (`seed`, `seed + 1`, …, `seed + runs - 1`).
+     * More runs widen the slice of the input space the differential
+     * explores; fewer keep durable-adapter suites fast. Default `8`.
+     */
+    readonly runs?: number;
+};
+/**
+ * Cross-adapter differential contract (#1030, fuzz workloads #1057).
+ *
+ * Adapters can drift in ways per-adapter cases don't catch — event
+ * ordering, the `with_snaps` snapshot floor, the exact shape of
+ * `query_stats` / `query_streams` output. This harness drives a **family
+ * of randomized, seeded workloads** (commits, inline snapshots, truncates,
+ * subscriptions) against every store in `options.stores`, then asserts
+ * their **normalized** outputs are byte-for-byte identical for every
+ * workload.
+ *
+ * Each workload is its own seeded plan (`seed`, `seed + 1`, …): the
+ * operation sequence — and even its length — varies by seed, so divergence
+ * is hunted across a slice of the input space rather than one fixed script.
+ * The seeds are deterministic, so a failing workload is always replayable.
+ *
+ * Normalization drops only the fields that legitimately differ between
+ * stores (absolute event ids, `created` timestamps, correlation/causation
+ * uuids) and keeps everything that defines correctness (stream, version,
+ * name, data, and emission order). A one-adapter `with_snaps` regression —
+ * the canonical failure mode — surfaces as a diff against the in-memory
+ * reference, with the offending seed in the describe block.
+ *
+ * Wire it with the in-memory store as the reference and one or more
+ * durable adapters as comparands:
+ *
+ * @example
+ * ```ts
+ * import { runStoreDifferentialTck } from "@rotorsoft/act-tck";
+ * import { InMemoryStore } from "@rotorsoft/act";
+ * import { PostgresStore } from "../src/index.js";
+ *
+ * runStoreDifferentialTck({
+ *   name: "InMemory vs Postgres",
+ *   runs: 6, // durable adapter: fewer workloads keep the suite fast
+ *   stores: [
+ *     { name: "InMemoryStore", factory: () => new InMemoryStore() },
+ *     { name: "PostgresStore", factory: () => new PostgresStore({ ... }) },
+ *   ],
+ * });
+ * ```
+ */
+export declare const runStoreDifferentialTck: (options: StoreDifferentialTckOptions) => void;
+//# sourceMappingURL=store-differential-tck.d.ts.map

package/dist/@types/store-differential-tck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-differential-tck.d.ts","sourceRoot":"","sources":["../../src/store-differential-tck.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAsB,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAYtE;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;CAChD,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,2BAA2B,GAAG;IACxC,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;IAClD;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAmLF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,uBAAuB,GAClC,SAAS,2BAA2B,KACnC,IAwKF,CAAC"}

package/dist/@types/store-tck.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-tck.d.ts","sourceRoot":"","sources":["../../src/store-tck.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAQV,KAAK,EAEN,MAAM,sBAAsB,CAAC;AAc9B;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC;;;;;;;;;OASG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC;;;;;;;;OAQG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;CACnC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC/C;;OAEG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAC3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,eAAe,KAAG,IAolFtD,CAAC"}
+{"version":3,"file":"store-tck.d.ts","sourceRoot":"","sources":["../../src/store-tck.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAQV,KAAK,EAEN,MAAM,sBAAsB,CAAC;AAc9B;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC;;;;;;;;;OASG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC;;;;;;;;OAQG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;CACnC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC/C;;OAEG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAC3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,eAAe,KAAG,IAyuFtD,CAAC"}