@kairos-es/feed-postgres 0.0.0-stage → 0.0.0

package/dist/dts-cjs/syncStore.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The Postgres `FeedSyncStore`: every sink's cursor, its parked list and its
+ * worker lease, kept in the source database beside the feed rows (ADR-0019 §10).
+ *
+ * `@kairos-es/feed`'s `FeedSyncStore.ts` owns the contract, and the in-memory feed
+ * is the oracle this store is held to; what is here is how each atomic step the
+ * contract names becomes one transaction or one statement.
+ *
+ * - `casCursor` is ONE transaction: the guarded, holder-fenced cursor update,
+ *   stamped with its `lastAdvance` from this process's `Clock`, and the parked
+ *   list moved with it. A guard that loses fails `CursorSuperseded` inside the
+ *   transaction, which rolls back the parked changes with it, so a park can never
+ *   outlive a refused advance.
+ * - `retryParked` is one transaction that takes the feed lock exclusively before it
+ *   re-stamps the row, so its new `seq` cannot commit out of order with the
+ *   materialisation's own writes (`internal/statements.ts` owns that argument).
+ * - `collectTombstones` is one statement that reads every registered sink's cursor
+ *   and deletes below the lowest, or nothing while any of them has no cursor, so
+ *   no cursor can move between the two.
+ * - `removeSink` is one transaction that first takes the sink's advisory lock for
+ *   its own length, which an advisory worker's session lock refuses, then deletes
+ *   the cursor row only when no live lease row holds it, in the same statement as
+ *   that test, and the parks after it. Both tests are therefore made whichever
+ *   lease kind this store was built with: a sink can be leased by either kind
+ *   (`lease.ts` owns how the two coexist), and the row alone cannot say whether
+ *   an advisory holder's session is alive.
+ * - `describe` is three reads, each its own snapshot, so a figure in it can be a
+ *   batch older or newer than the next. It is a report for an operator, and no
+ *   decision is taken on it.
+ *
+ * One store serves every feed in its prefix: unlike the in-memory feed, whose
+ * store belongs to one feed, a SQL store's state is keyed by feed name in shared
+ * tables, so a single store value is what every worker over the prefix takes.
+ *
+ * Infrastructure faults are `FeedUnreadable` on a read and `FeedWriteFailed` on a
+ * write, never defects, so the driver's supervision backs off and tries again.
+ */
+import { type FeedSyncStore } from '@kairos-es/feed';
+import { Effect } from 'effect';
+import { SqlClient } from 'effect/sql';
+import type { FeedPostgresConfig } from './config.js';
+import { type FeedLeaseConfig } from './lease.js';
+/** Options for {@link makePostgresFeedSyncStore}. */
+export interface PostgresFeedSyncStoreOptions {
+    /** The `{ schema, tablePrefix }` pair the feeds were written under. */
+    readonly config?: FeedPostgresConfig;
+    /** The lease kind; `leaseRow()` with its defaults when absent. */
+    readonly lease?: FeedLeaseConfig;
+}
+/**
+ * Build the sync store over the ambient `SqlClient`. Dies at construction on a
+ * malformed config, a lease whose heartbeat is not shorter than its ttl or leaves
+ * no room for its margin, or an `advisoryLock` connection recognisably pooled.
+ * `ensureFeedSchema` must have run.
+ */
+export declare const makePostgresFeedSyncStore: (options?: PostgresFeedSyncStoreOptions) => Effect.Effect<FeedSyncStore, never, SqlClient.SqlClient>;
+//# sourceMappingURL=syncStore.d.ts.map

package/dist/dts-cjs/syncStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncStore.d.ts","sourceRoot":"","sources":["../../src/syncStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,EAML,KAAK,aAAa,EAOnB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAmB,MAAM,EAAU,MAAM,QAAQ,CAAA;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AACtC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAOlD,OAAO,EAEL,KAAK,eAAe,EAGrB,MAAM,SAAS,CAAA;AAEhB,qDAAqD;AACrD,MAAM,WAAW,4BAA4B;IAC3C,uEAAuE;IACvE,QAAQ,CAAC,MAAM,CAAC,EAAE,kBAAkB,CAAA;IACpC,kEAAkE;IAClE,QAAQ,CAAC,KAAK,CAAC,EAAE,eAAe,CAAA;CACjC;AA0DD;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,GACpC,UAAS,4BAAiC,KACzC,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,KAAK,EAAE,SAAS,CAAC,SAAS,CAwMtD,CAAA"}

package/dist/dts-cjs/withFeed.d.ts

@@ -0,0 +1,69 @@
+/**
+ * `withFeed` — a `ProjectionStore` decorated so that resetting the checkpoint a
+ * feed is bound to also empties the feed and moves its generation on, in ONE
+ * transaction.
+ *
+ * ## Why a decorator
+ *
+ * Nothing in the library rebuilds a read model; a rebuild is an application
+ * resetting a checkpoint and letting the runner replay. A feed has to know when
+ * that happens, because a sink holding the old copy must be rebuilt from the
+ * replay rather than patched by it: a record the replay never writes again would
+ * otherwise survive in the sink. The reset is the one moment both facts are true,
+ * so the generation bump rides it.
+ *
+ * What it adds is the FEED's half of a rebuild and nothing more. A rebuild resets
+ * the checkpoint, drops the view, and starts again from `ORIGIN`; this resets the
+ * checkpoint and the feed, and the view is still the consumer's to drop. So
+ * rebuilding a DURABLE view means emptying it yourself before the replay, exactly
+ * as the port's own `resetCheckpoint` leaves it. Skip that and a row the replay
+ * never writes again survives in the view, and a read model whose `apply` reads
+ * its view back (a running count, say) builds on the old rows, which the feed
+ * then mirrors to every sink.
+ *
+ * The decorator keeps the port's three methods and replaces only
+ * `resetCheckpoint`, so it works through `forKey` exactly as the store does, and
+ * nothing about the read side has to know a feed exists.
+ *
+ * ## One transaction, and the client it needs
+ *
+ * The reset bumps the generation, deletes the checkpoint row through the store's
+ * own `resetCheckpoint`, and deletes the feed's rows, all inside one
+ * `withTransaction` on the client this decorator was built over. The store's own
+ * statement joins that transaction only when the store was built from the SAME
+ * client instance (ADR-0018 §3), which `@kairos-es/read-postgres`'s
+ * `makeSqlProjectionStore` is when both are built under one `SqlClient`. Build
+ * them apart and the checkpoint delete commits on its own: the reset still
+ * happens, but not atomically with the bump.
+ *
+ * The generation is bumped FIRST. That takes the feed lock exclusively, so a
+ * materialisation commit in flight finishes before the reset proceeds, and one
+ * that starts after it waits; and it takes the locks in the same order a commit
+ * does (the feed, then the checkpoint), so the two cannot deadlock. A commit that
+ * was mid-flight with the old checkpoint then loses its guard and rolls its feed
+ * rows back with its view.
+ *
+ * ## The binding
+ *
+ * A feed serves ONE materialisation, because one writer is what keeps its `seq`
+ * ascending in commit order. The binding is recorded on the feed's generations
+ * row the first time the feed is decorated, and checked at every construction
+ * after that, so a feed bound to another checkpoint key is refused across
+ * processes, not only within one. A refusal is a defect, as the read side's
+ * construction gate's are.
+ *
+ * The decorated store must be DURABLE. This feed is, and the feed's rows are
+ * written inside the store's commit transaction: an ephemeral store opens no
+ * transaction for them to join.
+ */
+import type { FeedWriteFailed } from '@kairos-es/feed';
+import { type CheckpointKey, type ProjectionStore } from '@kairos-es/read';
+import { Effect } from 'effect';
+import { SqlClient } from 'effect/sql';
+import { type PostgresFeed } from './feed.js';
+/**
+ * `store`, with `resetCheckpoint` for `key` also emptying `feed` and moving its
+ * generation on; see the module doc. Every other key passes through untouched.
+ */
+export declare const withFeed: <D>(store: ProjectionStore, feed: PostgresFeed<D>, key: CheckpointKey) => Effect.Effect<ProjectionStore, FeedWriteFailed, SqlClient.SqlClient>;
+//# sourceMappingURL=withFeed.d.ts.map

package/dist/dts-cjs/withFeed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withFeed.d.ts","sourceRoot":"","sources":["../../src/withFeed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACtD,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,eAAe,EAErB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AACtC,OAAO,EAAa,KAAK,YAAY,EAAE,MAAM,QAAQ,CAAA;AAMrD;;;GAGG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EACxB,OAAO,eAAe,EACtB,MAAM,YAAY,CAAC,CAAC,CAAC,EACrB,KAAK,aAAa,KACjB,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,eAAe,EAAE,SAAS,CAAC,SAAS,CAmElE,CAAA"}

package/dist/dts-esm/config.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Public configuration for the Postgres change feed.
+ *
+ * A feed backend is defined by its `{ schema, tablePrefix }` naming pair alone:
+ * every object it owns is DERIVED from it (`internal/ddl.ts`), so one config
+ * value is one isolated set of feed tables, cohabiting per prefix beside the
+ * event store's objects and `@kairos-es/read-postgres`'s checkpoint table. Pass
+ * the same pair to all three and one prefix names one complete world: the log,
+ * the checkpoints, and the feeds the read models write.
+ *
+ * It is a `Schema` rather than a bare interface so that a malformed value fails
+ * LOUDLY at construction rather than obscurely at the first statement: an empty or
+ * dotted atom (a dot would break the qualified-name split), or a pair whose
+ * derived names would exceed Postgres's 63-byte identifier limit and be silently
+ * truncated. The shape and its checks are `@kairos-es/read-postgres`'s, written
+ * again here rather than imported, because each backend measures only the names it
+ * creates and a sibling backend's internals are not a public surface.
+ */
+import { Schema } from 'effect';
+/**
+ * Configuration for the feed's tables.
+ *
+ * - `schema` — the Postgres schema that owns them (default `public`).
+ * - `tablePrefix` — the stem every name derives from (default `dcb_events`,
+ *   giving `dcb_events_feed_rows` and its siblings).
+ */
+export declare const FeedPostgresConfig: Schema.Struct<{
+    readonly schema: Schema.optionalKey<Schema.String>;
+    readonly tablePrefix: Schema.optionalKey<Schema.String>;
+}>;
+export type FeedPostgresConfig = typeof FeedPostgresConfig.Type;
+/** Decode a config, throwing a `SchemaError` on any violation. */
+export declare const decodeFeedPostgresConfig: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => {
+    readonly schema?: string;
+    readonly tablePrefix?: string;
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/dts-esm/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAY/B;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB;;;EAGqC,CAAA;AACpE,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC,IAAI,CAAA;AAE/D,kEAAkE;AAClE,eAAO,MAAM,wBAAwB;;;CACS,CAAA"}

package/dist/dts-esm/ensureFeedSchema.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `ensureFeedSchema` — the feed's idempotent DDL, as a payload for the consumer's
+ * migrator rather than a migrator of its own, exactly as `ensureCheckpointSchema`
+ * is for the read side and `ensureSchema` for the event store.
+ *
+ * It requires the GENERIC `SqlClient`, so it drops into an existing migrator:
+ *
+ * ```ts
+ * Migrator.fromRecord({
+ *   '0003_kairos_feed': ensureFeedSchema(config),
+ * })
+ * ```
+ *
+ * or runs once at boot. Every statement is `IF NOT EXISTS`, so running it again
+ * against existing tables keeps every row. Nothing in this package performs DDL at
+ * runtime: a feed cannot conjure its own tables, so schema ownership stays with
+ * whoever owns the migrations.
+ */
+import { Effect } from 'effect';
+import { SqlClient, type SqlError } from 'effect/sql';
+import { type FeedPostgresConfig } from './config.js';
+/** The feed tables' migration payload for `config`. */
+export declare const ensureFeedSchema: (config?: FeedPostgresConfig) => Effect.Effect<void, SqlError.SqlError, SqlClient.SqlClient>;
+//# sourceMappingURL=ensureFeedSchema.d.ts.map

package/dist/dts-esm/ensureFeedSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensureFeedSchema.d.ts","sourceRoot":"","sources":["../../src/ensureFeedSchema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrD,OAAO,EAA4B,KAAK,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAG5E,uDAAuD;AACvD,eAAO,MAAM,gBAAgB,GAC3B,SAAQ,kBAAuB,KAC9B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,SAAS,CAKzD,CAAA"}

package/dist/dts-esm/feed.d.ts

@@ -0,0 +1,81 @@
+/**
+ * The Postgres feed's two faces: the `BatchedFeedWriter` a read model's `apply`
+ * writes through, and the `FeedSource` a sync worker tails.
+ *
+ * ## The writer rides the read model's own client
+ *
+ * A feed row must exist if and only if the view write and the checkpoint advance
+ * that produced it landed (ADR-0019 §2). `@kairos-es/read-postgres`'s `commit` is
+ * one transaction over the client the store was built from, and `effect/sql`
+ * carries that transaction in the Effect CONTEXT under a key that belongs to that
+ * one client instance (ADR-0018 §3). So the writer does not capture a client: it
+ * reads `SqlClient` from the context AT WRITE TIME, which inside `commit`'s
+ * `viewWrites` is the read model's own, and its statements join the open
+ * transaction and roll back with it on a lost guard. That is why `SqlClient` sits
+ * in the writer's `RW` and not in the factory's requirements alone. A write
+ * through any OTHER client instance is not bracketed, and the exactly-once
+ * property does not extend to it.
+ *
+ * ## What one `write` sends
+ *
+ * The body's upserts and removes are buffered, last write per key winning, and
+ * land as at most three statements whatever the batch size: the feed lock (see
+ * `internal/statements.ts` for why the writer takes it), one upsert of every
+ * changed document and one tombstone of every removed key. The upsert writes
+ * nothing for a document equal to the stored one, compared as `jsonb`, so key
+ * order is no change; the tombstone writes nothing for a key that is absent or
+ * already a tombstone.
+ *
+ * Each document is encoded through its `Schema` before anything is sent. A
+ * document that fails to encode is a DEFECT in the read model, not a fault of the
+ * feed and not something a sink should ever be asked to refuse.
+ *
+ * ## The source
+ *
+ * `changesAfter` pages the feed's rows by `seq`, tombstones included, and decodes
+ * each document through the same `Schema`. A stored document that no longer
+ * decodes is a defect too: it means the schema changed without the feed being
+ * rebuilt, which retrying cannot mend.
+ *
+ * `listen` is optional and is a WAKE only. This package takes no reserved
+ * connection for a `LISTEN` of its own, as `@kairos-es/read-postgres` takes none,
+ * so the poll is the guarantee. {@link eventStoreWake} offers the event store's
+ * `subscribe` as a wake: it fires when an event is appended, which is BEFORE the
+ * projection has applied it and written the feed, so a woken read may find nothing
+ * new and the poll picks the row up. It shortens the wait; it never decides
+ * correctness.
+ */
+import { DcbEventStore, type Query } from '@kairos-es/core';
+import { type BatchedFeedWriter, type FeedName, type FeedSource, type FeedUnreadable, type FeedWriteFailed } from '@kairos-es/feed';
+import { Effect, Schema, Stream } from 'effect';
+import { SqlClient } from 'effect/sql';
+import type { FeedPostgresConfig } from './config.js';
+/** A Postgres feed: its writer, and the source a sync worker reads. */
+export interface PostgresFeed<D> extends BatchedFeedWriter<D, SqlClient.SqlClient> {
+    readonly source: FeedSource<D>;
+}
+/** Options for {@link makePostgresFeed}. */
+export interface PostgresFeedOptions<D, I> {
+    /** The `{ schema, tablePrefix }` pair; the same one the event store and read side take. */
+    readonly config?: FeedPostgresConfig;
+    readonly feed: FeedName;
+    /** The document's schema: what the writer encodes through and the source decodes through. */
+    readonly doc: Schema.Codec<D, I>;
+    /** A wake for the sync worker, such as {@link eventStoreWake}'s. The poll is the guarantee. */
+    readonly listen?: Stream.Stream<unknown, FeedUnreadable>;
+}
+/**
+ * Build a feed over the ambient `SqlClient`. Creates the feed's generations row
+ * if it is absent, at generation 0, so the writer's feed lock always has a row to
+ * take; that is the only write it makes. `ensureFeedSchema` must have run first.
+ */
+export declare const makePostgresFeed: <D, I>(options: PostgresFeedOptions<D, I>) => Effect.Effect<PostgresFeed<D>, FeedWriteFailed, SqlClient.SqlClient>;
+/**
+ * A wake from the event store: one element per event matching `query` appended
+ * after the moment the stream is subscribed, and nothing else. Pass it as
+ * `listen`. Early by the projection's own lag, as the module doc says, so the
+ * worker's poll still bounds the latency; `query` should be the read model's own,
+ * so events it never applies wake nothing.
+ */
+export declare const eventStoreWake: (query: Query) => Effect.Effect<Stream.Stream<unknown>, never, DcbEventStore>;
+//# sourceMappingURL=feed.d.ts.map

package/dist/dts-esm/feed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feed.d.ts","sourceRoot":"","sources":["../../src/feed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,OAAO,EACL,aAAa,EAEb,KAAK,KAAK,EAEX,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,QAAQ,EAGb,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,eAAe,EAGrB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,MAAM,EAAU,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AACtC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AASlD,uEAAuE;AACvE,MAAM,WAAW,YAAY,CAAC,CAAC,CAC7B,SAAQ,iBAAiB,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC;IACjD,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,CAAA;CAC/B;AAED,4CAA4C;AAC5C,MAAM,WAAW,mBAAmB,CAAC,CAAC,EAAE,CAAC;IACvC,2FAA2F;IAC3F,QAAQ,CAAC,MAAM,CAAC,EAAE,kBAAkB,CAAA;IACpC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,6FAA6F;IAC7F,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;IAChC,+FAA+F;IAC/F,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,cAAc,CAAC,CAAA;CACzD;AAiBD;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,EACnC,SAAS,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,KACjC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,eAAe,EAAE,SAAS,CAAC,SAAS,CAoJlE,CAAA;AAEJ;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GACzB,OAAO,KAAK,KACX,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,aAAa,CASzD,CAAA"}

package/dist/dts-esm/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @kairos-es/feed-postgres — the Postgres change feed: the feed tables and their
+ * idempotent DDL, the `FeedWriter` that rides a read model's own `SqlClient`
+ * inside its commit, the `FeedSource`, the `FeedSyncStore` with its worker lease,
+ * and the store decorator that moves the feed's generation on a reset
+ * (ADR-0019).
+ *
+ * A package of its own rather than part of `@kairos-es/read-postgres`, so that a
+ * read model with no feed gains no `@kairos-es/feed` peer (ADR-0003). It needs
+ * only the GENERIC `SqlClient`, and takes no reserved connection unless the
+ * consumer chooses the advisory-lock lease and dedicates one to it.
+ *
+ * Where each part's argument lives:
+ *
+ * - `config.ts` and `internal/ddl.ts` — the `{ schema, tablePrefix }` pair and the
+ *   five objects derived from it; `ensureFeedSchema.ts` — the migration payload.
+ * - `internal/statements.ts` — every statement the package sends, and the feed
+ *   lock that keeps `seq` ascending in commit order.
+ * - `feed.ts` — the writer, the source and the wake.
+ * - `syncStore.ts` — the cursor, the parked list and their atomic steps.
+ * - `lease.ts` — the two lease kinds, and what each costs.
+ * - `withFeed.ts` — the reset, the generation and the binding.
+ *
+ * Wiring, end to end:
+ *
+ * ```ts
+ * const config = { schema: 'public', tablePrefix: 'dcb_events' }
+ * const key = checkpointKey(ProjectionId.make('course-search'))
+ *
+ * // 1. In YOUR migrator, beside `ensureSchema` and `ensureCheckpointSchema`:
+ * //    ensureFeedSchema(config)
+ *
+ * // 2. Where the read model is wired, under ONE SqlClient:
+ * const feed = yield* makePostgresFeed({ config, feed: FeedName.make('course-search'), doc: CourseDoc })
+ * const store = yield* withFeed(yield* makeSqlProjectionStore(config), feed, key)
+ * // …and in the read model's `apply`, inside `commit`:
+ * //    feed.write(lastPosition, (writer) => writer.upsert(FeedKey.make(id), toDoc(course)))
+ *
+ * // 3. Beside the projections, one worker per feed and sink:
+ * const syncStore = yield* makePostgresFeedSyncStore({ config })
+ * yield* Effect.forkScoped(runFeedSync({ source: feed.source, sink, store: syncStore }))
+ * ```
+ */
+export { decodeFeedPostgresConfig, FeedPostgresConfig, } from './config.js';
+export { ensureFeedSchema } from './ensureFeedSchema.js';
+export { eventStoreWake, makePostgresFeed, type PostgresFeed, type PostgresFeedOptions, } from './feed.js';
+export { advisoryLock, DEFAULT_LEASE_HEARTBEAT, DEFAULT_LEASE_TTL, type FeedLeaseConfig, leaseRow, pooledConnectionFault, } from './lease.js';
+export { makePostgresFeedSyncStore, type PostgresFeedSyncStoreOptions, } from './syncStore.js';
+export { withFeed } from './withFeed.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/dts-esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,OAAO,EACL,wBAAwB,EACxB,kBAAkB,GACnB,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,KAAK,YAAY,EACjB,KAAK,mBAAmB,GACzB,MAAM,QAAQ,CAAA;AACf,OAAO,EACL,YAAY,EACZ,uBAAuB,EACvB,iBAAiB,EACjB,KAAK,eAAe,EACpB,QAAQ,EACR,qBAAqB,GACtB,MAAM,SAAS,CAAA;AAChB,OAAO,EACL,yBAAyB,EACzB,KAAK,4BAA4B,GAClC,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA"}

package/dist/dts-esm/internal/context.d.ts

@@ -0,0 +1,28 @@
+/**
+ * What every part of this package shares about one config: the resolved names,
+ * the compiled statements, and the error mapping from `SqlError` to the feed's own
+ * two infrastructure errors.
+ *
+ * A `PostgresFeed` carries its context privately, in a `WeakMap` keyed by the
+ * feed value, so `withFeed` can reach the feed's names and statements without the
+ * public type growing a field no consumer should touch.
+ */
+import { FeedUnreadable, FeedWriteFailed } from '@kairos-es/feed';
+import type { SqlError } from 'effect/sql';
+import { type FeedPostgresConfig } from '../config.js';
+import { type ResolvedFeedNames } from './ddl.js';
+import { type FeedStatements } from './statements.js';
+/** One config's names and statements. */
+export interface FeedContext {
+    readonly names: ResolvedFeedNames;
+    readonly statements: FeedStatements;
+}
+/** Decode `config` and compile its statements; throws on a malformed config. */
+export declare const feedContext: (config: FeedPostgresConfig) => FeedContext;
+/** A read that failed, named for what was being read. */
+export declare const unreadable: (attempt: string) => (cause: SqlError.SqlError) => FeedUnreadable;
+/** A write that failed, named for what was being written. */
+export declare const writeFailed: (attempt: string) => (cause: SqlError.SqlError) => FeedWriteFailed;
+/** A 64-bit column read back as text, as a `bigint`; see `statements.ts`. */
+export declare const bigintOf: (text: string | bigint | number) => bigint;
+//# sourceMappingURL=context.d.ts.map

package/dist/dts-esm/internal/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/internal/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,EAA4B,KAAK,kBAAkB,EAAE,MAAM,WAAW,CAAA;AAC7E,OAAO,EAAE,KAAK,iBAAiB,EAAoB,MAAM,OAAO,CAAA;AAChE,OAAO,EAAyB,KAAK,cAAc,EAAE,MAAM,cAAc,CAAA;AAEzE,yCAAyC;AACzC,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAA;CACpC;AAED,gFAAgF;AAChF,eAAO,MAAM,WAAW,GAAI,QAAQ,kBAAkB,KAAG,WAGxD,CAAA;AAED,yDAAyD;AACzD,eAAO,MAAM,UAAU,GACpB,SAAS,MAAM,MACf,OAAO,QAAQ,CAAC,QAAQ,KAAG,cACkD,CAAA;AAEhF,6DAA6D;AAC7D,eAAO,MAAM,WAAW,GACrB,SAAS,MAAM,MACf,OAAO,QAAQ,CAAC,QAAQ,KAAG,eAIxB,CAAA;AAEN,6EAA6E;AAC7E,eAAO,MAAM,QAAQ,GAAI,MAAM,MAAM,GAAG,MAAM,GAAG,MAAM,KAAG,MAAsB,CAAA"}

package/dist/dts-esm/internal/ddl.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Internal object naming and DDL for the Postgres change feed.
+ *
+ * The single source of truth for the FIVE objects this package owns — the feed
+ * rows, the sequence they share, the generations, the sync cursors and the parked
+ * list — and for the idempotent DDL that creates them. Every name is derived ONCE
+ * from `{ schema, tablePrefix }` and reused by `ensureFeedSchema` (the migration
+ * payload) and by every runtime statement in `statements.ts`, so a migration and a
+ * query can never disagree about what an object is called.
+ *
+ * The pair is the SAME one the event store and `@kairos-es/read-postgres` take, so
+ * the feed's tables land beside the log and the checkpoints they belong with, and
+ * one prefix keeps naming one complete, isolated world (ADR-0002).
+ *
+ * The identifier discipline is `@kairos-es/read-postgres`'s, duplicated rather
+ * than imported for the reason that package gives for duplicating the event
+ * store's: each package measures and quotes only the names IT materialises, and
+ * importing a sibling backend's internals would couple two packages that must
+ * stay independently publishable. Identifiers are pre-quoted here and embedded as
+ * literal text into `sql.unsafe`; values are always bound `$n` parameters. Names
+ * never pass through `sql(identifier)`, because the consumer's client may carry a
+ * query-name transform that would rewrite them.
+ */
+import type { SqlClient, Statement } from 'effect/sql';
+/** Every object a feed config owns, as qualified (unquoted) names. */
+export interface ResolvedFeedNames {
+    readonly schema: string;
+    readonly tablePrefix: string;
+    /** `<schema>.<prefix>_feed_rows`: one row per feed and key, the newest state. */
+    readonly rowsTable: string;
+    /** `<prefix>_feed_rows_seq_idx`: the `(feed, seq)` index the tail reads by. */
+    readonly rowsSeqIndex: string;
+    /** `<schema>.<prefix>_feed_seq`: the one sequence every feed in the prefix shares. */
+    readonly sequence: string;
+    /** `<schema>.<prefix>_feed_generations`: each feed's generation and binding. */
+    readonly generationsTable: string;
+    /** `<schema>.<prefix>_feed_cursors`: one cursor and lease per feed and sink. */
+    readonly cursorsTable: string;
+    /** `<schema>.<prefix>_feed_parked`: the records a sink refused. */
+    readonly parkedTable: string;
+}
+/** The default schema, identical to the event store's and the read side's. */
+export declare const DEFAULT_SCHEMA = "public";
+/** The default table prefix, identical to the event store's and the read side's. */
+export declare const DEFAULT_TABLE_PREFIX = "dcb_events";
+/**
+ * The first derived identifier over Postgres's 63-byte limit, as a message, or
+ * `undefined` when every name fits. Postgres truncates an over-long identifier
+ * with only a notice, so two prefixes sharing a 63-byte stem would silently share
+ * one feed table; refusing at the boundary beats that.
+ */
+export declare const oversizedIdentifier: (config: {
+    readonly schema?: string;
+    readonly tablePrefix?: string;
+}) => string | undefined;
+/** Derive every name from the pair; throws on an over-long identifier. */
+export declare const resolveFeedNames: (config: {
+    readonly schema?: string;
+    readonly tablePrefix?: string;
+}) => ResolvedFeedNames;
+/** Quote a possibly qualified identifier, atom by atom, for literal SQL text. */
+export declare const quoteQualified: (name: string) => string;
+/** Quote one identifier atom, doubling any embedded `"`. */
+export declare const quoteAtom: (name: string) => string;
+/**
+ * The quoted sequence name as a SQL string LITERAL, for `nextval('…')`. The
+ * literal is parsed as a `regclass`, which honours the double quotes inside it, so
+ * an awkward prefix resolves to exactly the object the DDL created; any `'` in it
+ * is doubled so the literal cannot be closed early.
+ */
+export declare const sequenceLiteral: (names: ResolvedFeedNames) => string;
+/**
+ * The ordered, idempotent DDL. Every statement is `IF NOT EXISTS`, so a second
+ * run against existing objects is a no-op that keeps every row.
+ *
+ * Shapes that are load-bearing:
+ *
+ * - `_feed_rows` is keyed `(feed, key)`: one row per record, which is what
+ *   "coalesced, latest wins" means in storage, and the arbiter the writer's
+ *   `ON CONFLICT` names. `doc` is NULL for a tombstone; a document that encodes to
+ *   JSON `null` is the jsonb value `null`, which is not SQL NULL, so the two
+ *   cannot be confused.
+ * - The `(feed, seq)` index is what `changesAfter` pages by.
+ * - ONE sequence serves every feed in the prefix. A feed's `seq` values therefore
+ *   have gaps, which the cursor never minds: it compares, never counts.
+ * - `_feed_cursors` holds the cursor AND the lease, so the cursor's
+ *   compare-and-set can fence on the lease holder in the same row it moves. The
+ *   cursor is `(generation, seq)`, both NULL before a sink's first sync and never
+ *   one without the other, which the `CHECK` holds. `last_advance_at` is when
+ *   the cursor last moved, NULL until it first does; taking a lease leaves it
+ *   alone, so a sink registered and never run shows as one.
+ * - `_feed_generations` holds the checkpoint key a feed is bound to, so binding
+ *   one feed to two materialisations is refused across processes, not only within
+ *   one.
+ */
+export declare const feedDdlStatements: (names: ResolvedFeedNames) => ReadonlyArray<string>;
+/** The DDL as statements on `sql`, one `sql.unsafe` each, in order. */
+export declare const runFeedDdl: (sql: SqlClient.SqlClient, names: ResolvedFeedNames) => ReadonlyArray<Statement.Statement<unknown>>;
+//# sourceMappingURL=ddl.d.ts.map

package/dist/dts-esm/internal/ddl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ddl.d.ts","sourceRoot":"","sources":["../../../src/internal/ddl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAEtD,sEAAsE;AACtE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,iFAAiF;IACjF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,+EAA+E;IAC/E,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,sFAAsF;IACtF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,gFAAgF;IAChF,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,gFAAgF;IAChF,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,mEAAmE;IACnE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC7B;AAED,8EAA8E;AAC9E,eAAO,MAAM,cAAc,WAAW,CAAA;AACtC,oFAAoF;AACpF,eAAO,MAAM,oBAAoB,eAAe,CAAA;AAuChD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ;IAC1C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAC9B,KAAG,MAAM,GAAG,SAQZ,CAAA;AAED,0EAA0E;AAC1E,eAAO,MAAM,gBAAgB,GAAI,QAAQ;IACvC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAC9B,KAAG,iBAkBH,CAAA;AAED,iFAAiF;AACjF,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,KAAG,MAIhC,CAAA;AAEd,4DAA4D;AAC5D,eAAO,MAAM,SAAS,GAAI,MAAM,MAAM,KAAG,MACR,CAAA;AAEjC;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,iBAAiB,KAAG,MACA,CAAA;AAE3D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,iBAAiB,GAC5B,OAAO,iBAAiB,KACvB,aAAa,CAAC,MAAM,CAmDtB,CAAA;AAED,uEAAuE;AACvE,eAAO,MAAM,UAAU,GACrB,KAAK,SAAS,CAAC,SAAS,EACxB,OAAO,iBAAiB,KACvB,aAAa,CAAC,SAAS,CAAC,SAAS,CAAC,OAAO,CAAC,CACuB,CAAA"}

package/dist/dts-esm/internal/statements.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Every runtime statement text the Postgres change feed issues, compiled once per
+ * name set, and the conventions their parameters follow.
+ *
+ * One module, so what the feed sends to the database is auditable in one file.
+ * The Effect wiring that issues them lives in `feed.ts`, `syncStore.ts`, `lease.ts`
+ * and `withFeed.ts`; none of those writes SQL of its own.
+ *
+ * ## Parameter conventions
+ *
+ * - Every 64-bit value (`seq`, `generation`, `event_position`) is bound as a
+ *   decimal STRING and cast (`$n::bigint`), and read back as text and turned into
+ *   a `bigint`, so no value ever passes through a JS `number` and no driver's
+ *   integer handling can round one.
+ * - A batch of rows is bound as ONE `jsonb` parameter and unpacked server-side
+ *   (`jsonb_to_recordset`, `jsonb_array_elements_text`), so a batch is one
+ *   statement whatever its size and no array-binding support is asked of the
+ *   driver.
+ * - A timestamp is bound as epoch MILLISECONDS from Effect's `Clock`, and read back
+ *   the same way. Lease expiry is judged against the worker's Clock rather than the
+ *   database's `now()`, so a `TestClock` governs it in tests as it governs every
+ *   other time in this repository; the cost is that workers on several hosts must
+ *   keep their clocks within a small fraction of the lease length of each other.
+ * - A document is read back as `doc::text` and parsed here, so a consumer's JSON
+ *   parsing or name transforms cannot reshape it on the way.
+ * - A column read back as text is ALIASED to its own name, so every `ORDER BY`
+ *   qualifies the column with its table alias: an unqualified name in `ORDER BY`
+ *   resolves to the output column first, and `seq` would then sort as text, with
+ *   `10` before `4`.
+ *
+ * ## The feed lock
+ *
+ * The generations row of a feed doubles as its WRITE LOCK. A feed's `seq` is
+ * ascending in commit order only while one transaction at a time takes `seq`
+ * values for that feed, and the subscribe machine silently loses a row whose `seq`
+ * commits below one already read (ADR-0009). The materialisation is one writer, but
+ * two other things take `seq` values for a feed outside its commit: `retryParked`
+ * re-stamps a row, and a reset empties the feed. So the writer takes the row
+ * `FOR SHARE` before it takes any `seq`, `retryParked` takes it `FOR UPDATE`, and
+ * the reset UPDATEs it; each waits for the others to commit, and `seq` order is
+ * commit order for all three.
+ */
+import { type ResolvedFeedNames } from './ddl.js';
+/** Every statement text, compiled for one name set. */
+export interface FeedStatements {
+    /** `$1` feed. Creates the generations row at generation 0 if absent. */
+    readonly ensureGeneration: string;
+    /** `$1` feed. The writer's share of the feed lock. */
+    readonly lockFeedShared: string;
+    /** `$1` feed, `$2` event position, `$3` jsonb `[{ key, doc }]`. */
+    readonly upsertRows: string;
+    /** `$1` feed, `$2` event position, `$3` jsonb `[key]`. */
+    readonly tombstoneRows: string;
+    /** `$1` feed. */
+    readonly selectGeneration: string;
+    /** `$1` feed, `$2` after seq, `$3` limit. */
+    readonly changesAfter: string;
+    /** `$1` feed, `$2` sink. */
+    readonly selectCursor: string;
+    /**
+     * `$1` feed, `$2` sink, `$3` holder, `$4` next generation, `$5` next seq,
+     * `$6` expected generation (NULL for none), `$7` expected seq (NULL for none),
+     * `$8` now ms, recorded as the sink's last advance.
+     */
+    readonly casCursor: string;
+    /** `$1` feed, `$2` sink. */
+    readonly clearParked: string;
+    /** `$1` feed, `$2` sink, `$3` jsonb `[key]`. */
+    readonly unparkKeys: string;
+    /** `$1` feed, `$2` sink, `$3` jsonb `[{ key, seq, reason, parked_at_ms }]`. */
+    readonly parkKeys: string;
+    /** `$1` feed, `$2` sink. */
+    readonly selectParked: string;
+    /** `$1` feed. The feed lock, exclusively, for `retryParked`. */
+    readonly lockFeedExclusive: string;
+    /** `$1` feed, `$2` sink, `$3` key. */
+    readonly unparkOne: string;
+    /** `$1` feed, `$2` key. */
+    readonly restampRow: string;
+    /** `$1` feed. */
+    readonly collectTombstones: string;
+    /** `$1` lock name. The advisory lock, held until the transaction ends. */
+    readonly tryAdvisoryXactLock: string;
+    /** `$1` feed, `$2` sink, `$3` now ms. Deletes the cursor row unless a live lease row holds it. */
+    readonly deleteCursorUnlessLeased: string;
+    /** `$1` feed, `$2` sink. Whether a cursor row is still there. */
+    readonly cursorExists: string;
+    /** `$1` feed, `$2` sink. Every park of the sink, one row back per park. */
+    readonly deleteSinkParked: string;
+    /** `$1` feed. */
+    readonly selectHead: string;
+    /** `$1` feed. */
+    readonly describeSinks: string;
+    /** `$1` feed. */
+    readonly describeParked: string;
+    /**
+     * `$1` feed, `$2` sink, `$3` holder, `$4` expiry ms, `$5` now ms, `$6` whether
+     * the caller holds the sink's advisory lock for its transaction.
+     */
+    readonly takeLeaseRow: string;
+    /** `$1` feed, `$2` sink, `$3` holder, `$4` expiry ms. */
+    readonly renewLeaseRow: string;
+    /** `$1` feed, `$2` sink, `$3` holder. */
+    readonly releaseLease: string;
+    /**
+     * `$1` feed, `$2` sink, `$3` holder, `$4` now ms, `$5` lock name. On the
+     * dedicated connection. Records an advisory holder unless a live lease row
+     * holds the row or this session no longer holds the lock; zero rows means one
+     * of the two.
+     */
+    readonly claimAdvisoryHolder: string;
+    /** `$1` lock name. On the dedicated connection. */
+    readonly tryAdvisoryLock: string;
+    /** `$1` lock name. On the dedicated connection. */
+    readonly holdsAdvisoryLock: string;
+    /** `$1` lock name. On the dedicated connection. */
+    readonly advisoryUnlock: string;
+    /** `$1` feed, `$2` projection, `$3` partition. */
+    readonly bindFeed: string;
+    /** `$1` feed. */
+    readonly bumpGeneration: string;
+    /** `$1` feed. */
+    readonly deleteFeedRows: string;
+}
+/** Compile every statement for `names`. */
+export declare const compileFeedStatements: (names: ResolvedFeedNames) => FeedStatements;
+//# sourceMappingURL=statements.d.ts.map

package/dist/dts-esm/internal/statements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statements.d.ts","sourceRoot":"","sources":["../../../src/internal/statements.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,OAAO,EAAkB,KAAK,iBAAiB,EAAmB,MAAM,OAAO,CAAA;AAE/E,uDAAuD;AACvD,MAAM,WAAW,cAAc;IAE7B,wEAAwE;IACxE,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,sDAAsD;IACtD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,mEAAmE;IACnE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,0DAA0D;IAC1D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAE9B,iBAAiB;IACjB,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,6CAA6C;IAC7C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAE7B,4BAA4B;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,4BAA4B;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,gDAAgD;IAChD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,4BAA4B;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,gEAAgE;IAChE,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;IAClC,sCAAsC;IACtC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,2BAA2B;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,iBAAiB;IACjB,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;IAElC,0EAA0E;IAC1E,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAA;IACpC,kGAAkG;IAClG,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAA;IACzC,iEAAiE;IACjE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,2EAA2E;IAC3E,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,iBAAiB;IACjB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,iBAAiB;IACjB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,iBAAiB;IACjB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAE/B;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,yDAAyD;IACzD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,yCAAyC;IACzC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAA;IACpC,mDAAmD;IACnD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,mDAAmD;IACnD,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;IAClC,mDAAmD;IACnD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAE/B,kDAAkD;IAClD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,iBAAiB;IACjB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,iBAAiB;IACjB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;CAChC;AAED,2CAA2C;AAC3C,eAAO,MAAM,qBAAqB,GAChC,OAAO,iBAAiB,KACvB,cA2PF,CAAA"}