@seedprotocol/sdk 0.7.9-next.1177.ga3e08ed → 0.7.9-next.1306.g4ff6582

package/dist/changeFeed-DKdVlUmt.js

@@ -1,726 +0,0 @@
-import debug from 'debug';
-import { e as eventEmitter } from './eventBus-7vxTCc3a.js';
-import { am as isBrowser, Q as BaseFileManager, ac as EAS_SEED_DATA_SYNCED_TO_DB_EVENT, w as entityChanges } from './index-Dx_GTdyQ.js';
-import { sql, gt, lt } from 'drizzle-orm';
-
-/**
- * Phase timings for item creates, finds and property saves, and ready waits that timed out but
- * were allowed to continue, under `DEBUG=seedSdk:timing`. Timing lines are `<label> <ms>ms` plus
- * any details, so an app can report where a slow call spent its time.
- */
-const timingLogger = debug('seedSdk:timing');
-const now = () => (typeof performance !== 'undefined' ? performance.now() : Date.now());
-/** Runs `fn` and logs how long it took (also when it throws). Costs nothing when the namespace is off. */
-async function timed(label, fn, details) {
-    if (!timingLogger.enabled)
-        return fn();
-    const start = now();
-    let failed = false;
-    try {
-        return await fn();
-    }
-    catch (error) {
-        failed = true;
-        throw error;
-    }
-    finally {
-        const extra = details?.();
-        timingLogger(`${label} ${Math.round(now() - start)}ms${failed ? ' (failed)' : ''}${extra ? ` ${extra}` : ''}`);
-    }
-}
-/**
- * Database work counted while the namespace is on, so a timing line can say how much of its time
- * was the SQLite worker. Statements are the ones the SDK sends through the driver; their time runs
- * from send to result, so it includes the wait behind everything queued before them on the one
- * worker. Live-query runs are SQLocal reactive-query results (the first run and every re-run after
- * a write to a watched table), which go through the same worker but not through the driver.
- */
-const dbTimingCounters = {
-    statements: 0,
-    statementMs: 0,
-    inFlight: 0,
-    liveQueryRuns: 0,
-    liveQueryFirstRuns: 0,
-    liveQueryFirstRunMs: 0,
-};
-const snapshotCounters = () => ({ ...dbTimingCounters });
-/** Wraps a driver function so each call is counted while timing is on. */
-function countDbStatements(driver) {
-    return async (...args) => {
-        if (!timingLogger.enabled)
-            return driver(...args);
-        const start = now();
-        dbTimingCounters.inFlight += 1;
-        try {
-            return await driver(...args);
-        }
-        finally {
-            dbTimingCounters.inFlight -= 1;
-            dbTimingCounters.statements += 1;
-            dbTimingCounters.statementMs += now() - start;
-        }
-    };
-}
-/** Starts the clock for one live query; call the result on each of its runs. */
-function countLiveQueryRuns() {
-    if (!timingLogger.enabled)
-        return () => { };
-    const start = now();
-    let first = true;
-    return () => {
-        dbTimingCounters.liveQueryRuns += 1;
-        if (!first)
-            return;
-        first = false;
-        dbTimingCounters.liveQueryFirstRuns += 1;
-        dbTimingCounters.liveQueryFirstRunMs += now() - start;
-    };
-}
-const describeDbDelta = (before) => {
-    const after = dbTimingCounters;
-    const statements = after.statements - before.statements;
-    const statementMs = after.statementMs - before.statementMs;
-    const liveRuns = after.liveQueryRuns - before.liveQueryRuns;
-    const firstRuns = after.liveQueryFirstRuns - before.liveQueryFirstRuns;
-    const firstMs = after.liveQueryFirstRunMs - before.liveQueryFirstRunMs;
-    const parts = [`queued ${before.inFlight}`];
-    if (statements)
-        parts.push(`${statements} stmts avg ${Math.round(statementMs / statements)}ms`);
-    if (liveRuns)
-        parts.push(`${liveRuns} live runs`);
-    if (firstRuns)
-        parts.push(`${firstRuns} new live queries, first run avg ${Math.round(firstMs / firstRuns)}ms`);
-    return `[db: ${parts.join(', ')}]`;
-};
-/**
- * Like `timed`, and the line also says how many statements and live-query runs went through the
- * worker meanwhile (from any caller, since they share the queue) and how many statements were
- * already queued when it started.
- */
-async function timedDb(label, fn, details) {
-    if (!timingLogger.enabled)
-        return fn();
-    const before = snapshotCounters();
-    return timed(label, fn, () => [details?.(), describeDbDelta(before)].filter(Boolean).join(' '));
-}
-/** Milliseconds since `start` (a `timingNow()` value), rounded. */
-const timingSince = (start) => Math.round(now() - start);
-const timingNow = now;
-/**
- * Split timer for one multi-step call: `mark(step)` records the time since the previous mark, and
- * `log(label)` writes one line with the total and every step. Does nothing when timing is off.
- */
-function timingMarks() {
-    if (!timingLogger.enabled)
-        return { mark: () => { }, log: () => { } };
-    const start = now();
-    const before = snapshotCounters();
-    let last = start;
-    const steps = [];
-    return {
-        mark: (step) => {
-            const t = now();
-            steps.push(`${step} ${Math.round(t - last)}`);
-            last = t;
-        },
-        log: (label) => {
-            timingLogger(`${label} ${Math.round(now() - start)}ms: ${steps.join(', ')} ${describeDbDelta(before)}`);
-        },
-    };
-}
-
-/**
- * Cross-tab exclusive sections, using the Web Locks API. All tabs of an origin share one SQLite
- * database and OPFS tree; the browser releases a tab's locks when it closes or crashes, so a lock
- * can't go stale. See docs/MULTI_TAB.md.
- *
- * Node has Web Locks from 24.5, scoped to the process. Where they're missing (older Node, old
- * browsers), sections still run one at a time within this JS realm (see `withProcessLock`), which
- * covers a single Node process but not other tabs or worker threads.
- * Not re-entrant: requesting a name the caller already holds waits forever, so take each lock
- * only at the outermost call site.
- */
-/** Long enough for a slow init in another tab; short enough that a hung tab doesn't block forever. */
-const TAB_LOCK_WAIT_TIMEOUT_MS = 60000;
-function seedDbLockName(scope, filesDir) {
-    return `seed:${scope}:${filesDir}/db/seed.db`;
-}
-/** `withTabLock` on the database under `filesDir`; runs `fn` directly when there's no `filesDir` yet. */
-function withSeedDbLock(scope, filesDir, fn) {
-    return filesDir ? withTabLock(seedDbLockName(scope, filesDir), fn) : fn();
-}
-class TabLockTimeoutError extends Error {
-    constructor(lockName, timeoutMs) {
-        super(`Timed out after ${timeoutMs}ms waiting for another tab to release "${lockName}".`);
-        this.lockName = lockName;
-        this.code = 'TAB_LOCK_TIMEOUT';
-        this.name = 'TabLockTimeoutError';
-    }
-}
-async function withTabLock(name, fn, { timeoutMs = TAB_LOCK_WAIT_TIMEOUT_MS } = {}) {
-    const locks = typeof navigator !== 'undefined' ? navigator.locks : undefined;
-    if (!locks)
-        return withProcessLock(name, fn, { timeoutMs });
-    try {
-        // The timeout bounds the wait only; once granted, fn runs to completion. Infinity waits for as
-        // long as the holder runs (it can't outlive its tab).
-        const signal = Number.isFinite(timeoutMs) ? AbortSignal.timeout(timeoutMs) : undefined;
-        return await locks.request(name, { mode: 'exclusive', signal }, fn);
-    }
-    catch (error) {
-        if (error?.name === 'TimeoutError') {
-            throw new TabLockTimeoutError(name, timeoutMs);
-        }
-        throw error;
-    }
-}
-/**
- * Runs `fn` holding lock `name` only if no one holds it or waits for it now; otherwise runs nothing
- * and returns `{ acquired: false }`. For work that has something else to do meanwhile (the outbox
- * drainer).
- */
-async function tryWithTabLock(name, fn) {
-    const locks = typeof navigator !== 'undefined' ? navigator.locks : undefined;
-    if (!locks) {
-        if (processLockTails.has(name))
-            return { acquired: false };
-        return { acquired: true, value: await withProcessLock(name, fn) };
-    }
-    return locks.request(name, { mode: 'exclusive', ifAvailable: true }, async (lock) => lock ? { acquired: true, value: await fn() } : { acquired: false });
-}
-/** Tail of each name's queue: resolves once every section queued so far has finished or given up. */
-const processLockTails = new Map();
-/**
- * The `withTabLock` fallback without Web Locks: an exclusive, first-come-first-served lock per name
- * within this JS realm. Like Web Locks, `timeoutMs` bounds the wait only, and a waiter that times
- * out doesn't let later waiters in before the current holder finishes.
- */
-async function withProcessLock(name, fn, { timeoutMs = TAB_LOCK_WAIT_TIMEOUT_MS } = {}) {
-    const previous = processLockTails.get(name) ?? Promise.resolve();
-    let release;
-    const done = new Promise((resolve) => (release = resolve));
-    const tail = previous.then(() => done);
-    processLockTails.set(name, tail);
-    void tail.then(() => {
-        if (processLockTails.get(name) === tail)
-            processLockTails.delete(name);
-    });
-    try {
-        await waitForTurn(previous, name, timeoutMs);
-    }
-    catch (error) {
-        release();
-        throw error;
-    }
-    try {
-        return await fn();
-    }
-    finally {
-        release();
-    }
-}
-function waitForTurn(previous, name, timeoutMs) {
-    if (!Number.isFinite(timeoutMs))
-        return previous;
-    let timer;
-    const timedOut = new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new TabLockTimeoutError(name, timeoutMs)), timeoutMs);
-    });
-    return Promise.race([previous, timedOut]).finally(() => clearTimeout(timer));
-}
-
-const logger$2 = debug('seedSdk:helpers:tabCoordinator');
-/** Identifies this tab (this page's SDK instance) in the messages it sends. */
-const TAB_ID = typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
-    ? crypto.randomUUID()
-    : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
-let state;
-let leader = false;
-let leaderWaiters = [];
-const messageHandlers = new Set();
-/** Starts once per page; later calls (re-init) keep the first database. */
-function startTabCoordination({ filesDir, mode = 'coordinate' }) {
-    if (state)
-        return;
-    const locks = typeof navigator !== 'undefined' ? navigator.locks : undefined;
-    const dbKey = `${filesDir}/db/seed.db`;
-    const coordinating = mode === 'coordinate' && isBrowser() && !!locks && typeof BroadcastChannel !== 'undefined';
-    state = { dbKey, coordinating };
-    if (!coordinating) {
-        becomeLeader();
-        return;
-    }
-    const channel = new BroadcastChannel(`seed:tabs:${dbKey}`);
-    channel.onmessage = (event) => {
-        // A BroadcastChannel never hears itself, but another channel object in this page would (a
-        // second channel opened by a test, or the same module loaded twice): skip our own messages.
-        if (event.data?.from === TAB_ID)
-            return;
-        for (const handler of messageHandlers)
-            handler(event.data);
-    };
-    state.channel = channel;
-    const current = state;
-    void locks.request(`seed:leader:${dbKey}`, () => {
-        // Reset (tests) before the grant: hand the lock straight back.
-        if (state !== current)
-            return undefined;
-        becomeLeader();
-        // Held until the tab closes (or a test resets coordination).
-        return new Promise((release) => {
-            current.releaseLeadership = release;
-        });
-    });
-}
-function becomeLeader() {
-    if (leader)
-        return;
-    leader = true;
-    logger$2(`this tab leads ${state?.dbKey}`);
-    const waiters = leaderWaiters;
-    leaderWaiters = [];
-    for (const resolve of waiters)
-        resolve();
-}
-function isLeaderTab() {
-    return !state || leader;
-}
-/** Resolves when this tab leads (at once if it already does). */
-function whenLeaderTab() {
-    if (isLeaderTab())
-        return Promise.resolve();
-    return new Promise((resolve) => leaderWaiters.push(resolve));
-}
-/** Sends to the other tabs of this database; a no-op when not coordinating. */
-function postTabMessage(message) {
-    state?.channel?.postMessage({ ...message, from: TAB_ID });
-}
-/** Whether postTabMessage reaches other tabs (a browser tab coordinating with Web Locks). */
-function isPostingTabMessages() {
-    return !!state?.channel;
-}
-function onTabMessage(handler) {
-    messageHandlers.add(handler);
-    return () => messageHandlers.delete(handler);
-}
-/** `withTabLock` named for this database (`seed:<scope>:<db>`); runs `fn` directly before init. */
-function withDbTabLock(scope, fn, options) {
-    return state ? withTabLock(`seed:${scope}:${state.dbKey}`, fn, options) : fn();
-}
-
-/**
- * Blob URLs the SDK mints for property values (File and Image display URLs). Only these are revoked
- * by `ItemProperty`: a blob URL the app passed in as a value stays the app's to revoke.
- */
-const minted = new Set();
-const createSessionObjectUrl = (blob) => {
-    const url = URL.createObjectURL(blob);
-    minted.add(url);
-    return url;
-};
-const isSessionObjectUrl = (value) => typeof value === 'string' && minted.has(value);
-const revokeSessionObjectUrl = (url) => {
-    if (!minted.delete(url))
-        return;
-    URL.revokeObjectURL(url);
-};
-
-/** Emitted by the client manager after `app_state.addresses` is written (post-`setAddresses`). */
-const ADDRESSES_PERSISTED_EVENT = 'addresses.persisted';
-/** Emitted after hard-deleting local on-chain seed copies for publisher addresses. */
-const LOCAL_COPIES_REMOVED_EVENT = 'localCopies.removed';
-function parseAddressesPersistedPayload(value) {
-    if (!value || typeof value !== 'object') {
-        return { owned: [], watched: [] };
-    }
-    const v = value;
-    const owned = Array.isArray(v.owned)
-        ? v.owned.filter((a) => typeof a === 'string')
-        : [];
-    const watched = Array.isArray(v.watched)
-        ? v.watched.filter((a) => typeof a === 'string')
-        : [];
-    return { owned, watched };
-}
-
-const logger$1 = debug('seedSdk:helpers:tabEvents');
-/**
- * Keeps other tabs current (docs/MULTI_TAB.md). The event bus is per tab, so events that mean "the
- * shared database or OPFS changed" are also posted to the other tabs, which refresh their caches
- * and emit the same event locally. Events are posted only where they originate, so a relayed event
- * is never relayed again.
- */
-/** Emitted with the changed paths when files change outside this tab's file-system cache. */
-const FILES_CHANGED_EVENT = 'fs.files.changed';
-/** Emits on this tab's event bus and in every other tab of this database. */
-function emitAcrossTabs(name, payload) {
-    if (payload === undefined) {
-        eventEmitter.emit(name);
-    }
-    else {
-        eventEmitter.emit(name, payload);
-    }
-    postTabMessage({ type: 'event', name, payload });
-}
-/**
- * A file saved through this tab's file system: emits `file-saved` here. Other tabs hear about it
- * from the file system itself (see queueFilesChangedNotice), once the write has reached OPFS.
- */
-function notifyFileSaved(filePath) {
-    eventEmitter.emit('file-saved', filePath);
-}
-/**
- * Files written straight to OPFS by a worker: refreshes this tab's file-system cache, emits
- * FILES_CHANGED_EVENT, and tells other tabs to do the same.
- */
-async function notifyFilesWrittenOutsideCache(paths) {
-    if (paths.length === 0)
-        return;
-    await BaseFileManager.invalidateCachedPaths(paths);
-    eventEmitter.emit(FILES_CHANGED_EVENT, paths);
-    queueFilesChangedNotice(paths);
-}
-/**
- * How long changed paths gather before one `files-changed` message goes out. Counted from the
- * first queued path, so a steady stream of writes still sends once per window, never later.
- */
-const FILES_CHANGED_FLUSH_MS = 25;
-/** Keeps a message for a huge batch (a bulk download) from being one giant structured clone. */
-const FILES_CHANGED_MAX_PATHS = 500;
-let pendingChangedPaths = new Set();
-let flushTimer;
-let flushOnPageHide = false;
-/**
- * Tells other tabs that these absolute ZenFS paths changed in OPFS, so they drop and re-read their
- * cached copies (the sync API's in-memory copy in particular). The browser file system calls this
- * for every file it writes, truncates or removes (`TolerantWebAccessFS.onOpfsChange`, wired in
- * `BrowserFileManager.initializeFileSystem`), after the change reached OPFS. Paths are coalesced
- * for FILES_CHANGED_FLUSH_MS, so bulk writes (migrations, schema processing, downloads) send a few
- * messages rather than one per write.
- *
- * Defense in depth only: a tab that misses a message still sees the change on its next async
- * stat() (see TolerantWebAccessFS.stat). A no-op unless this tab coordinates with others.
- */
-function queueFilesChangedNotice(paths) {
-    if (!isPostingTabMessages())
-        return;
-    for (const path of paths)
-        pendingChangedPaths.add(path);
-    if (flushTimer !== undefined || pendingChangedPaths.size === 0)
-        return;
-    flushTimer = setTimeout(flushFilesChangedNotices, FILES_CHANGED_FLUSH_MS);
-    if (!flushOnPageHide && typeof addEventListener === 'function') {
-        flushOnPageHide = true;
-        // A tab closing inside the window still sends what it wrote.
-        addEventListener('pagehide', flushFilesChangedNotices);
-    }
-}
-/** Sends the queued paths now (page hide, tests). */
-function flushFilesChangedNotices() {
-    if (flushTimer !== undefined)
-        clearTimeout(flushTimer);
-    flushTimer = undefined;
-    if (pendingChangedPaths.size === 0)
-        return;
-    const paths = [...pendingChangedPaths];
-    pendingChangedPaths = new Set();
-    for (let i = 0; i < paths.length; i += FILES_CHANGED_MAX_PATHS) {
-        postTabMessage({ type: 'files-changed', paths: paths.slice(i, i + FILES_CHANGED_MAX_PATHS) });
-    }
-}
-/** Refreshes this tab's in-memory state for an event another tab emitted, before re-emitting it. */
-async function catchUpOn(name, payload) {
-    if (name === EAS_SEED_DATA_SYNCED_TO_DB_EVENT) {
-        const _mod_0 = await import('./Item-0oDoTPhi.js');
-        const _ns_0 = _mod_0.au;
-        const { Item } = _ns_0;
-        await Item.rehydrateCachedItemsFromDbAfterEasSync();
-    }
-    else if (name === LOCAL_COPIES_REMOVED_EVENT) {
-        const { removedSeedLocalIds = [], removedSeedUids = [] } = (payload ?? {});
-        const _mod_1 = await import('./Item-0oDoTPhi.js');
-        const _ns_1 = _mod_1.au;
-        const { Item } = _ns_1;
-        Item.dropCachedInstancesForSeedIds([...removedSeedLocalIds, ...removedSeedUids]);
-    }
-}
-const RELAYED_EVENTS = new Set([
-    EAS_SEED_DATA_SYNCED_TO_DB_EVENT,
-    ADDRESSES_PERSISTED_EVENT,
-    LOCAL_COPIES_REMOVED_EVENT,
-]);
-let listening = false;
-/** Applies other tabs' events and file changes in this tab. */
-function listenForOtherTabsEvents() {
-    if (listening)
-        return;
-    listening = true;
-    onTabMessage((message) => {
-        if (message.type === 'event' && RELAYED_EVENTS.has(message.name)) {
-            void catchUpOn(message.name, message.payload)
-                .catch((error) => logger$1(`catching up on ${message.name} failed`, error))
-                .then(() => {
-                if (message.payload === undefined) {
-                    eventEmitter.emit(message.name);
-                }
-                else {
-                    eventEmitter.emit(message.name, message.payload);
-                }
-            });
-        }
-        else if (message.type === 'files-changed') {
-            // Only refreshes caches: never writes, so never sends files-changed back.
-            void BaseFileManager.invalidateCachedPaths(message.paths)
-                .catch((error) => logger$1('refreshing changed files failed', error))
-                .then(() => eventEmitter.emit(FILES_CHANGED_EVENT, message.paths));
-        }
-    });
-}
-
-var tabEvents = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    FILES_CHANGED_EVENT: FILES_CHANGED_EVENT,
-    FILES_CHANGED_FLUSH_MS: FILES_CHANGED_FLUSH_MS,
-    FILES_CHANGED_MAX_PATHS: FILES_CHANGED_MAX_PATHS,
-    emitAcrossTabs: emitAcrossTabs,
-    flushFilesChangedNotices: flushFilesChangedNotices,
-    listenForOtherTabsEvents: listenForOtherTabsEvents,
-    notifyFileSaved: notifyFileSaved,
-    notifyFilesWrittenOutsideCache: notifyFilesWrittenOutsideCache,
-    queueFilesChangedNotice: queueFilesChangedNotice
-});
-
-const logger = debug('seedSdk:browser:db:changeFeed');
-/** Log rows older than this are pruned by the leader tab. */
-const ENTITY_CHANGES_RETENTION_MS = 10 * 60000;
-/** The leader prunes at most this often. */
-const ENTITY_CHANGES_PRUNE_EVERY_MS = 60000;
-const byLocalId = new Map();
-const byUid = new Map();
-const registrations = new Set();
-let feed;
-let cursor = 0;
-let reading;
-let readAgain = false;
-let lastPrunedAt = 0;
-const addTo = (map, key, registration) => {
-    let set = map.get(key);
-    if (!set)
-        map.set(key, (set = new Set()));
-    set.add(registration);
-};
-const removeFrom = (map, key, registration) => {
-    const set = map.get(key);
-    if (!set)
-        return;
-    set.delete(registration);
-    if (set.size === 0)
-        map.delete(key);
-};
-/**
- * Calls `listener` after a committed write to one of `watch.tables` for the watched seed, matched
- * by local id or (case-insensitively) by uid. A read of the log that has several matching rows
- * calls it once. When the tab missed rows (its cursor is older than the oldest kept row), every
- * listener is called once. Returns the unregister function.
- */
-function watchEntityChanges(watch, listener) {
-    const registration = {
-        watch,
-        tables: new Set(watch.tables),
-        propertyNames: watch.propertyNames ? new Set(watch.propertyNames) : undefined,
-        listener,
-    };
-    const localId = watch.seedLocalId || undefined;
-    const uid = watch.seedUid ? watch.seedUid.toLowerCase() : undefined;
-    registrations.add(registration);
-    if (localId)
-        addTo(byLocalId, localId, registration);
-    if (uid)
-        addTo(byUid, uid, registration);
-    return () => {
-        registrations.delete(registration);
-        if (localId)
-            removeFrom(byLocalId, localId, registration);
-        if (uid)
-            removeFrom(byUid, uid, registration);
-    };
-}
-/**
- * Watches `watch` and runs `read` once per dispatch, handing its result to `onRows` when it differs
- * from the last one handed over. A read that finishes after a newer one started is dropped, so an
- * older result never replaces a newer one.
- *
- * Pass `since` (the `changeFeedCursor()` taken before the caller's own initial read) to run `read`
- * once right away when the feed moved on in between: a change dispatched before this watch was
- * registered would otherwise be missed. Pass `immediate` to run it once right away regardless, as
- * a liveQuery's first emission does.
- */
-function watchEntityRows(watch, read, onRows, options = {}) {
-    let latest = 0;
-    let closed = false;
-    let lastJson;
-    const run = () => {
-        const token = ++latest;
-        read().then((rows) => {
-            if (closed || token !== latest)
-                return;
-            // Like BaseDb.liveQuery's distinctUntilChanged: a write that left these rows as they were
-            // (this entity's own write, read back) doesn't reach the handler again.
-            const json = JSON.stringify(rows);
-            if (json === lastJson)
-                return;
-            lastJson = json;
-            onRows(rows);
-        }, (error) => {
-            if (closed || token !== latest)
-                return;
-            if (options.onError)
-                options.onError(error);
-            else
-                logger('entity read failed', error);
-        });
-    };
-    const unregister = watchEntityChanges(watch, run);
-    if (options.immediate || (options.since !== undefined && cursor > options.since))
-        run();
-    return {
-        unsubscribe: () => {
-            closed = true;
-            unregister();
-        },
-    };
-}
-/**
- * Runs an SQL-tag query once, the way BaseDb.liveQuery's query function is written
- * (`(sql) => sql\`SELECT ...\``), so an entity can keep its liveQuery's text for its feed reads.
- */
-async function queryEntityRows(query) {
-    if (!feed)
-        throw new Error('The change feed has not started');
-    return (await query(feed.sql));
-}
-/** Whether this tab's feed runs (a browser database is open); Node has none. */
-function isChangeFeedRunning() {
-    return feed !== undefined;
-}
-const callAll = (targets) => {
-    for (const registration of targets) {
-        try {
-            registration.listener();
-        }
-        catch (error) {
-            logger('listener threw', error);
-        }
-    }
-};
-const dispatch = (rows) => {
-    const targets = new Set();
-    for (const row of rows) {
-        const candidates = [
-            ...(row.seedLocalId ? byLocalId.get(row.seedLocalId) ?? [] : []),
-            ...(row.seedUid ? byUid.get(row.seedUid.toLowerCase()) ?? [] : []),
-        ];
-        for (const registration of candidates) {
-            if (!registration.tables.has(row.tbl))
-                continue;
-            if (row.tbl === 'metadata' &&
-                registration.propertyNames &&
-                row.propertyName != null &&
-                !registration.propertyNames.has(row.propertyName)) {
-                continue;
-            }
-            targets.add(registration);
-        }
-    }
-    callAll(targets);
-};
-const readNewRows = async (db) => {
-    const rows = await db
-        .select({
-        seq: entityChanges.seq,
-        tbl: entityChanges.tbl,
-        seedLocalId: entityChanges.seedLocalId,
-        seedUid: entityChanges.seedUid,
-        propertyName: entityChanges.propertyName,
-    })
-        .from(entityChanges)
-        .where(gt(entityChanges.seq, cursor))
-        .orderBy(entityChanges.seq);
-    if (feed?.db !== db || rows.length === 0)
-        return;
-    // Writers are serialized, so committed seqs have no holes: a missing first row was pruned.
-    const missed = rows[0].seq > cursor + 1;
-    cursor = rows[rows.length - 1].seq;
-    if (missed) {
-        logger(`cursor fell behind the log; notifying all ${registrations.size} watches`);
-        callAll([...registrations]);
-    }
-    else {
-        dispatch(rows);
-    }
-    await maybePrune(db);
-};
-const maybePrune = async (db) => {
-    const now = Date.now();
-    if (!isLeaderTab() || now - lastPrunedAt < ENTITY_CHANGES_PRUNE_EVERY_MS)
-        return;
-    lastPrunedAt = now;
-    try {
-        await pruneEntityChanges(db, now);
-    }
-    catch (error) {
-        logger('prune failed', error);
-    }
-};
-/** Deletes log rows older than ENTITY_CHANGES_RETENTION_MS. Deleting doesn't raise max(seq), so it dispatches nothing. */
-async function pruneEntityChanges(db, now = Date.now()) {
-    await db.delete(entityChanges).where(lt(entityChanges.at, now - ENTITY_CHANGES_RETENTION_MS));
-}
-/** Reads once at a time; an emission during a read makes it read once more. */
-const scheduleRead = (db) => {
-    if (reading) {
-        readAgain = true;
-        return;
-    }
-    reading = (async () => {
-        try {
-            do {
-                readAgain = false;
-                await readNewRows(db);
-            } while (readAgain && feed?.db === db);
-        }
-        catch (error) {
-            logger('read failed', error);
-        }
-        finally {
-            reading = undefined;
-        }
-    })();
-};
-/**
- * Starts this tab's feed on `db` (once its migrations ran), at the newest seq allocated so far:
- * entities do their own initial read. A second call replaces the first feed.
- */
-async function startChangeFeed(db, { liveQuery, sql: sqlTag }) {
-    stopChangeFeed();
-    // sqlite_sequence keeps the last seq even when pruning emptied the table.
-    const [row] = await db.all(sql `SELECT seq FROM sqlite_sequence WHERE name = 'entity_changes'`);
-    cursor = Number(row?.seq ?? 0);
-    const subscription = liveQuery((tag) => tag `SELECT max(seq) AS seq FROM entity_changes`).subscribe({
-        next: ([latest]) => {
-            if (latest?.seq != null && Number(latest.seq) > cursor)
-                scheduleRead(db);
-        },
-        error: (error) => logger('feed query failed', error),
-    });
-    feed = { db, sql: sqlTag, unsubscribe: () => subscription.unsubscribe() };
-    logger(`started at seq ${cursor}`);
-}
-function stopChangeFeed() {
-    feed?.unsubscribe();
-    feed = undefined;
-    readAgain = false;
-}
-
-export { ADDRESSES_PERSISTED_EVENT as A, revokeSessionObjectUrl as B, queryEntityRows as C, isSessionObjectUrl as D, timedDb as E, FILES_CHANGED_EVENT as F, tabEvents as G, LOCAL_COPIES_REMOVED_EVENT as L, TabLockTimeoutError as T, isLeaderTab as a, watchEntityRows as b, whenLeaderTab as c, withDbTabLock as d, emitAcrossTabs as e, createSessionObjectUrl as f, withSeedDbLock as g, countDbStatements as h, isChangeFeedRunning as i, countLiveQueryRuns as j, postTabMessage as k, listenForOtherTabsEvents as l, startTabCoordination as m, notifyFilesWrittenOutsideCache as n, onTabMessage as o, parseAddressesPersistedPayload as p, tryWithTabLock as q, notifyFileSaved as r, startChangeFeed as s, timingMarks as t, timingNow as u, timingSince as v, watchEntityChanges as w, timingLogger as x, TAB_ID as y, timed as z };
-//# sourceMappingURL=changeFeed-DKdVlUmt.js.map