@kairos-es/feed-postgres 0.0.0-stage → 1.0.0-alpha.6

package/dist/dts-cjs/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-cjs/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-cjs/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-cjs/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-cjs/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-cjs/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-cjs/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-cjs/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-cjs/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-cjs/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-cjs/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-cjs/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-cjs/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-cjs/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"}

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

@@ -0,0 +1,138 @@
+/**
+ * The sync worker's lease on Postgres, in the two kinds `FeedSyncStore`'s doc
+ * describes, chosen in config to suit the infrastructure in front of the
+ * database.
+ *
+ * ## Why there are two
+ *
+ * A worker lease is what keeps a feed's sends to a sink in order: a sink has no
+ * transaction, so a rival worker's stale send lands before any compare-and-set can
+ * catch it (ADR-0019 §5). The two kinds trade the same two things against each
+ * other — what the connection must be, and how long a lapsed worker can go on
+ * sending — and neither wins on both.
+ *
+ * - **`leaseRow`, the default.** The holder and an expiry live on the sink's
+ *   cursor row, taken with a guarded upsert (only when free, expired, or held by
+ *   an advisory worker whose session is gone; see below) and renewed by a
+ *   heartbeat forked into the lease's scope. Every statement is an ordinary short
+ *   one, and the take one short transaction, so it works through a TRANSACTION
+ *   POOLER, which drops session state and so rules out a session lock, and it
+ *   needs no reserved connection. Its cost is a window. `ensureHeld` fails a
+ *   MARGIN before the stored expiry: once the last successful renewal is
+ *   `ttl - margin` old by the worker's own `Clock`, that renewal's expiry, which is
+ *   when a rival may take the row, is at most `margin` away. So a call to the sink
+ *   that `ensureHeld` let through, and that lands within `margin` of that check,
+ *   pauses included, lands before any rival can hold the lease, however its
+ *   renewals have been failing meanwhile, as long as the two workers' clocks
+ *   agree. A call that outlasts the margin, whether it is slow or its worker
+ *   pauses (a long GC pause, a network stall), can land after a rival took over:
+ *   ONE stale call, since the next `ensureHeld` fails; `FeedSyncStore.ts` owns what
+ *   that call costs. The margin is `ttl / 3` unless configured, and must leave the
+ *   heartbeat room under the lease (`heartbeat + margin < ttl`), or `ensureHeld`
+ *   would fail between two renewals that both landed at once. Each renewal is
+ *   bounded by the heartbeat and the next starts on the next tick, and the age
+ *   `ensureHeld` judges runs from when a renewal STARTED. So a renewal that lands
+ *   is at most `heartbeat` late, and the worst age `ensureHeld` meets is
+ *   `heartbeat` plus that latency with every renewal landing, and `2 * heartbeat`
+ *   plus it with one lost. A worker therefore goes on sending, without a single
+ *   failed `ensureHeld`, through renewals that are slow when
+ *   `2 * heartbeat + margin <= ttl`, and through one that fails or hangs when
+ *   `3 * heartbeat + margin <= ttl`. The defaults satisfy the second; the
+ *   construction check enforces only the first's zero-latency form, so a tighter
+ *   config is accepted and trades those guarantees for a shorter `ttl`.
+ * - **`advisoryLock`.** A session `pg_try_advisory_lock` on a connection RESERVED
+ *   from a client the consumer dedicates to it, keyed by a hash of the prefix, the
+ *   feed and the sink. The lock goes when the session goes, and `ensureHeld` asks
+ *   that same session, before every call that changes the sink, whether it still
+ *   holds the lock; any failure to answer is a lost lease. So a process pause
+ *   opens no stale window, since the lock survives it. What a check cannot see is
+ *   the session dying AFTER it: the call it let through is already under way and
+ *   runs to its end, so it can land as late as its whole duration after the session
+ *   died, and after a rival has taken the lock and sent. That is still ONE stale
+ *   call, since the next `ensureHeld` asks a session that is gone, but a sink call
+ *   can be long — a resync's `publish` most of all. The price is a connection per
+ *   running worker, and a connection that is genuinely a SESSION: a transaction
+ *   pooler would hand the lock's session to somebody else between statements. A
+ *   client this package can recognise as one is refused at construction; see
+ *   {@link pooledConnectionFault} for what it can and cannot recognise.
+ *
+ * ## Fencing is the same for both
+ *
+ * Both kinds record the holder on the cursor row, and the cursor compare-and-set
+ * requires it, so a worker whose lease has gone cannot move the cursor whichever
+ * kind it held. Mixing the two kinds on one feed and sink fails safe, because
+ * neither takes the row from a LIVE holder of the other. A lease-row worker takes
+ * over an advisory holder (one with no expiry to lapse) only while it holds that
+ * sink's advisory lock for its own transaction, which a live advisory session
+ * refuses; so a crashed advisory worker, whose scope never closed to clear the row,
+ * does not leave the sink unleasable by every lease-row worker after it. An
+ * advisory worker that wins the lock but finds a lease row unexpired on the row lets
+ * the lock go and fails `LeaseHeld`. Whichever took the row first keeps it while it
+ * lives. The advisory worker likewise takes over an ADVISORY holder recorded on the
+ * row, because holding the lock proves that session is gone; it records itself
+ * from the session that holds the lock, and only while it still does, so a session
+ * that died after its try-lock cannot overwrite the successor that took the lock
+ * from it.
+ */
+import { type FeedLease, type FeedSinkId, type FeedUnreadable, type FeedWriteFailed, LeaseHeld } from '@kairos-es/feed';
+import { Duration, Effect, type Scope } from 'effect';
+import type { SqlClient } from 'effect/sql';
+/** The lease kind, as config carries it. See the module doc. */
+export type FeedLeaseConfig = {
+    readonly _tag: 'LeaseRow';
+    /** How long a lease lasts without a renewal. */
+    readonly ttl: Duration.Input;
+    /** How often the holder renews it; shorter than `ttl`. */
+    readonly heartbeat: Duration.Input;
+    /**
+     * How long before the stored expiry `ensureHeld` starts failing: a sink call
+     * that takes less than this cannot land after a rival took the lease. See
+     * the module doc. `ttl / 3` when absent; `heartbeat + margin` must be under
+     * `ttl`.
+     */
+    readonly margin?: Duration.Input;
+} | {
+    readonly _tag: 'AdvisoryLock';
+    /**
+     * A client used for nothing but leases, each lease reserving one connection
+     * from it for its lifetime. Its lifecycle is the consumer's, exactly as the
+     * main client's is.
+     */
+    readonly connection: SqlClient.SqlClient;
+};
+/** The default lease length. */
+export declare const DEFAULT_LEASE_TTL: Duration.Duration;
+/**
+ * The default renewal interval: a fifth of the lease. With the default margin, a
+ * third, `3 * heartbeat + margin` is under the `ttl`, so a worker goes on sending,
+ * with no failed `ensureHeld`, through one renewal that fails or hangs. However
+ * many fail, it stops sending a margin before its lease could lapse. The module
+ * doc has the arithmetic.
+ */
+export declare const DEFAULT_LEASE_HEARTBEAT: Duration.Duration;
+/** A lease row, the default; see the module doc. */
+export declare const leaseRow: (options?: {
+    readonly ttl?: Duration.Input;
+    readonly heartbeat?: Duration.Input;
+    readonly margin?: Duration.Input;
+}) => FeedLeaseConfig;
+/** A session advisory lock on a dedicated connection; see the module doc. */
+export declare const advisoryLock: (options: {
+    readonly connection: SqlClient.SqlClient;
+}) => FeedLeaseConfig;
+/**
+ * Why `client` cannot carry a session lock, when this package can tell, or
+ * `undefined`.
+ *
+ * What it can tell is limited to what a client says about where it connects,
+ * which `@effect/sql-pg`'s client exposes as `config` and a generic `SqlClient`
+ * does not. It recognises the two pooler conventions that show in an address: a
+ * Neon pooled endpoint (a host containing `-pooler`), and PgBouncer's default
+ * port, 6432, or a `pgbouncer=true` URL parameter. A pooler on any other address,
+ * or behind a client that exposes nothing, passes; that is a wiring the consumer
+ * owns. The URL is read only to judge it and is never repeated in the message.
+ */
+export declare const pooledConnectionFault: (client: SqlClient.SqlClient) => string | undefined;
+/** How a sync store takes a lease. Package-internal. */
+export type AcquireLease = (id: FeedSinkId) => Effect.Effect<FeedLease, LeaseHeld | FeedUnreadable | FeedWriteFailed, Scope.Scope>;
+//# sourceMappingURL=lease.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lease.d.ts","sourceRoot":"","sources":["../../src/lease.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AACH,OAAO,EACL,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,SAAS,EAGV,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAEL,QAAQ,EACR,MAAM,EAKN,KAAK,KAAK,EACX,MAAM,QAAQ,CAAA;AACf,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAG3C,gEAAgE;AAChE,MAAM,MAAM,eAAe,GACvB;IACE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,gDAAgD;IAChD,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,KAAK,CAAA;IAC5B,0DAA0D;IAC1D,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,KAAK,CAAA;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAA;CACjC,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC,SAAS,CAAA;CACzC,CAAA;AAEL,gCAAgC;AAChC,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,QAA+B,CAAA;AAExE;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,QAA8B,CAAA;AAE7E,oDAAoD;AACpD,eAAO,MAAM,QAAQ,GACnB,UAAS;IACP,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAA;IAC7B,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAA;IACnC,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAA;CAC5B,KACL,eAKD,CAAA;AAEF,6EAA6E;AAC7E,eAAO,MAAM,YAAY,GAAI,SAAS;IACpC,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC,SAAS,CAAA;CACzC,KAAG,eAGF,CAAA;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,GAChC,QAAQ,SAAS,CAAC,SAAS,KAC1B,MAAM,GAAG,SAwCX,CAAA;AAED,wDAAwD;AACxD,MAAM,MAAM,YAAY,GAAG,CACzB,EAAE,EAAE,UAAU,KACX,MAAM,CAAC,MAAM,CAChB,SAAS,EACT,SAAS,GAAG,cAAc,GAAG,eAAe,EAC5C,KAAK,CAAC,KAAK,CACZ,CAAA"}

package/dist/dts-cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}