@rocicorp/zero 0.0.0-202410031711

package/out/zero-cache/src/services/replicator/notifier.js

@@ -0,0 +1,54 @@
+import { EventEmitter } from 'eventemitter3';
+import { Subscription, } from '../../types/subscription.js';
+/**
+ * Handles the semantics of {@link ReplicatorVersionNotifier.subscribe()}
+ * notifications, namely:
+ *
+ * * New subscribers are notified immediately with the latest received
+ *   ReplicaState.
+ *
+ * * Non-latest notifications are discarded if the subscriber is too
+ *   busy to consume them.
+ *
+ * By encapsulating the state for the first behavior (essentially, whether
+ * the first notification has been sent by the Replicator), Notifier objects
+ * can be chained to simplify fanout from Replicator to View Syncers.
+ *
+ * In particular, each Syncer Thread can manage a single Subscription to
+ * the Replicator across a MessageChannel, which it uses for its own Notifier
+ * instance to manage subscriptions from View Syncers within its thread. This
+ * way a Replicator only deals with sending notifications to a bounded set
+ * of MessageChannel-based subscribers (Syncer Threads), while the dynamic
+ * subscribe and unsubscribe traffic from View Syncers remains within each
+ * Syncer Thread.
+ */
+export class Notifier {
+    #eventEmitter = new EventEmitter();
+    #lastStateReceived;
+    #newSubscription() {
+        const notify = (state) => subscription.push(state);
+        const subscription = Subscription.create({
+            coalesce: curr => curr,
+            cleanup: () => this.#eventEmitter.off('version', notify),
+        });
+        return { notify, subscription };
+    }
+    subscribe() {
+        const { notify, subscription } = this.#newSubscription();
+        this.#eventEmitter.on('version', notify);
+        if (this.#lastStateReceived) {
+            // Per Replicator.subscribe() semantics, the current state of the
+            // replica, if known, is immediately sent on subscribe.
+            notify(this.#lastStateReceived);
+        }
+        return subscription;
+    }
+    notifySubscribers(state = { state: 'version-ready' }) {
+        this.#lastStateReceived = state;
+        return this.#eventEmitter
+            .listeners('version')
+            .map(notify => notify(state))
+            .map(pending => pending.result);
+    }
+}
+//# sourceMappingURL=notifier.js.map

package/out/zero-cache/src/services/replicator/notifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"notifier.js","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/replicator/notifier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAC3C,OAAO,EAGL,YAAY,GACb,MAAM,6BAA6B,CAAC;AAGrC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,QAAQ;IACV,aAAa,GAAG,IAAI,YAAY,EAAE,CAAC;IAC5C,kBAAkB,CAA2B;IAE7C,gBAAgB;QACd,MAAM,MAAM,GAAG,CAAC,KAAmB,EAAE,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACjE,MAAM,YAAY,GAAG,YAAY,CAAC,MAAM,CAAe;YACrD,QAAQ,EAAE,IAAI,CAAC,EAAE,CAAC,IAAI;YACtB,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,SAAS,EAAE,MAAM,CAAC;SACzD,CAAC,CAAC;QACH,OAAO,EAAC,MAAM,EAAE,YAAY,EAAC,CAAC;IAChC,CAAC;IAED,SAAS;QACP,MAAM,EAAC,MAAM,EAAE,YAAY,EAAC,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACvD,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QACzC,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC5B,iEAAiE;YACjE,uDAAuD;YACvD,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAClC,CAAC;QACD,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,iBAAiB,CACf,QAAsB,EAAC,KAAK,EAAE,eAAe,EAAC;QAE9C,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;QAChC,OAAO,IAAI,CAAC,aAAa;aACtB,SAAS,CAAC,SAAS,CAAC;aACpB,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,KAAK,CAA6B,CAAC;aACxD,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC;CACF"}

package/out/zero-cache/src/services/replicator/replicator.d.ts

@@ -0,0 +1,65 @@
+import type { LogContext } from '@rocicorp/logger';
+import type { ReadonlyJSONObject } from '../../../../shared/src/json.js';
+import { Database } from '../../../../zqlite/src/db.js';
+import type { Source } from '../../types/streams.js';
+import type { ChangeStreamer } from '../change-streamer/change-streamer.js';
+import type { Service } from '../service.js';
+import type { Checkpointer } from './checkpointer.js';
+/** See {@link ReplicaStateNotifier.subscribe()}. */
+export type ReplicaState = {
+    readonly state: 'version-ready' | 'maintenance';
+    /**
+     * An optional random integer indicating that the notifier requests
+     * an ACK from all (transitive) subscribers. As the Subscription class
+     * uses the AsyncIterable paradigm to automatically handle ACKs for
+     * in-process communication, this field is primarily for IPC-level
+     * logic to perform additional communication between processes.
+     *
+     * It follows that application logic can largely ignore this field.
+     */
+    readonly ack?: number | undefined;
+};
+export interface ReplicaStateNotifier {
+    /**
+     * Creates a cancelable subscription of changes in the replica state.
+     *
+     * A `version-ready` message indicates that the replica is ready to be
+     * read, and henceforth that a _new_ version is ready, i.e. whenever a
+     * change is committed to the replica. The `version-ready` message itself
+     * otherwise contains no other information; the subscriber queries the
+     * replica for the current data.
+     *
+     * A `maintenance` state indicates that the replica should not be read from.
+     * If a subscriber is holding any transaction locks, it should release them
+     * until the next `version-ready` signal.
+     *
+     * Upon subscription, the current state of the replica is sent immediately
+     * if known. If multiple notifications occur before the subscriber
+     * can consume them, all but the last notification are discarded by the
+     * Subscription object (i.e. not buffered). Thus, a subscriber only
+     * ever consumes the current (i.e. known) state of the replica. This avoids
+     * a buildup of "work" if a subscriber is too busy to consume all
+     * notifications.
+     */
+    subscribe(): Source<ReplicaState>;
+}
+export interface Replicator extends ReplicaStateNotifier {
+    /**
+     * Returns an opaque message for human-readable consumption. This is
+     * purely for ensuring that the Replicator has started at least once to
+     * bootstrap a new replica.
+     */
+    status(): Promise<ReadonlyJSONObject>;
+}
+export declare class ReplicatorService implements Replicator, Service {
+    #private;
+    readonly id: string;
+    constructor(lc: LogContext, id: string, changeStreamer: ChangeStreamer, replica: Database, checkpointer: Checkpointer);
+    status(): Promise<{
+        status: string;
+    }>;
+    run(): Promise<void>;
+    subscribe(): Source<ReplicaState>;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=replicator.d.ts.map

package/out/zero-cache/src/services/replicator/replicator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replicator.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/replicator/replicator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAC,QAAQ,EAAC,MAAM,kBAAkB,CAAC;AAC1C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,wBAAwB,CAAC;AACnD,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,uCAAuC,CAAC;AAC1E,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,mBAAmB,CAAC;AAGpD,oDAAoD;AACpD,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,KAAK,EAAE,eAAe,GAAG,aAAa,CAAC;IAEhD;;;;;;;;OAQG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC,CAAC;AAEF,MAAM,WAAW,oBAAoB;IACnC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,SAAS,IAAI,MAAM,CAAC,YAAY,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,UAAW,SAAQ,oBAAoB;IACtD;;;;OAIG;IACH,MAAM,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAAC;CACvC;AAED,qBAAa,iBAAkB,YAAW,UAAU,EAAE,OAAO;;IAC3D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;gBAKlB,EAAE,EAAE,UAAU,EACd,EAAE,EAAE,MAAM,EACV,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,QAAQ,EACjB,YAAY,EAAE,YAAY;IAe5B,MAAM;;;IAIN,GAAG;IAIH,SAAS,IAAI,MAAM,CAAC,YAAY,CAAC;IAI3B,IAAI;CAGX"}

package/out/zero-cache/src/services/replicator/replicator.js

@@ -0,0 +1,27 @@
+import { Database } from '../../../../zqlite/src/db.js';
+import { IncrementalSyncer } from './incremental-sync.js';
+export class ReplicatorService {
+    id;
+    #lc;
+    #incrementalSyncer;
+    constructor(lc, id, changeStreamer, replica, checkpointer) {
+        this.id = id;
+        this.#lc = lc
+            .withContext('component', 'replicator')
+            .withContext('serviceID', this.id);
+        this.#incrementalSyncer = new IncrementalSyncer(id, changeStreamer, replica, checkpointer);
+    }
+    status() {
+        return Promise.resolve({ status: 'ok' });
+    }
+    run() {
+        return this.#incrementalSyncer.run(this.#lc);
+    }
+    subscribe() {
+        return this.#incrementalSyncer.subscribe();
+    }
+    async stop() {
+        await this.#incrementalSyncer.stop(this.#lc);
+    }
+}
+//# sourceMappingURL=replicator.js.map

package/out/zero-cache/src/services/replicator/replicator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replicator.js","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/replicator/replicator.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,QAAQ,EAAC,MAAM,kBAAkB,CAAC;AAK1C,OAAO,EAAC,iBAAiB,EAAC,MAAM,uBAAuB,CAAC;AAoDxD,MAAM,OAAO,iBAAiB;IACnB,EAAE,CAAS;IACX,GAAG,CAAa;IAChB,kBAAkB,CAAoB;IAE/C,YACE,EAAc,EACd,EAAU,EACV,cAA8B,EAC9B,OAAiB,EACjB,YAA0B;QAE1B,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;QACb,IAAI,CAAC,GAAG,GAAG,EAAE;aACV,WAAW,CAAC,WAAW,EAAE,YAAY,CAAC;aACtC,WAAW,CAAC,WAAW,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;QAErC,IAAI,CAAC,kBAAkB,GAAG,IAAI,iBAAiB,CAC7C,EAAE,EACF,cAAc,EACd,OAAO,EACP,YAAY,CACb,CAAC;IACJ,CAAC;IAED,MAAM;QACJ,OAAO,OAAO,CAAC,OAAO,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC,CAAC;IACzC,CAAC;IAED,GAAG;QACD,OAAO,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC/C,CAAC;IAED,SAAS;QACP,OAAO,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,CAAC;IAC7C,CAAC;IAED,KAAK,CAAC,IAAI;QACR,MAAM,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC/C,CAAC;CACF"}

package/out/zero-cache/src/services/replicator/schema/change-log.d.ts

@@ -0,0 +1,35 @@
+import type { Database } from '../../../../../zqlite/src/db.js';
+import * as v from '../../../../../shared/src/valita.js';
+import { StatementRunner } from '../../../../../zero-cache/src/db/statements.js';
+import type { LexiVersion } from '../../../../../zero-cache/src/types/lexi-version.js';
+import { type RowKey } from '../../../../../zero-cache/src/types/row-key.js';
+/**
+ * The Change Log tracks the last operation (set or delete) for each row in the
+ * data base, ordered by state version; in other words, a cross-table
+ * index of row changes ordered by version. This facilitates a minimal "diff"
+ * of row changes needed to advance a pipeline from one state version to another.
+ *
+ * The Change Log stores identifiers only, i.e. it does not store contents.
+ * A database snapshot at the previous version can be used to query a row's
+ * old contents, if any, and the current snapshot can be used to query a row's
+ * new contents. (In the common case, the new contents will have just been applied
+ * and thus has a high likelihood of being in the SQLite cache.)
+ *
+ * The postgres TRUNCATE operation is represented as a log entry with a `null` row
+ * key, which means that it is sorted before any row operations for that table.
+ */
+export declare const SET_OP = "s";
+export declare const DEL_OP = "d";
+export declare const TRUNCATE_OP = "t";
+export declare const changeLogEntrySchema: v.Type<{
+    rowKey: Readonly<Record<string, import("../../../../../zero-cache/src/types/bigint-json.js").JSONValue>> | null;
+    stateVersion: string;
+    table: string;
+    op: "s" | "d" | "t";
+}>;
+export type ChangeLogEntry = v.Infer<typeof changeLogEntrySchema>;
+export declare function initChangeLog(db: Database): void;
+export declare function logSetOp(db: StatementRunner, version: LexiVersion, table: string, row: RowKey): void;
+export declare function logDeleteOp(db: StatementRunner, version: LexiVersion, table: string, row: RowKey): void;
+export declare function logTruncateOp(db: StatementRunner, version: LexiVersion, table: string): void;
+//# sourceMappingURL=change-log.d.ts.map

package/out/zero-cache/src/services/replicator/schema/change-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-log.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/replicator/schema/change-log.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,CAAC,MAAM,sBAAsB,CAAC;AAC1C,OAAO,EAAC,eAAe,EAAC,MAAM,iCAAiC,CAAC;AAMhE,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,sCAAsC,CAAC;AACtE,OAAO,EAAqB,KAAK,MAAM,EAAC,MAAM,iCAAiC,CAAC;AAEhF;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,MAAM,MAAM,CAAC;AAC1B,eAAO,MAAM,MAAM,MAAM,CAAC;AAC1B,eAAO,MAAM,WAAW,MAAM,CAAC;AAoB/B,eAAO,MAAM,oBAAoB;;;;;EAU5B,CAAC;AAEN,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,wBAAgB,aAAa,CAAC,EAAE,EAAE,QAAQ,QAEzC;AAED,wBAAgB,QAAQ,CACtB,EAAE,EAAE,eAAe,EACnB,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,QAGZ;AAED,wBAAgB,WAAW,CACzB,EAAE,EAAE,eAAe,EACnB,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,QAGZ;AAqBD,wBAAgB,aAAa,CAC3B,EAAE,EAAE,eAAe,EACnB,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,MAAM,QAgBd"}

package/out/zero-cache/src/services/replicator/schema/change-log.js

@@ -0,0 +1,78 @@
+import * as v from '../../../../../shared/src/valita.js';
+import { StatementRunner } from '../../../../../zero-cache/src/db/statements.js';
+import { jsonObjectSchema, parse, stringify, } from '../../../../../zero-cache/src/types/bigint-json.js';
+import { normalizedKeyOrder } from '../../../../../zero-cache/src/types/row-key.js';
+/**
+ * The Change Log tracks the last operation (set or delete) for each row in the
+ * data base, ordered by state version; in other words, a cross-table
+ * index of row changes ordered by version. This facilitates a minimal "diff"
+ * of row changes needed to advance a pipeline from one state version to another.
+ *
+ * The Change Log stores identifiers only, i.e. it does not store contents.
+ * A database snapshot at the previous version can be used to query a row's
+ * old contents, if any, and the current snapshot can be used to query a row's
+ * new contents. (In the common case, the new contents will have just been applied
+ * and thus has a high likelihood of being in the SQLite cache.)
+ *
+ * The postgres TRUNCATE operation is represented as a log entry with a `null` row
+ * key, which means that it is sorted before any row operations for that table.
+ */
+export const SET_OP = 's';
+export const DEL_OP = 'd';
+export const TRUNCATE_OP = 't';
+const CREATE_CHANGELOG_SCHEMA = 
+// stateVersion : a.k.a. row version
+// table        : The table associated with the change
+// rowKey       : JSON row key for a row change, or NULL for a table TRUNCATE.
+//                Note that SQLite will sort rows such that TRUNCATE operations appear
+//                before row operations (as desired), as NULL appears before non-NULL values.
+// op           : 't' for table truncation, 's' for set (insert/update), and 'd' for delete
+`
+  CREATE TABLE "_zero.ChangeLog" (
+    "stateVersion" TEXT NOT NULL,
+    "table"        TEXT NOT NULL,
+    "rowKey"       TEXT,
+    "op"           TEXT NOT NULL,
+    PRIMARY KEY("stateVersion", "table", "rowKey"),
+    UNIQUE("table", "rowKey")
+  )
+  `;
+export const changeLogEntrySchema = v
+    .object({
+    stateVersion: v.string(),
+    table: v.string(),
+    rowKey: v.string().nullable(),
+    op: v.union(v.literal(SET_OP), v.literal(DEL_OP), v.literal(TRUNCATE_OP)),
+})
+    .map(val => ({
+    ...val,
+    rowKey: val.rowKey ? v.parse(parse(val.rowKey), jsonObjectSchema) : null,
+}));
+export function initChangeLog(db) {
+    db.exec(CREATE_CHANGELOG_SCHEMA);
+}
+export function logSetOp(db, version, table, row) {
+    logRowOp(db, version, table, row, SET_OP);
+}
+export function logDeleteOp(db, version, table, row) {
+    logRowOp(db, version, table, row, DEL_OP);
+}
+function logRowOp(db, version, table, row, op) {
+    const rowKey = stringify(normalizedKeyOrder(row));
+    db.run(`
+    INSERT INTO "_zero.ChangeLog" (stateVersion, "table", rowKey, op)
+      VALUES (@version, @table, JSON(@rowKey), @op)
+      ON CONFLICT ("table", rowKey) DO UPDATE
+      SET stateVersion = @version, op = @op
+    `, { version, table, rowKey, op });
+}
+export function logTruncateOp(db, version, table) {
+    db.run(`
+    DELETE FROM "_zero.ChangeLog" WHERE "table" = ?
+    `, table);
+    db.run(`
+    INSERT INTO "_zero.ChangeLog" (stateVersion, "table", op) 
+      VALUES (@version, @table, @op)
+    `, { version, table, op: TRUNCATE_OP });
+}
+//# sourceMappingURL=change-log.js.map

package/out/zero-cache/src/services/replicator/schema/change-log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-log.js","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/replicator/schema/change-log.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,sBAAsB,CAAC;AAC1C,OAAO,EAAC,eAAe,EAAC,MAAM,iCAAiC,CAAC;AAChE,OAAO,EACL,gBAAgB,EAChB,KAAK,EACL,SAAS,GACV,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EAAC,kBAAkB,EAAc,MAAM,iCAAiC,CAAC;AAEhF;;;;;;;;;;;;;;GAcG;AAEH,MAAM,CAAC,MAAM,MAAM,GAAG,GAAG,CAAC;AAC1B,MAAM,CAAC,MAAM,MAAM,GAAG,GAAG,CAAC;AAC1B,MAAM,CAAC,MAAM,WAAW,GAAG,GAAG,CAAC;AAE/B,MAAM,uBAAuB;AAC3B,oCAAoC;AACpC,sDAAsD;AACtD,8EAA8E;AAC9E,sFAAsF;AACtF,6FAA6F;AAC7F,2FAA2F;AAC3F;;;;;;;;;GASC,CAAC;AAEJ,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC;KAClC,MAAM,CAAC;IACN,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE;IACxB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;IACjB,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC7B,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;CAC1E,CAAC;KACD,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACX,GAAG,GAAG;IACN,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC,IAAI;CACzE,CAAC,CAAC,CAAC;AAIN,MAAM,UAAU,aAAa,CAAC,EAAY;IACxC,EAAE,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;AACnC,CAAC;AAED,MAAM,UAAU,QAAQ,CACtB,EAAmB,EACnB,OAAoB,EACpB,KAAa,EACb,GAAW;IAEX,QAAQ,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;AAC5C,CAAC;AAED,MAAM,UAAU,WAAW,CACzB,EAAmB,EACnB,OAAoB,EACpB,KAAa,EACb,GAAW;IAEX,QAAQ,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;AAC5C,CAAC;AAED,SAAS,QAAQ,CACf,EAAmB,EACnB,OAAoB,EACpB,KAAa,EACb,GAAW,EACX,EAAU;IAEV,MAAM,MAAM,GAAG,SAAS,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC;IAClD,EAAE,CAAC,GAAG,CACJ;;;;;KAKC,EACD,EAAC,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAC,CAC7B,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,aAAa,CAC3B,EAAmB,EACnB,OAAoB,EACpB,KAAa;IAEb,EAAE,CAAC,GAAG,CACJ;;KAEC,EACD,KAAK,CACN,CAAC;IAEF,EAAE,CAAC,GAAG,CACJ;;;KAGC,EACD,EAAC,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,WAAW,EAAC,CAClC,CAAC;AACJ,CAAC"}

package/out/zero-cache/src/services/replicator/schema/replication-state.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Replication metadata, used for incremental view maintenance and catchup.
+ *
+ * These tables are created atomically in {@link setupReplicationTables}
+ * after the logical replication handoff when initial data synchronization has completed.
+ */
+import * as v from '../../../../../shared/src/valita.js';
+import { StatementRunner } from '../../../../../zero-cache/src/db/statements.js';
+import { Database } from '../../../../../zqlite/src/db.js';
+export declare const ZERO_VERSION_COLUMN_NAME = "_0_version";
+declare const versionsSchema: v.ObjectType<{
+    stateVersion: v.Type<string>;
+    nextStateVersion: v.Type<string>;
+}, undefined>;
+export type ReplicationVersions = v.Infer<typeof versionsSchema>;
+export declare function initReplicationState(db: Database, publications: string[], watermark: string): void;
+export declare function getSubscriptionState(db: StatementRunner): {
+    publications: string[];
+    replicaVersion: string;
+    watermark: string;
+};
+export declare function updateReplicationWatermark(db: StatementRunner, watermark: string): void;
+export declare function getReplicationVersions(db: StatementRunner): ReplicationVersions;
+export {};
+//# sourceMappingURL=replication-state.d.ts.map

package/out/zero-cache/src/services/replicator/schema/replication-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replication-state.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/replicator/schema/replication-state.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,CAAC,MAAM,sBAAsB,CAAC;AAC1C,OAAO,EAAC,eAAe,EAAC,MAAM,iCAAiC,CAAC;AAChE,OAAO,EAAC,QAAQ,EAAC,MAAM,kBAAkB,CAAC;AAE1C,eAAO,MAAM,wBAAwB,eAAe,CAAC;AA4CrD,QAAA,MAAM,cAAc;;;aAGlB,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEjE,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,QAAQ,EACZ,YAAY,EAAE,MAAM,EAAE,EACtB,SAAS,EAAE,MAAM,QAelB;AAED,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,eAAe;;;;EAUvD;AAED,wBAAgB,0BAA0B,CACxC,EAAE,EAAE,eAAe,EACnB,SAAS,EAAE,MAAM,QAelB;AAED,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,eAAe,GAClB,mBAAmB,CAKrB"}

package/out/zero-cache/src/services/replicator/schema/replication-state.js

@@ -0,0 +1,90 @@
+/**
+ * Replication metadata, used for incremental view maintenance and catchup.
+ *
+ * These tables are created atomically in {@link setupReplicationTables}
+ * after the logical replication handoff when initial data synchronization has completed.
+ */
+import * as v from '../../../../../shared/src/valita.js';
+import { StatementRunner } from '../../../../../zero-cache/src/db/statements.js';
+import { Database } from '../../../../../zqlite/src/db.js';
+export const ZERO_VERSION_COLUMN_NAME = '_0_version';
+const CREATE_REPLICATION_STATE_SCHEMA = 
+// replicaVersion   : A value identifying the version at which the initial sync happened, i.e.
+//                    at which all rows were copied and initialized with `_0_version: "00"`. This
+//                    value is used to distinguish data from other replicas (e.g. if a replica is
+//                    reset or if there are ever multiple replicas). Data from replicas with
+//                    different versions are incompatible, as their "00" version will correspond
+//                    to different snapshots of the upstream database.
+// publications     : JSON stringified array of publication names
+// lock             : Auto-magic column for enforcing single-row semantics.
+`
+  CREATE TABLE "_zero.ReplicationConfig" (
+    replicaVersion TEXT NOT NULL,
+    publications TEXT NOT NULL,
+    lock INTEGER PRIMARY KEY DEFAULT 1 CHECK (lock=1)
+  );
+  ` +
+    // watermark        : Lexicographically sortable watermark denoting the point from which replication
+    //                    should continue. For a Postgres upstream, for example, this is the
+    //                    LexiVersion-encoded LSN. This is also used as the state version for rows
+    //                    modified in the **next** transaction.
+    // stateVersion     : The value of the _0_version column for the newest rows in the database.
+    `
+  CREATE TABLE "_zero.ReplicationState" (
+    watermark TEXT NOT NULL,
+    stateVersion TEXT NOT NULL,
+    lock INTEGER PRIMARY KEY DEFAULT 1 CHECK (lock=1)
+  );
+  `;
+const stringArray = v.array(v.string());
+const subscriptionStateSchema = v
+    .object({
+    replicaVersion: v.string(),
+    publications: v.string(),
+    watermark: v.string(),
+})
+    .map(s => ({
+    ...s,
+    publications: v.parse(JSON.parse(s.publications), stringArray),
+}));
+const versionsSchema = v.object({
+    stateVersion: v.string(),
+    nextStateVersion: v.string(),
+});
+export function initReplicationState(db, publications, watermark) {
+    db.exec(CREATE_REPLICATION_STATE_SCHEMA);
+    db.prepare(`
+    INSERT INTO "_zero.ReplicationConfig" 
+       (replicaVersion, publications) VALUES (?, ?)
+    `).run(watermark, JSON.stringify(publications.sort()));
+    db.prepare(`
+    INSERT INTO "_zero.ReplicationState" 
+       (watermark, stateVersion) VALUES (?,'00')
+    `).run(watermark);
+}
+export function getSubscriptionState(db) {
+    const result = db.get(`
+      SELECT c.replicaVersion, c.publications, s.watermark 
+        FROM "_zero.ReplicationConfig" as c
+        JOIN "_zero.ReplicationState" as s
+        ON c.lock = s.lock
+    `);
+    return v.parse(result, subscriptionStateSchema);
+}
+export function updateReplicationWatermark(db, watermark) {
+    // The previous `watermark` needs to be set as the next `stateVersion`.
+    // Rather than explicitly looking that up with an additional statement, use an
+    // UPSERT for which the INSERT fails so that the value of `watermark`
+    // from the original row can be used to set the new `stateVersion`.
+    db.run(`
+      INSERT INTO "_zero.ReplicationState" 
+        (lock, watermark, stateVersion) VALUES (1,'','')
+        ON CONFLICT (lock)
+        DO UPDATE SET watermark=?, stateVersion=watermark
+    `, watermark);
+}
+export function getReplicationVersions(db) {
+    const result = db.get(`SELECT stateVersion, watermark as nextStateVersion FROM "_zero.ReplicationState"`);
+    return v.parse(result, versionsSchema);
+}
+//# sourceMappingURL=replication-state.js.map

package/out/zero-cache/src/services/replicator/schema/replication-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replication-state.js","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/replicator/schema/replication-state.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,CAAC,MAAM,sBAAsB,CAAC;AAC1C,OAAO,EAAC,eAAe,EAAC,MAAM,iCAAiC,CAAC;AAChE,OAAO,EAAC,QAAQ,EAAC,MAAM,kBAAkB,CAAC;AAE1C,MAAM,CAAC,MAAM,wBAAwB,GAAG,YAAY,CAAC;AAErD,MAAM,+BAA+B;AACnC,8FAA8F;AAC9F,iGAAiG;AACjG,iGAAiG;AACjG,4FAA4F;AAC5F,gGAAgG;AAChG,sEAAsE;AACtE,iEAAiE;AACjE,2EAA2E;AAC3E;;;;;;GAMC;IACD,oGAAoG;IACpG,wFAAwF;IACxF,8FAA8F;IAC9F,2DAA2D;IAC3D,6FAA6F;IAC7F;;;;;;GAMC,CAAC;AAEJ,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;AAExC,MAAM,uBAAuB,GAAG,CAAC;KAC9B,MAAM,CAAC;IACN,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE;IAC1B,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE;IACxB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;CACtB,CAAC;KACD,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACT,GAAG,CAAC;IACJ,YAAY,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,YAAY,CAAC,EAAE,WAAW,CAAC;CAC/D,CAAC,CAAC,CAAC;AAEN,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC;IAC9B,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE;IACxB,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE;CAC7B,CAAC,CAAC;AAIH,MAAM,UAAU,oBAAoB,CAClC,EAAY,EACZ,YAAsB,EACtB,SAAiB;IAEjB,EAAE,CAAC,IAAI,CAAC,+BAA+B,CAAC,CAAC;IACzC,EAAE,CAAC,OAAO,CACR;;;KAGC,CACF,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IACtD,EAAE,CAAC,OAAO,CACR;;;KAGC,CACF,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;AACnB,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,EAAmB;IACtD,MAAM,MAAM,GAAG,EAAE,CAAC,GAAG,CACnB;;;;;KAKC,CACF,CAAC;IACF,OAAO,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;AAClD,CAAC;AAED,MAAM,UAAU,0BAA0B,CACxC,EAAmB,EACnB,SAAiB;IAEjB,uEAAuE;IACvE,8EAA8E;IAC9E,qEAAqE;IACrE,mEAAmE;IACnE,EAAE,CAAC,GAAG,CACJ;;;;;KAKC,EACD,SAAS,CACV,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,sBAAsB,CACpC,EAAmB;IAEnB,MAAM,MAAM,GAAG,EAAE,CAAC,GAAG,CACnB,kFAAkF,CACnF,CAAC;IACF,OAAO,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AACzC,CAAC"}

package/out/zero-cache/src/services/runner.d.ts

@@ -0,0 +1,21 @@
+import { LogContext } from '@rocicorp/logger';
+import type { Service } from './service.js';
+/**
+ * Manages the creation and lifecycle of objects that implement
+ * {@link Service}.
+ */
+export declare class ServiceRunner<S extends Service> {
+    #private;
+    constructor(lc: LogContext, factory: (id: string) => S, isValid?: (existing: S) => boolean);
+    /**
+     * Creates and runs the Service with the given `id`, returning
+     * an existing one if it is still running a valid.
+     */
+    getService(id: string): S;
+}
+/**
+ * Runs the specified services, exiting on SIGTERM, or logging an error and
+ * exiting the process if any of them fail.
+ */
+export declare function runOrExit(lc: LogContext, ...services: Service[]): Promise<void>;
+//# sourceMappingURL=runner.d.ts.map

package/out/zero-cache/src/services/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/services/runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAC5C,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,cAAc,CAAC;AAE1C;;;GAGG;AACH,qBAAa,aAAa,CAAC,CAAC,SAAS,OAAO;;gBAOxC,EAAE,EAAE,UAAU,EACd,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,CAAC,EAC1B,OAAO,GAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,OAAoB;IAOhD;;;OAGG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,CAAC;CAqB1B;AAED;;;GAGG;AACH,wBAAsB,SAAS,CAC7B,EAAE,EAAE,UAAU,EACd,GAAG,QAAQ,EAAE,OAAO,EAAE,GACrB,OAAO,CAAC,IAAI,CAAC,CAqBf"}

package/out/zero-cache/src/services/runner.js

@@ -0,0 +1,63 @@
+import { LogContext } from '@rocicorp/logger';
+/**
+ * Manages the creation and lifecycle of objects that implement
+ * {@link Service}.
+ */
+export class ServiceRunner {
+    #lc;
+    #instances = new Map();
+    #create;
+    #isValid;
+    constructor(lc, factory, isValid = () => true) {
+        this.#lc = lc;
+        this.#create = factory;
+        this.#isValid = isValid;
+    }
+    /**
+     * Creates and runs the Service with the given `id`, returning
+     * an existing one if it is still running a valid.
+     */
+    getService(id) {
+        const existing = this.#instances.get(id);
+        if (existing && this.#isValid(existing)) {
+            return existing;
+        }
+        const service = this.#create(id);
+        this.#instances.set(id, service);
+        void service
+            .run()
+            .catch(e => {
+            this.#lc.error?.(`Error running ${service.constructor?.name} ${service.id}`, e);
+            this.#lc.info?.(e.toString());
+        })
+            .finally(() => {
+            this.#instances.delete(id);
+        });
+        return service;
+    }
+}
+/**
+ * Runs the specified services, exiting on SIGTERM, or logging an error and
+ * exiting the process if any of them fail.
+ */
+export async function runOrExit(lc, ...services) {
+    for (const signal of ['SIGINT', 'SIGQUIT', 'SIGTERM']) {
+        process.once(signal, () => {
+            for (const svc of services) {
+                lc.info?.(`exiting ${svc.constructor.name} (${svc.id}) for ${signal}`);
+                void svc.stop();
+            }
+        });
+    }
+    try {
+        // Exit if any of the services stop.
+        const svc = await Promise.race(services.map(svc => svc.run().then(() => svc)));
+        lc.info?.(`exiting because ${svc.constructor.name} (${svc.id}) stopped`);
+        process.exit(0);
+    }
+    catch (e) {
+        lc.error?.(`exiting on error`, e);
+        process.exit(-1);
+    }
+}
+//# sourceMappingURL=runner.js.map

package/out/zero-cache/src/services/runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.js","sourceRoot":"","sources":["../../../../../zero-cache/src/services/runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAG5C;;;GAGG;AACH,MAAM,OAAO,aAAa;IACf,GAAG,CAAa;IAChB,UAAU,GAAG,IAAI,GAAG,EAAa,CAAC;IAClC,OAAO,CAAoB;IAC3B,QAAQ,CAA2B;IAE5C,YACE,EAAc,EACd,OAA0B,EAC1B,UAAoC,GAAG,EAAE,CAAC,IAAI;QAE9C,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC;QACd,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;IAC1B,CAAC;IAED;;;OAGG;IACH,UAAU,CAAC,EAAU;QACnB,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACzC,IAAI,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YACxC,OAAO,QAAQ,CAAC;QAClB,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QACjC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QACjC,KAAK,OAAO;aACT,GAAG,EAAE;aACL,KAAK,CAAC,CAAC,CAAC,EAAE;YACT,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CACd,iBAAiB,OAAO,CAAC,WAAW,EAAE,IAAI,IAAI,OAAO,CAAC,EAAE,EAAE,EAC1D,CAAC,CACF,CAAC;YACF,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;QAChC,CAAC,CAAC;aACD,OAAO,CAAC,GAAG,EAAE;YACZ,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;QACL,OAAO,OAAO,CAAC;IACjB,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAC7B,EAAc,EACd,GAAG,QAAmB;IAEtB,KAAK,MAAM,MAAM,IAAI,CAAC,QAAQ,EAAE,SAAS,EAAE,SAAS,CAAU,EAAE,CAAC;QAC/D,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE;YACxB,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;gBAC3B,EAAE,CAAC,IAAI,EAAE,CAAC,WAAW,GAAG,CAAC,WAAW,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;gBACvE,KAAK,GAAG,CAAC,IAAI,EAAE,CAAC;YAClB,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,IAAI,CAAC;QACH,oCAAoC;QACpC,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,IAAI,CAC5B,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAC/C,CAAC;QACF,EAAE,CAAC,IAAI,EAAE,CAAC,mBAAmB,GAAG,CAAC,WAAW,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,WAAW,CAAC,CAAC;QACzE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,EAAE,CAAC,KAAK,EAAE,CAAC,kBAAkB,EAAE,CAAC,CAAC,CAAC;QAClC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IACnB,CAAC;AACH,CAAC"}

package/out/zero-cache/src/services/running-state.d.ts

@@ -0,0 +1,56 @@
+import { LogContext } from '@rocicorp/logger';
+import { sleepWithAbort } from '../../../shared/src/sleep.js';
+export type RetryConfig = {
+    initialRetryDelay?: number;
+    maxRetryDelay?: number;
+};
+export interface Cancelable {
+    cancel(): void;
+}
+export type UnregisterFn = () => void;
+/**
+ * Facilitates lifecycle control with exponential backoff.
+ */
+export declare class RunningState {
+    #private;
+    constructor(serviceName: string, retryConfig?: RetryConfig, sleeper?: typeof sleepWithAbort);
+    /**
+     * Returns `true` until {@link stop()} has been called.
+     *
+     * This is usually called as part of the service's main loop
+     * conditional to determine if the next iteration should execute.
+     */
+    shouldRun(): boolean;
+    /**
+     * Registers a Cancelable object to be invoked when {@link stop()} is called.
+     * Returns a method to unregister the object.
+     */
+    cancelOnStop(c: Cancelable): UnregisterFn;
+    /**
+     * Called to stop the service. After this is called, {@link shouldRun()}
+     * will return `false` and the {@link stopped()} Promise will be resolved.
+     */
+    stop(lc: LogContext, err?: unknown): void;
+    /**
+     * Returns a Promise that resolves when {@link stop()} is called.
+     * This is used internally to cut off a {@link backoff()} delay, but
+     * can also be used explicitly in a `Promise.race(...)` call to stop
+     * stop waiting for work.
+     */
+    stopped(): Promise<void>;
+    /**
+     * Call in response to an error or unexpected termination in the main
+     * loop of the service. The returned Promise will resolve after an
+     * exponential delay, or once {@link stop()} is called.
+     *
+     * If the supplied `err` is an `AbortError`, the service will shut down.
+     */
+    backoff(lc: LogContext, err?: unknown): Promise<void>;
+    /**
+     * When using {@link backoff()}, this method should be called when the
+     * implementation receives a healthy signal (e.g. a successful
+     * response). This resets the delay used in {@link backoff()}.
+     */
+    resetBackoff(): void;
+}
+//# sourceMappingURL=running-state.d.ts.map

package/out/zero-cache/src/services/running-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"running-state.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/services/running-state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAG5C,OAAO,EAAC,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAKnD,MAAM,MAAM,WAAW,GAAG;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,WAAW,UAAU;IACzB,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,MAAM,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC;AAEtC;;GAEG;AACH,qBAAa,YAAY;;gBAWrB,WAAW,EAAE,MAAM,EACnB,WAAW,CAAC,EAAE,WAAW,EACzB,OAAO,wBAAiB;IAsB1B;;;;;OAKG;IACH,SAAS,IAAI,OAAO;IAIpB;;;OAGG;IACH,YAAY,CAAC,CAAC,EAAE,UAAU,GAAG,YAAY;IAMzC;;;OAGG;IACH,IAAI,CAAC,EAAE,EAAE,UAAU,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,IAAI;IAWzC;;;;;OAKG;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB;;;;;;OAMG;IACG,OAAO,CAAC,EAAE,EAAE,UAAU,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB3D;;;;OAIG;IACH,YAAY;CAGb"}