@carno.js/live 1.8.0

package/dist/client/vanilla.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveSlot = void 0;
+exports.liveStoreOf = liveStoreOf;
+exports.liveIdentity = liveIdentity;
+exports.liveStore = liveStore;
+const canonical_1 = require("../shared/canonical");
+const descriptor_1 = require("../shared/descriptor");
+/**
+ * Resolve a descriptor or a resource id to the underlying store.
+ *
+ * Framework adapters go through here rather than through `liveStore()`: they
+ * already own their own teardown, and wrapping a second lifecycle around the
+ * one the framework gives them is how an adapter starts leaking.
+ */
+function liveStoreOf(client, resource, inputs = {}) {
+    const resourceId = typeof resource === 'string' ? resource : (0, descriptor_1.resourceIdOf)(resource);
+    return client.store(resourceId, (0, descriptor_1.normalizeLiveInputs)(inputs));
+}
+/**
+ * Canonical identity of a subscription, for adapters that need to know whether
+ * reactive inputs actually changed before tearing a subscription down.
+ */
+function liveIdentity(resource, inputs = {}) {
+    const resourceId = typeof resource === 'string' ? resource : (0, descriptor_1.resourceIdOf)(resource);
+    const normalized = (0, descriptor_1.normalizeLiveInputs)(inputs);
+    return `${resourceId}|${(0, canonical_1.canonical)({
+        params: normalized.params,
+        query: normalized.query,
+        body: normalized.body ?? null
+    })}`;
+}
+/**
+ * Subscribe without a framework.
+ *
+ * This is the whole vanilla adapter, and it is small on purpose: everything
+ * hard -- dedupe, revisions, resync, reconnect, the optimistic stack -- is in
+ * the client, and an adapter that grows is logic leaking out of it.
+ */
+function liveStore(client, resource, 
+// Loose on purpose, and invisible to callers: a descriptor's own `query`
+// type is a plain object, which no index signature accepts. The overloads
+// above are what anyone actually sees.
+inputs = {}) {
+    const store = liveStoreOf(client, resource, inputs);
+    const drops = new Set();
+    return {
+        get: () => store.getSnapshot(),
+        subscribe(listener) {
+            const drop = store.subscribe(() => listener(store.getSnapshot()));
+            drops.add(drop);
+            // Idempotent: calling this and then close() must not release the
+            // client's refcount twice, or an unrelated handle loses its data.
+            return () => {
+                if (drops.delete(drop)) {
+                    drop();
+                }
+            };
+        },
+        close() {
+            for (const drop of [...drops]) {
+                drops.delete(drop);
+                drop();
+            }
+        }
+    };
+}
+const EMPTY_STATE = { data: undefined, pending: true, error: null, stale: false };
+/**
+ * A subscription that points at one target at a time.
+ *
+ * Reactive frameworks re-run an expression when its inputs change, and for a
+ * live subscription that means "this component now wants a different instance".
+ * The rule that makes that safe has nothing to do with any framework, so it
+ * lives here: recomputing to the same inputs must not churn the subscription,
+ * and switching targets must release the old one *before* retaining the new
+ * one. Holding both across the switch is how a dragged filter walks a
+ * connection into `maxInstancesPerConnection`.
+ */
+class LiveSlot {
+    constructor(client, onState) {
+        this.client = client;
+        this.onState = onState;
+        this.identity = null;
+        this.release = null;
+        this.store = null;
+    }
+    point(resource, inputs = {}) {
+        const next = liveIdentity(resource, inputs);
+        if (next === this.identity) {
+            return;
+        }
+        this.release?.();
+        this.release = null;
+        this.identity = next;
+        this.store = liveStoreOf(this.client, resource, inputs);
+        const store = this.store;
+        this.release = store.subscribe(() => this.onState(store.getSnapshot()));
+        this.onState(store.getSnapshot());
+    }
+    get() {
+        return this.store?.getSnapshot() ?? EMPTY_STATE;
+    }
+    close() {
+        this.release?.();
+        this.release = null;
+        this.store = null;
+        this.identity = null;
+    }
+}
+exports.LiveSlot = LiveSlot;

package/dist/client/vue.d.ts

@@ -0,0 +1,12 @@
+import { type InjectionKey, type ShallowRef } from 'vue';
+import type { LiveDataOf, LiveDescriptor, LiveInputsOf } from '../shared/descriptor';
+import type { LiveClient, LiveState } from './core';
+export declare const LIVE_CLIENT_KEY: InjectionKey<LiveClient>;
+/** Call once, high in the tree. Every useLiveQuery() below it finds the client. */
+export declare function provideLiveClient(client: LiveClient): void;
+export declare function useLiveQuery<R>(descriptor: LiveDescriptor<R>, inputs?: () => LiveInputsOf<R>, options?: {
+    client?: LiveClient;
+}): ShallowRef<LiveState<LiveDataOf<R>>>;
+export declare function useLiveQuery<T>(resourceId: string, inputs?: () => Record<string, any>, options?: {
+    client?: LiveClient;
+}): ShallowRef<LiveState<T>>;

package/dist/client/vue.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIVE_CLIENT_KEY = void 0;
+exports.provideLiveClient = provideLiveClient;
+exports.useLiveQuery = useLiveQuery;
+const vue_1 = require("vue");
+const vanilla_1 = require("./vanilla");
+exports.LIVE_CLIENT_KEY = Symbol('carno.live.client');
+/** Call once, high in the tree. Every useLiveQuery() below it finds the client. */
+function provideLiveClient(client) {
+    (0, vue_1.provide)(exports.LIVE_CLIENT_KEY, client);
+}
+const PENDING = { data: undefined, pending: true, error: null, stale: false };
+/**
+ * Subscribe a component to server-owned state, as a shallow ref.
+ *
+ * Shallow because the server replaces the whole snapshot and nothing ever
+ * writes into it: a deep proxy would pay to track mutations that cannot
+ * happen. `inputs` is read inside a watchEffect, so a ref it touches
+ * re-points the subscription; the effect scope tears it down.
+ */
+function useLiveQuery(resource, inputs = () => ({}), options = {}) {
+    const client = options.client
+        ?? ((0, vue_1.getCurrentInstance)() ? (0, vue_1.inject)(exports.LIVE_CLIENT_KEY, undefined) : undefined);
+    if (!client) {
+        throw new Error('useLiveQuery() found no LiveClient. Call provideLiveClient(client) in an ancestor ' +
+            'component, or pass { client } explicitly.');
+    }
+    const state = (0, vue_1.shallowRef)(PENDING);
+    const slot = new vanilla_1.LiveSlot(client, next => { state.value = next; });
+    const target = (0, vue_1.computed)(() => inputs());
+    (0, vue_1.watchEffect)(() => slot.point(resource, target.value));
+    (0, vue_1.onScopeDispose)(() => slot.close());
+    return state;
+}

package/dist/config.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Tunables from §10.1 of the design. These are starting points to calibrate
+ * against the recompute-without-patch metric, not measured values.
+ */
+export interface LiveConfig {
+    /** Window in ms over which invalidations for one instance are grouped. */
+    coalesceMs: number;
+    /** Above this many row keys, one read collapses to its table key. */
+    maxKeysPerRead: number;
+    /** Ceiling on the canonicalized inputs of a single subscription. */
+    maxInputBytes: number;
+    /** Grace period before dropping an instance whose refcount hit zero. */
+    unsubGraceMs: number;
+    /** Consecutive back-pressured sends before collapsing to a snapshot. */
+    maxPendingPatches: number;
+    /** Above this fan-out, recompute is queued instead of run inline. */
+    fanoutQueueThreshold: number;
+    /** Ceiling on live instances held by a single connection. */
+    maxInstancesPerConnection: number;
+    /** Ceiling on live instances held by this process. */
+    maxInstancesPerNode: number;
+    /** Path of the SSE downstream, when the SSE transport is on. */
+    ssePath: string;
+    /** Path client messages are posted to, when the SSE transport is on. */
+    sseControlPath: string;
+    /** Comment frame interval that keeps idle-timeout proxies from reaping. */
+    sseHeartbeatMs: number;
+    /** Ceiling on concurrent SSE streams held by this process. */
+    sseMaxConnections: number;
+}
+export declare const DEFAULT_LIVE_CONFIG: LiveConfig;
+export declare function resolveLiveConfig(overrides?: Partial<LiveConfig>): LiveConfig;

package/dist/config.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_LIVE_CONFIG = void 0;
+exports.resolveLiveConfig = resolveLiveConfig;
+exports.DEFAULT_LIVE_CONFIG = {
+    coalesceMs: 16,
+    maxKeysPerRead: 64,
+    maxInputBytes: 8192,
+    unsubGraceMs: 5000,
+    maxPendingPatches: 32,
+    fanoutQueueThreshold: 500,
+    maxInstancesPerConnection: 64,
+    maxInstancesPerNode: 50000,
+    ssePath: '/live/sse',
+    sseControlPath: '/live/control',
+    sseHeartbeatMs: 15000,
+    sseMaxConnections: 10000
+};
+function resolveLiveConfig(overrides = {}) {
+    return { ...exports.DEFAULT_LIVE_CONFIG, ...overrides };
+}

package/dist/decorators/Live.d.ts

@@ -0,0 +1,4 @@
+import 'reflect-metadata';
+import { type LiveOptions } from '../metadata';
+/** Marks an existing route as subscribable while keeping it a normal HTTP route. */
+export declare function Live(options?: LiveOptions): MethodDecorator;

package/dist/decorators/Live.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Live = Live;
+require("reflect-metadata");
+const metadata_1 = require("../metadata");
+/** Marks an existing route as subscribable while keeping it a normal HTTP route. */
+function Live(options = {}) {
+    return function (target, propertyKey) {
+        const meta = {
+            key: options.key,
+            shared: options.shared ?? 'private',
+            dependsOn: options.dependsOn ?? [],
+            handlerName: String(propertyKey)
+        };
+        Reflect.defineMetadata(metadata_1.LIVE_META, meta, target.constructor, String(propertyKey));
+    };
+}

package/dist/emitters/AppEmitter.d.ts

@@ -0,0 +1,20 @@
+import type { InvalidationBus } from '../bus/InvalidationBus';
+import type { LiveConfig } from '../config';
+export declare class WriteDuringComputeError extends Error {
+    constructor(table: string | undefined, operation: string | undefined);
+}
+/**
+ * First of the three invalidation sources in §4.4: writes issued through
+ * @carno.js/orm. Costs no infrastructure, and covers everything the
+ * application itself writes.
+ */
+export declare class AppEmitter {
+    private readonly bus;
+    private readonly config;
+    /** Tables announced by another emitter, so we do not announce them twice. */
+    private covered;
+    constructor(bus: InvalidationBus, config: LiveConfig);
+    setCoveredTables(tables: Iterable<string>): void;
+    attach(): void;
+    detach(): void;
+}

package/dist/emitters/AppEmitter.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppEmitter = exports.WriteDuringComputeError = void 0;
+const orm_1 = require("@carno.js/orm");
+const dep_key_1 = require("../graph/dep-key");
+const dependency_context_1 = require("../resource/dependency-context");
+const statement_keys_1 = require("./statement-keys");
+class WriteDuringComputeError extends Error {
+    constructor(table, operation) {
+        super(`A live resource compute attempted a ${operation ?? 'write'} on "${table ?? 'unknown'}". ` +
+            `A resource reads; an action writes. Re-running the handler on every change would ` +
+            `duplicate the side effect, so the write is refused.`);
+        this.name = 'WriteDuringComputeError';
+    }
+}
+exports.WriteDuringComputeError = WriteDuringComputeError;
+/**
+ * First of the three invalidation sources in §4.4: writes issued through
+ * @carno.js/orm. Costs no infrastructure, and covers everything the
+ * application itself writes.
+ */
+class AppEmitter {
+    constructor(bus, config) {
+        this.bus = bus;
+        this.config = config;
+        /** Tables announced by another emitter, so we do not announce them twice. */
+        this.covered = new Set();
+    }
+    setCoveredTables(tables) {
+        this.covered = new Set(tables);
+    }
+    attach() {
+        orm_1.statementObserver.onRead((statement) => {
+            const collector = dependency_context_1.dependencyContext.current();
+            if (!collector) {
+                // A read outside any compute: an ordinary request. Nothing to record.
+                return;
+            }
+            collector.addAll((0, statement_keys_1.readDependencies)(statement, this.config.maxKeysPerRead));
+        });
+        orm_1.statementObserver.onWriteAttempt((statement) => {
+            if (dependency_context_1.dependencyContext.isActive()) {
+                throw new WriteDuringComputeError(statement.table, statement.statement);
+            }
+        });
+        orm_1.statementObserver.onWrite((statement) => {
+            const events = (0, statement_keys_1.writeEvents)(statement, this.config.maxKeysPerRead);
+            // A table watched by the Postgres emitter already announces itself
+            // through the trigger, on every node at once. Publishing here too
+            // would only buy a duplicate recompute.
+            const ours = events.filter(event => !this.covered.has((0, dep_key_1.tableOfKey)(event.key) ?? ''));
+            this.bus.publish(ours);
+        });
+    }
+    detach() {
+        orm_1.statementObserver.reset();
+    }
+}
+exports.AppEmitter = AppEmitter;

package/dist/emitters/pg-listener.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The slice of Bun's Postgres client this module needs.
+ *
+ * Bun 1.4 implements `listen` and `notify` at runtime, but `@types/bun` does
+ * not declare them and the published docs still list them as unimplemented.
+ * Declaring the slice here keeps the cast in one place, and makes the whole
+ * thing injectable so the unit tests need no database.
+ */
+export interface ListenableSql {
+    listen(channel: string, onNotify: (payload: string) => void): Promise<unknown>;
+    notify(channel: string, payload?: string): Promise<unknown>;
+    unsafe(query: string): Promise<unknown>;
+    close(): Promise<void>;
+}
+export interface PgListenerOptions {
+    url: string;
+    /** Liveness check interval. Zero disables the timer; `check()` still works. */
+    heartbeatMs?: number;
+    /** Delay between reconnection attempts. */
+    retryMs?: number;
+    /** Injected in tests. Defaults to a dedicated single Bun connection. */
+    sqlFactory?: (url: string) => ListenableSql;
+    /**
+     * Fired after the connection came back and every channel was re-listened.
+     *
+     * Whatever was published while the socket was down is gone with no trace,
+     * so the caller has to assume the worst — see PgNotifyEmitter.
+     */
+    onReconnect?: () => void;
+}
+/** One dedicated Postgres connection held open for LISTEN, with reconnection. */
+export declare class PgListener {
+    private readonly options;
+    private sql;
+    private readonly channels;
+    private timer;
+    private opening;
+    private closed;
+    constructor(options: PgListenerOptions);
+    listen(channel: string, onNotify: (payload: string) => void): Promise<void>;
+    notify(channel: string, payload: string): Promise<void>;
+    /** One liveness probe. Called by the heartbeat and directly by tests. */
+    check(): Promise<void>;
+    close(): Promise<void>;
+    private factory;
+    private connect;
+    private open;
+    private startHeartbeat;
+    private reconnect;
+}

package/dist/emitters/pg-listener.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgListener = void 0;
+const bun_1 = require("bun");
+const DEFAULT_HEARTBEAT_MS = 5000;
+const DEFAULT_RETRY_MS = 1000;
+function defaultSqlFactory(url) {
+    // A LISTEN connection cannot be shared with the query pool: it sits open
+    // waiting for asynchronous notifications, so it gets its own socket.
+    return new bun_1.SQL({ url, max: 1 });
+}
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+/** One dedicated Postgres connection held open for LISTEN, with reconnection. */
+class PgListener {
+    constructor(options) {
+        this.options = options;
+        this.sql = null;
+        this.channels = new Map();
+        this.timer = null;
+        this.opening = null;
+        this.closed = false;
+    }
+    async listen(channel, onNotify) {
+        const known = this.channels.has(channel);
+        this.channels.set(channel, onNotify);
+        if (!this.sql) {
+            // `open()` subscribes every registered channel, this one included.
+            await this.connect();
+            return;
+        }
+        if (!known) {
+            await this.sql.listen(channel, onNotify);
+        }
+    }
+    async notify(channel, payload) {
+        await this.connect();
+        await this.sql?.notify(channel, payload);
+    }
+    /** One liveness probe. Called by the heartbeat and directly by tests. */
+    async check() {
+        if (this.closed || !this.sql) {
+            return;
+        }
+        try {
+            await this.sql.unsafe('SELECT 1');
+        }
+        catch {
+            await this.reconnect();
+        }
+    }
+    async close() {
+        this.closed = true;
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        const sql = this.sql;
+        this.sql = null;
+        try {
+            await sql?.close();
+        }
+        catch {
+            // Already gone. Nothing to do and nothing to report.
+        }
+    }
+    // ------------------------------------------------------------ internals
+    factory() {
+        return this.options.sqlFactory ?? defaultSqlFactory;
+    }
+    async connect() {
+        if (this.sql || this.closed) {
+            return;
+        }
+        if (!this.opening) {
+            this.opening = this.open().finally(() => {
+                this.opening = null;
+            });
+        }
+        await this.opening;
+    }
+    async open() {
+        const sql = this.factory()(this.options.url);
+        for (const [channel, handler] of this.channels) {
+            await sql.listen(channel, handler);
+        }
+        this.sql = sql;
+        this.startHeartbeat();
+    }
+    startHeartbeat() {
+        const interval = this.options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
+        if (this.timer || interval <= 0) {
+            return;
+        }
+        this.timer = setInterval(() => {
+            void this.check();
+        }, interval);
+    }
+    async reconnect() {
+        const previous = this.sql;
+        this.sql = null;
+        try {
+            await previous?.close();
+        }
+        catch {
+            // The socket is what just failed; closing it is best effort.
+        }
+        while (!this.closed) {
+            try {
+                await this.open();
+                this.options.onReconnect?.();
+                return;
+            }
+            catch {
+                this.sql = null;
+                await delay(this.options.retryMs ?? DEFAULT_RETRY_MS);
+            }
+        }
+    }
+}
+exports.PgListener = PgListener;

package/dist/emitters/pg-notify-emitter.d.ts

@@ -0,0 +1,59 @@
+import type { InvalidationEvent } from '../graph/types';
+import { PgListener } from './pg-listener';
+export interface PgNotifyTable {
+    /** Table name as it exists in the database, unqualified. */
+    table: string;
+    /** Primary key column, as it exists in the database. */
+    primaryKey: string;
+}
+export interface PgNotifyEmitterOptions {
+    tables: PgNotifyTable[];
+    /** Connection string. Defaults to the ORM's own. */
+    url: string;
+    /** Runs the DDL. Defaults to the ORM driver's `executeSql`. */
+    execute: (sql: string) => Promise<unknown>;
+    channel?: string;
+    maxPayloadBytes?: number;
+    heartbeatMs?: number;
+    retryMs?: number;
+    /** Injected in tests. */
+    listener?: PgListener;
+}
+export declare const DEFAULT_PG_CHANNEL = "carno_live";
+export declare const DEFAULT_PG_MAX_PAYLOAD_BYTES = 7000;
+/**
+ * Turn one trigger payload into invalidation events.
+ *
+ * Exported on its own because it is the whole translation layer between
+ * Postgres and the graph, and it is worth testing without a database.
+ */
+export declare function eventsFromPayload(raw: string): InvalidationEvent[];
+/**
+ * The second emitter of §4.4: writes that never went through @carno.js/orm.
+ *
+ * A trigger per watched table produces table + primary key + changed columns,
+ * which is the same key vocabulary the application emitter produces. The graph
+ * cannot tell them apart, and does not need to.
+ */
+export declare class PgNotifyEmitter {
+    private readonly deliver;
+    private readonly options;
+    private readonly listener;
+    private readonly channel;
+    private attached;
+    constructor(deliver: (events: InvalidationEvent[]) => void, options: PgNotifyEmitterOptions);
+    /** Tables this emitter announces, so the ORM emitter can skip them. */
+    coveredTables(): Set<string>;
+    /** Install the trigger function and one trigger per watched table. */
+    install(): Promise<void>;
+    attach(): Promise<void>;
+    detach(): Promise<void>;
+    /** Remove the triggers. The function is left in place; it is harmless. */
+    uninstall(): Promise<void>;
+    /**
+     * Whatever was written while the socket was down arrived nowhere, and there
+     * is no way to ask Postgres what we missed. The only correct move is to
+     * assume everything watched is stale.
+     */
+    private onReconnect;
+}

package/dist/emitters/pg-notify-emitter.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgNotifyEmitter = exports.DEFAULT_PG_MAX_PAYLOAD_BYTES = exports.DEFAULT_PG_CHANNEL = void 0;
+exports.eventsFromPayload = eventsFromPayload;
+const dep_key_1 = require("../graph/dep-key");
+const pg_listener_1 = require("./pg-listener");
+const pg_trigger_sql_1 = require("./pg-trigger-sql");
+exports.DEFAULT_PG_CHANNEL = 'carno_live';
+exports.DEFAULT_PG_MAX_PAYLOAD_BYTES = 7000;
+/**
+ * Turn one trigger payload into invalidation events.
+ *
+ * Exported on its own because it is the whole translation layer between
+ * Postgres and the graph, and it is worth testing without a database.
+ */
+function eventsFromPayload(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        // Someone else is using our channel. Not our problem, and not a crash.
+        return [];
+    }
+    if (!parsed || typeof parsed.t !== 'string' || parsed.t === '') {
+        return [];
+    }
+    const table = parsed.t;
+    const columns = Array.isArray(parsed.c)
+        ? parsed.c.filter(item => typeof item === 'string')
+        : [];
+    const id = typeof parsed.i === 'string' || typeof parsed.i === 'number' ? parsed.i : null;
+    return [{
+            key: id === null ? (0, dep_key_1.tableKey)(table) : (0, dep_key_1.rowKey)(table, id),
+            // An empty list is "we do not know which columns", not "no columns".
+            columns: columns.length > 0 ? columns : null
+        }];
+}
+/**
+ * The second emitter of §4.4: writes that never went through @carno.js/orm.
+ *
+ * A trigger per watched table produces table + primary key + changed columns,
+ * which is the same key vocabulary the application emitter produces. The graph
+ * cannot tell them apart, and does not need to.
+ */
+class PgNotifyEmitter {
+    constructor(deliver, options) {
+        this.deliver = deliver;
+        this.options = options;
+        this.attached = false;
+        this.channel = options.channel ?? exports.DEFAULT_PG_CHANNEL;
+        this.listener = options.listener ?? new pg_listener_1.PgListener({
+            url: options.url,
+            heartbeatMs: options.heartbeatMs,
+            retryMs: options.retryMs,
+            onReconnect: () => this.onReconnect()
+        });
+    }
+    /** Tables this emitter announces, so the ORM emitter can skip them. */
+    coveredTables() {
+        return new Set(this.options.tables.map(entry => entry.table));
+    }
+    /** Install the trigger function and one trigger per watched table. */
+    async install() {
+        await this.options.execute((0, pg_trigger_sql_1.createFunctionSql)(this.options.maxPayloadBytes ?? exports.DEFAULT_PG_MAX_PAYLOAD_BYTES));
+        for (const entry of this.options.tables) {
+            await this.options.execute((0, pg_trigger_sql_1.createTriggerSql)(entry.table, entry.primaryKey, this.channel));
+        }
+    }
+    async attach() {
+        if (this.attached) {
+            return;
+        }
+        this.attached = true;
+        await this.install();
+        await this.listener.listen(this.channel, payload => {
+            const events = eventsFromPayload(payload);
+            if (events.length > 0) {
+                this.deliver(events);
+            }
+        });
+    }
+    async detach() {
+        this.attached = false;
+        await this.listener.close();
+    }
+    /** Remove the triggers. The function is left in place; it is harmless. */
+    async uninstall() {
+        for (const entry of this.options.tables) {
+            await this.options.execute((0, pg_trigger_sql_1.dropTriggerSql)(entry.table));
+        }
+    }
+    /**
+     * Whatever was written while the socket was down arrived nowhere, and there
+     * is no way to ask Postgres what we missed. The only correct move is to
+     * assume everything watched is stale.
+     */
+    onReconnect() {
+        this.deliver(this.options.tables.map(entry => ({
+            key: (0, dep_key_1.tableKey)(entry.table),
+            columns: null
+        })));
+    }
+}
+exports.PgNotifyEmitter = PgNotifyEmitter;