@seedprotocol/sdk 0.7.10 → 0.7.11-next.1384.g8b47246

package/dist/tabEvents-BnBzIdEi.js

@@ -0,0 +1,1408 @@
+import { Type } from '@sinclair/typebox';
+import debug from 'debug';
+import { customAlphabet } from 'nanoid';
+import { alphanumeric } from 'nanoid-dictionary';
+import { w as BaseFileManager, g as entityChanges } from './BaseFileManager-DLou1TZS.js';
+import { sql, gt, lt } from 'drizzle-orm';
+import { VERSION_SCHEMA_UID } from '@seedprotocol/eas';
+import '@seedprotocol/arweave';
+
+// Define zero constants ourselves since they're not exported from eas-sdk in newer versions
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+const ZERO_BYTES = '0x';
+const ZERO_BYTES32 = '0x0000000000000000000000000000000000000000000000000000000000000000';
+const INTERNAL_DATA_TYPES = {
+    Text: {
+        eas: 'string',
+    },
+    // ADR 0010: decimal strings, so negatives, fractions and values above 255 publish.
+    Number: {
+        eas: 'string',
+    },
+    Image: {
+        eas: 'bytes32',
+    },
+    Relation: {
+        eas: 'bytes32',
+    },
+    List: {
+        eas: 'bytes32[]',
+    },
+    File: {
+        eas: 'bytes32',
+    },
+    Json: {
+        eas: 'bytes32',
+    },
+    Blob: {
+        eas: 'bytes32',
+    },
+    Boolean: {
+        eas: 'bool',
+    },
+    Date: {
+        eas: 'uint256',
+    },
+    Html: {
+        eas: 'bytes32',
+    },
+};
+/**
+ * Internal property names ending in `Id` that are names in their own right: never stripped to a
+ * base name, and never given an `Id` suffix in metadata.
+ */
+const PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP = new Set(['storageTransactionId', 'transactionId']);
+const INTERNAL_PROPERTY_NAMES = [
+    'localId',
+    'uid',
+    'seedLocalId',
+    'seedUid',
+    'schemaUid',
+    'attestationCreatedAt',
+    'attestationRaw',
+    'createdAt',
+    'updatedAt',
+    'lastVersionPublishedAt',
+    'latestVersionLocalId',
+    'latestVersionUid',
+    'lastLocalUpdateAt',
+    'modelName',
+    'refSeedType',
+    'refValueType',
+    'refResolvedValue',
+    'refResolvedDisplayValue',
+    'type',
+    // Image
+    'src',
+    'alt',
+    //
+    'versionLocalId',
+    'versionsCount',
+    'versionUid',
+    '_markedForDeletion',
+    // SDK-internal: wallet address of attester; never publish as property attestation
+    'publisher',
+    // SDK-internal: Unix timestamp when attestations were revoked; never a schema field
+    'revokedAt',
+];
+/** @deprecated The UID is chain-independent. Use {@link VERSION_SCHEMA_UID}. */
+const VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA = VERSION_SCHEMA_UID;
+const defaultAttestationData = {
+    recipient: ZERO_ADDRESS,
+    revocable: true,
+    value: BigInt(0),
+    refUID: ZERO_BYTES32,
+    expirationTime: BigInt(0),
+    data: ZERO_BYTES,
+};
+var ImageSize;
+(function (ImageSize) {
+    ImageSize[ImageSize["EXTRA_SMALL"] = 480] = "EXTRA_SMALL";
+    ImageSize[ImageSize["SMALL"] = 760] = "SMALL";
+    ImageSize[ImageSize["MEDIUM"] = 1024] = "MEDIUM";
+    ImageSize[ImageSize["LARGE"] = 1440] = "LARGE";
+    ImageSize[ImageSize["EXTRA_LARGE"] = 1920] = "EXTRA_LARGE";
+})(ImageSize || (ImageSize = {}));
+const CLIENT_NOT_INITIALIZED = 'ClientManager is not initialized. Please call init() first.';
+var SeedModels;
+(function (SeedModels) {
+    SeedModels["Seed"] = "Seed";
+    SeedModels["Metadata"] = "Metadata";
+    SeedModels["Version"] = "Version";
+})(SeedModels || (SeedModels = {}));
+// Internal SDK schema that should not be created in app's files directory
+const SEED_PROTOCOL_SCHEMA_NAME = 'Seed Protocol';
+const INTERNAL_SCHEMA_IDS = ['SEEDPROTOCOL'];
+/** Fired, in every tab, after `syncDbWithEas` persists EAS seeds, versions and metadata to SQLite. */
+const EAS_SEED_DATA_SYNCED_TO_DB_EVENT = 'easSeedDataSyncedToDb';
+/**
+ * Check if a schema is an internal SDK schema that should not be created in app files
+ */
+function isInternalSchema(schemaName, schemaId) {
+    return schemaName === SEED_PROTOCOL_SCHEMA_NAME ||
+        (schemaId !== undefined && INTERNAL_SCHEMA_IDS.includes(schemaId));
+}
+/**
+ * Model ids (schemaFileId) of the internal Seed Protocol storage models. Storage seeds are always
+ * these models, even if a user schema also defines a model named Image/File/Html.
+ */
+const INTERNAL_STORAGE_MODEL_FILE_IDS = {
+    image: 'SEEDPROTOCOL_IMAGE',
+    file: 'SEEDPROTOCOL_FILE',
+    html: 'SEEDPROTOCOL_HTML',
+};
+
+/** Default maximum length for Text properties when not explicitly set. Html holds arbitrary-length content and does not use this limit. */
+const DEFAULT_TEXT_MAX_LENGTH = 255;
+/**
+ * TypeBox schema for ValidationRules
+ */
+const TValidationRules = Type.Object({
+    pattern: Type.Optional(Type.String()),
+    minLength: Type.Optional(Type.Integer({ minimum: 0 })),
+    maxLength: Type.Optional(Type.Integer({ minimum: 1 })),
+    enum: Type.Optional(Type.Array(Type.Any())),
+    custom: Type.Optional(Type.String()),
+}, { additionalProperties: true });
+
+/**
+ * Enum for all property data types
+ */
+var ModelPropertyDataTypes;
+(function (ModelPropertyDataTypes) {
+    ModelPropertyDataTypes["Text"] = "Text";
+    ModelPropertyDataTypes["Number"] = "Number";
+    ModelPropertyDataTypes["List"] = "List";
+    ModelPropertyDataTypes["Relation"] = "Relation";
+    ModelPropertyDataTypes["Image"] = "Image";
+    ModelPropertyDataTypes["Json"] = "Json";
+    ModelPropertyDataTypes["File"] = "File";
+    ModelPropertyDataTypes["Boolean"] = "Boolean";
+    ModelPropertyDataTypes["Date"] = "Date";
+    ModelPropertyDataTypes["Html"] = "Html";
+})(ModelPropertyDataTypes || (ModelPropertyDataTypes = {}));
+/** Known data types in lowercase for normalization */
+const DATA_TYPE_LOWER_MAP = {
+    text: 'Text',
+    string: 'Text', // JSON Schema convention
+    number: 'Number',
+    list: 'List',
+    relation: 'Relation',
+    image: 'Image',
+    json: 'Json',
+    file: 'File',
+    boolean: 'Boolean',
+    date: 'Date',
+    html: 'Html',
+    blob: 'Blob',
+};
+/**
+ * Normalize dataType to canonical PascalCase form.
+ * Accepts lowercase (e.g. 'text') or mixed case and returns 'Text'.
+ * Use when ingesting dataType from JSON schema files.
+ */
+function normalizeDataType(value) {
+    if (!value || typeof value !== 'string')
+        return value ?? '';
+    const lower = value.toLowerCase().trim();
+    return DATA_TYPE_LOWER_MAP[lower] ?? value.charAt(0).toUpperCase() + value.slice(1).toLowerCase();
+}
+/**
+ * Case-insensitive dataType check. Use instead of `dataType === 'List'` so schemas
+ * (or existing DB rows) with lowercase types like "list" still match.
+ */
+function isDataType(value, expected) {
+    if (!value)
+        return false;
+    return normalizeDataType(value) === expected;
+}
+/**
+ * Normalize a property definition to the internal shape ItemProperty reads (`dataType`,
+ * `refValueType`, `ref`, `storageType`, ...). Accepts schema-file shape (`type`, `model`,
+ * `items`, `storage`) and any casing. Mirrors the conversion in imports/json createModelFromJson
+ * for the fallback paths that read schema-file properties directly.
+ */
+function normalizePropertyRecordSchema(def) {
+    if (!def || typeof def !== 'object')
+        return def;
+    const src = def;
+    const out = { ...src };
+    const rawType = src.dataType ?? src.type;
+    if (typeof rawType === 'string' && rawType)
+        out.dataType = normalizeDataType(rawType);
+    const ref = src.ref ?? src.refModelName ?? src.items?.model ?? src.model;
+    if (ref && !out.ref)
+        out.ref = ref;
+    if (ref && !out.refModelName)
+        out.refModelName = ref;
+    const rawRefValueType = src.refValueType ?? src.items?.type;
+    if (typeof rawRefValueType === 'string' && rawRefValueType) {
+        out.refValueType = normalizeDataType(rawRefValueType);
+    }
+    else if (out.dataType === ModelPropertyDataTypes.List && ref) {
+        out.refValueType = ModelPropertyDataTypes.Relation;
+    }
+    if (src.storage && typeof src.storage === 'object' && !out.storageType) {
+        out.storageType = src.storage.type === 'ItemStorage' ? 'ItemStorage' : 'PropertyStorage';
+        if (src.storage.path !== undefined && out.localStorageDir === undefined)
+            out.localStorageDir = src.storage.path;
+        if (src.storage.extension !== undefined && out.filenameSuffix === undefined)
+            out.filenameSuffix = src.storage.extension;
+    }
+    return out;
+}
+// String literals, not enum members: PropertyDataType must accept plain strings
+// such as `{ dataType: 'Text' }`. ModelPropertyDataTypes members still fit.
+const TPropertyDataType = Type.Union([
+    Type.Literal('Text'),
+    Type.Literal('Number'),
+    Type.Literal('List'),
+    Type.Literal('Relation'),
+    Type.Literal('Image'),
+    Type.Literal('Json'),
+    Type.Literal('File'),
+    Type.Literal('Boolean'),
+    Type.Literal('Date'),
+    Type.Literal('Html'),
+]);
+const TStorageType = Type.Union([
+    Type.Literal('ItemStorage'), // Looks for a storageTransactionId property on the item
+    Type.Literal('PropertyStorage'), // Looks for a storageTransactionId value on the property
+]);
+/** How publish handles `data:image/*` URIs inside Html storage. Only applies when `dataType === 'Html'`. */
+const THtmlEmbeddedDataUriPolicy = Type.Union([
+    Type.Literal('materialize'),
+    Type.Literal('preserve'),
+]);
+const TProperty = Type.Object({
+    id: Type.Optional(Type.String()), // schemaFileId (string) - public ID
+    _dbId: Type.Optional(Type.Number()), // Database integer ID - internal only
+    name: Type.Optional(Type.String()),
+    dataType: TPropertyDataType,
+    ref: Type.Optional(Type.String()),
+    // modelId: string (modelFileId) in code; number only for DB foreign keys when resolved
+    modelId: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+    modelName: Type.Optional(Type.String()),
+    refModelId: Type.Optional(Type.Number()),
+    refModelName: Type.Optional(Type.String()),
+    refValueType: Type.Optional(TPropertyDataType),
+    storageType: Type.Optional(TStorageType),
+    localStorageDir: Type.Optional(Type.String()),
+    filenameSuffix: Type.Optional(Type.String()),
+    validation: Type.Optional(TValidationRules),
+    required: Type.Optional(Type.Boolean()),
+    /** When set on an Html property: `materialize` uploads embedded images as Image seeds and rewrites src; `preserve` leaves data URIs. */
+    htmlEmbeddedDataUriPolicy: Type.Optional(THtmlEmbeddedDataUriPolicy),
+});
+const TPropertyConstructor = Type.Function([
+    Type.Optional(Type.Union([Type.String(), TStorageType, Type.Undefined()])),
+    Type.Optional(Type.Union([Type.String(), TPropertyDataType])),
+    Type.Optional(Type.Union([Type.String(), Type.Boolean()])),
+], TProperty);
+const TPropertyDefs = Type.Record(TPropertyDataType, TPropertyConstructor);
+function htmlPropertyFactory(opts) {
+    return {
+        dataType: ModelPropertyDataTypes.Html,
+        ...(opts?.htmlEmbeddedDataUriPolicy
+            ? { htmlEmbeddedDataUriPolicy: opts.htmlEmbeddedDataUriPolicy }
+            : {}),
+    };
+}
+const Property = {
+    Text: (storageType, localStorageDir, filenameSuffix) => ({
+        dataType: ModelPropertyDataTypes.Text,
+        storageType,
+        localStorageDir,
+        filenameSuffix,
+        TObject: Type.String(),
+    }),
+    Json: () => ({ dataType: ModelPropertyDataTypes.Json }),
+    File: () => ({ dataType: ModelPropertyDataTypes.File }),
+    Number: () => ({ dataType: ModelPropertyDataTypes.Number }),
+    /**
+     * Create a List property. refValueType is required; ref is required only for list of relations.
+     * @param refValueType - Element type: 'Text', 'Number', 'Relation', etc.
+     * @param ref - Model name when refValueType is 'Relation' (optional for primitives)
+     * @example List('Text') - list of strings
+     * @example List('Relation', 'Tag') - list of relations to Tag model
+     */
+    List: (refValueType, ref) => ({
+        dataType: ModelPropertyDataTypes.List,
+        ref,
+        refValueType,
+    }),
+    Relation: (ref, refValueType, required) => ({
+        dataType: ModelPropertyDataTypes.Relation,
+        ref,
+        refValueType,
+        required,
+    }),
+    Image: () => ({ dataType: ModelPropertyDataTypes.Image }),
+    Boolean: () => ({ dataType: ModelPropertyDataTypes.Boolean }),
+    Date: () => ({ dataType: ModelPropertyDataTypes.Date }),
+    Html: htmlPropertyFactory,
+    /** `Html` opts are not representable in `TPropertyConstructor`; keep runtime shape via double assert. */
+};
+
+/**
+ * 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)}`);
+        },
+    };
+}
+
+const randomId = customAlphabet(alphanumeric, 10);
+/**
+ * A 10-character local id. Never starts with "0x" (about 1 in 3,844 random ids would), so code that
+ * tells local ids from EAS uids by that prefix can't mistake one for the other.
+ */
+const generateId = () => {
+    let id = randomId();
+    while (id.startsWith('0x'))
+        id = randomId();
+    return id;
+};
+
+var generateId$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    generateId: generateId
+});
+
+const isNode = () => {
+    return (typeof process !== 'undefined' &&
+        process.versions != null &&
+        process.versions.node != null);
+};
+const isBrowser = () => {
+    return !isElectron() && typeof document !== 'undefined' && typeof window !== 'undefined';
+};
+const isElectron = () => {
+    return typeof process !== 'undefined' && process.versions != null && process.versions.electron != null;
+};
+/**
+ * Detects if code is running in an Electron renderer process.
+ *
+ * Uses multiple detection methods for robustness:
+ * 1. Checks process.type === 'renderer' (most reliable)
+ * 2. Falls back to checking if Electron is present and window/document exist
+ *
+ * @returns true if running in Electron renderer process, false otherwise
+ */
+const isElectronRenderer = () => {
+    // Method 1: Check process.type (most reliable - official Electron API)
+    if (typeof process !== 'undefined' &&
+        process.type === 'renderer') {
+        return true;
+    }
+    // Method 2: Fallback - Electron + browser-like environment
+    // Renderer processes have window/document, main process doesn't (in modern Electron)
+    if (isElectron() &&
+        typeof window !== 'undefined' &&
+        typeof document !== 'undefined') {
+        return true;
+    }
+    return false;
+};
+/**
+ * True where OPFS-backed Arweave file downloads should run: normal browsers and
+ * Electron renderer. {@link isBrowser} is false for every Electron build (including renderer).
+ */
+const supportsOpfsFileDownloads = () => {
+    return isBrowser() || isElectronRenderer();
+};
+
+/**
+ * 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$3 = 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 until stopTabCoordination; 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$3(`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();
+}
+/**
+ * Ends this tab's coordination (client.stop): hands leadership to another tab and closes the
+ * channel. The next startTabCoordination starts over, for whatever database init then opens.
+ * Keeps message handlers (modules register theirs once per page) and whenLeaderTab waiters, which
+ * resolve once this tab leads again.
+ */
+function stopTabCoordination() {
+    state?.releaseLeadership?.();
+    state?.channel?.close();
+    state = undefined;
+    leader = false;
+}
+
+const logger$2 = debug('seedSdk:helpers:localImageBlobUrl');
+/**
+ * A new blob: URL for `images/<txId>` in the files directory, or undefined when the file isn't
+ * there. Each call creates a URL; the caller owns it and revokes it with `URL.revokeObjectURL`
+ * once nothing displays it.
+ */
+const convertTxIdToImage = async (txId) => {
+    const imageFilePath = BaseFileManager.getFilesPath('images', txId);
+    const fileExists = await BaseFileManager.pathExists(imageFilePath);
+    if (!fileExists) {
+        logger$2(`${imageFilePath} does not exist`);
+        return;
+    }
+    const buffer = await BaseFileManager.readFileAsBuffer(imageFilePath);
+    // Convert Blob to ArrayBuffer if needed, or use Buffer directly
+    let arrayBuffer;
+    if (buffer instanceof Blob) {
+        arrayBuffer = await buffer.arrayBuffer();
+    }
+    else if (buffer instanceof ArrayBuffer) {
+        arrayBuffer = buffer;
+    }
+    else {
+        // Node.js Buffer
+        const sliced = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+        // Handle SharedArrayBuffer case by creating a new ArrayBuffer
+        if (sliced instanceof SharedArrayBuffer) {
+            const uint8Array = new Uint8Array(sliced);
+            arrayBuffer = uint8Array.buffer.slice(0);
+        }
+        else {
+            arrayBuffer = sliced;
+        }
+    }
+    return URL.createObjectURL(new Blob([new Uint8Array(arrayBuffer)]));
+};
+
+/**
+ * File extension <-> MIME type, shared by the upload side (`getPublishUploads.ts`, which sets the
+ * `Content-Type` tag) and the download worker (`browser/workers/filesDownload.ts`, which picks the
+ * extension of a file saved under `files/`). The worker runs from a string and cannot import this
+ * module, so {@link MIME_TO_EXTENSION} is injected into its source as JSON.
+ */
+/**
+ * Lowercase extension (no dot) to MIME type. Includes the odd extensions the SDK itself produces:
+ * `saveImage` names a file `<id>.<subtype>` (e.g. `.svg+xml`, `.x-icon`), so subtypes appear here too.
+ */
+const EXTENSION_TO_MIME = {
+    // images
+    png: 'image/png',
+    apng: 'image/apng',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    jfif: 'image/jpeg',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    avif: 'image/avif',
+    heic: 'image/heic',
+    heif: 'image/heif',
+    svg: 'image/svg+xml',
+    'svg+xml': 'image/svg+xml',
+    bmp: 'image/bmp',
+    ico: 'image/x-icon',
+    'x-icon': 'image/x-icon',
+    'vnd.microsoft.icon': 'image/x-icon',
+    tif: 'image/tiff',
+    tiff: 'image/tiff',
+    // text / documents
+    html: 'text/html',
+    htm: 'text/html',
+    xhtml: 'application/xhtml+xml',
+    json: 'application/json',
+    txt: 'text/plain',
+    plain: 'text/plain',
+    md: 'text/markdown',
+    markdown: 'text/markdown',
+    csv: 'text/csv',
+    tsv: 'text/tab-separated-values',
+    xml: 'application/xml',
+    css: 'text/css',
+    js: 'text/javascript',
+    mjs: 'text/javascript',
+    pdf: 'application/pdf',
+    rtf: 'application/rtf',
+    epub: 'application/epub+zip',
+    zip: 'application/zip',
+    gz: 'application/gzip',
+    doc: 'application/msword',
+    docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    xls: 'application/vnd.ms-excel',
+    xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    ppt: 'application/vnd.ms-powerpoint',
+    pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    odt: 'application/vnd.oasis.opendocument.text',
+    // audio
+    mp3: 'audio/mpeg',
+    mpeg: 'audio/mpeg',
+    wav: 'audio/wav',
+    ogg: 'audio/ogg',
+    oga: 'audio/ogg',
+    opus: 'audio/opus',
+    m4a: 'audio/mp4',
+    aac: 'audio/aac',
+    flac: 'audio/flac',
+    weba: 'audio/webm',
+    // video
+    mp4: 'video/mp4',
+    m4v: 'video/mp4',
+    webm: 'video/webm',
+    mov: 'video/quicktime',
+    quicktime: 'video/quicktime',
+    ogv: 'video/ogg',
+    mkv: 'video/x-matroska',
+    avi: 'video/x-msvideo',
+    // fonts
+    woff: 'font/woff',
+    woff2: 'font/woff2',
+    ttf: 'font/ttf',
+    otf: 'font/otf',
+};
+/**
+ * MIME type to the extension a downloaded file gets. One canonical extension per type (the
+ * first one listed here wins over {@link EXTENSION_TO_MIME}'s aliases), plus a few common
+ * non-canonical spellings a gateway may send.
+ */
+const MIME_TO_EXTENSION = (() => {
+    const preferred = {
+        'image/jpeg': 'jpg',
+        'image/svg+xml': 'svg',
+        'image/x-icon': 'ico',
+        'image/tiff': 'tiff',
+        'text/html': 'html',
+        'text/plain': 'txt',
+        'text/markdown': 'md',
+        'text/javascript': 'js',
+        'audio/mpeg': 'mp3',
+        'audio/ogg': 'ogg',
+        'audio/mp4': 'm4a',
+        'video/mp4': 'mp4',
+        'video/quicktime': 'mov',
+        'video/ogg': 'ogv',
+    };
+    const out = { ...preferred };
+    for (const [ext, mime] of Object.entries(EXTENSION_TO_MIME)) {
+        if (!(mime in out))
+            out[mime] = ext;
+    }
+    // Non-canonical names some servers use for the same formats.
+    Object.assign(out, {
+        'audio/mp3': 'mp3',
+        'audio/x-wav': 'wav',
+        'audio/wave': 'wav',
+        'audio/vnd.wave': 'wav',
+        'audio/x-m4a': 'm4a',
+        'audio/x-flac': 'flac',
+        'application/x-zip-compressed': 'zip',
+        'image/vnd.microsoft.icon': 'ico',
+    });
+    return out;
+})();
+/**
+ * Content types that say nothing about the content. A Blob carrying one of these is treated as
+ * untyped.
+ */
+const GENERIC_MIME_TYPES = [
+    '',
+    'application/octet-stream',
+    'binary/octet-stream',
+];
+/** Lowercase `type/subtype` without parameters; `undefined` when empty or generic. */
+const normalizeMimeType = (mimeType) => {
+    const t = (mimeType ?? '').split(';')[0].trim().toLowerCase();
+    if (!t || GENERIC_MIME_TYPES.includes(t) || !t.includes('/'))
+        return undefined;
+    return t;
+};
+/** MIME type for a path or file name by its extension, if it has a known one. */
+const getMimeTypeFromPath = (filePathOrName) => {
+    const name = filePathOrName.split('/').pop() ?? '';
+    const dot = name.lastIndexOf('.');
+    if (dot <= 0 || dot === name.length - 1)
+        return undefined;
+    return EXTENSION_TO_MIME[name.slice(dot + 1).toLowerCase()];
+};
+/** Extension (no dot) for a MIME type, if it has a well-known one. */
+const getExtensionForMimeType = (mimeType) => {
+    const t = normalizeMimeType(mimeType);
+    return t ? MIME_TO_EXTENSION[t] : undefined;
+};
+/**
+ * MIME type from the leading bytes, for formats with an unambiguous signature. Used when a local
+ * file has no (known) extension, e.g. a file seed named after its id. Self-contained: the download
+ * and resize workers get it as source text.
+ */
+const sniffMimeType = (bytes) => {
+    const at = (offset, ...sig) => bytes.length >= offset + sig.length && sig.every((b, i) => bytes[offset + i] === b);
+    const ascii = (offset, s) => at(offset, ...Array.from(s).map((c) => c.charCodeAt(0)));
+    if (at(0, 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a))
+        return 'image/png';
+    if (at(0, 0xff, 0xd8, 0xff))
+        return 'image/jpeg';
+    if (ascii(0, 'GIF87a') || ascii(0, 'GIF89a'))
+        return 'image/gif';
+    if (ascii(0, 'RIFF') && ascii(8, 'WEBP'))
+        return 'image/webp';
+    if (ascii(0, 'RIFF') && ascii(8, 'WAVE'))
+        return 'audio/wav';
+    if (ascii(0, 'RIFF') && ascii(8, 'AVI '))
+        return 'video/x-msvideo';
+    if (ascii(0, 'BM') && bytes.length > 14)
+        return 'image/bmp';
+    if (at(0, 0x49, 0x49, 0x2a, 0x00) || at(0, 0x4d, 0x4d, 0x00, 0x2a))
+        return 'image/tiff';
+    if (ascii(0, '%PDF-'))
+        return 'application/pdf';
+    if (ascii(0, 'OggS'))
+        return 'audio/ogg';
+    if (ascii(0, 'fLaC'))
+        return 'audio/flac';
+    if (ascii(0, 'ID3'))
+        return 'audio/mpeg';
+    if (at(0, 0x1a, 0x45, 0xdf, 0xa3))
+        return 'video/webm';
+    if (ascii(4, 'ftyp')) {
+        const brand = String.fromCharCode(...Array.from(bytes.slice(8, 12)));
+        if (brand === 'avif' || brand === 'avis')
+            return 'image/avif';
+        if (['heic', 'heix', 'heif', 'mif1', 'msf1'].includes(brand))
+            return 'image/heic';
+        if (brand === 'qt  ')
+            return 'video/quicktime';
+        if (brand === 'M4A ')
+            return 'audio/mp4';
+        return 'video/mp4';
+    }
+    if (at(0, 0x00, 0x00, 0x01, 0x00))
+        return 'image/x-icon';
+    return undefined;
+};
+/**
+ * Best MIME type for upload bytes: the source's own type (a Blob/File `type`) when it is specific,
+ * then the file name's extension, then the bytes' signature.
+ */
+const resolveUploadMimeType = (params) => normalizeMimeType(params.sourceType) ??
+    (params.fileName ? getMimeTypeFromPath(params.fileName) : undefined) ??
+    (params.bytes ? sniffMimeType(params.bytes) : undefined);
+
+class SeedEventEmitter {
+    constructor() {
+        this.listeners = new Map();
+    }
+    on(event, listener) {
+        const set = this.listeners.get(event) ?? new Set();
+        set.add(listener);
+        this.listeners.set(event, set);
+        return this;
+    }
+    addListener(event, listener) {
+        return this.on(event, listener);
+    }
+    once(event, listener) {
+        const wrapped = (...args) => {
+            this.off(event, wrapped);
+            listener(...args);
+        };
+        return this.on(event, wrapped);
+    }
+    off(event, listener) {
+        const set = this.listeners.get(event);
+        if (!set)
+            return this;
+        set.delete(listener);
+        if (set.size === 0)
+            this.listeners.delete(event);
+        return this;
+    }
+    removeListener(event, listener) {
+        return this.off(event, listener);
+    }
+    removeAllListeners(event) {
+        if (typeof event === 'undefined') {
+            this.listeners.clear();
+            return this;
+        }
+        this.listeners.delete(event);
+        return this;
+    }
+    /**
+     * Calls every listener. A listener that throws is logged and skipped: the others still
+     * run, and the error never reaches the SDK code that emitted the event (which may be
+     * midway through a save).
+     */
+    emit(event, ...args) {
+        const set = this.listeners.get(event);
+        if (!set || set.size === 0)
+            return false;
+        for (const listener of [...set]) {
+            try {
+                listener(...args);
+            }
+            catch (error) {
+                console.error(`[seed] listener for "${String(event)}" threw:`, error);
+            }
+        }
+        return true;
+    }
+}
+const eventEmitter = new SeedEventEmitter();
+
+const logger$1 = 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 `immediate` to also run it once right away.
+ */
+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;
+            // 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$1('entity read failed', error);
+        });
+    };
+    const unregister = watchEntityChanges(watch, run);
+    if (options.immediate)
+        run();
+    return {
+        unsubscribe: () => {
+            closed = true;
+            unregister();
+        },
+    };
+}
+/** 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$1('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$1(`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$1('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$1('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 }) {
+    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$1('feed query failed', error),
+    });
+    feed = { db, unsubscribe: () => subscription.unsubscribe() };
+    logger$1(`started at seq ${cursor}`);
+}
+function stopChangeFeed() {
+    feed?.unsubscribe();
+    feed = undefined;
+    readAgain = false;
+}
+
+/**
+ * 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 = 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 === LOCAL_COPIES_REMOVED_EVENT) {
+        const { removedSeedLocalIds = [], removedSeedUids = [] } = (payload ?? {});
+        const _mod_0 = await import('./Item-Ld1iPicQ.js');
+        const _ns_0 = _mod_0.bX;
+        const { Item } = _ns_0;
+        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(`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('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
+});
+
+export { stopChangeFeed as $, ADDRESSES_PERSISTED_EVENT as A, isChangeFeedRunning as B, isLeaderTab as C, DEFAULT_TEXT_MAX_LENGTH as D, EAS_SEED_DATA_SYNCED_TO_DB_EVENT as E, FILES_CHANGED_EVENT as F, parseAddressesPersistedPayload as G, watchEntityChanges as H, ImageSize as I, watchEntityRows as J, whenLeaderTab as K, LOCAL_COPIES_REMOVED_EVENT as L, ModelPropertyDataTypes as M, withDbTabLock as N, MIME_TO_EXTENSION as O, Property as P, sniffMimeType as Q, notifyFilesWrittenOutsideCache as R, SEED_PROTOCOL_SCHEMA_NAME as S, THtmlEmbeddedDataUriPolicy as T, createSessionObjectUrl as U, VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA as V, withSeedDbLock as W, countDbStatements as X, startChangeFeed as Y, ZERO_BYTES32 as Z, countLiveQueryRuns as _, TProperty as a, postTabMessage as a0, onTabMessage as a1, listenForOtherTabsEvents as a2, startTabCoordination as a3, tryWithTabLock as a4, notifyFileSaved as a5, CLIENT_NOT_INITIALIZED as a6, stopTabCoordination as a7, PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP as a8, TAB_ID as a9, normalizeMimeType as aa, timingMarks as ab, withTabLock as ac, revokeSessionObjectUrl as ad, timed as ae, isSessionObjectUrl as af, timingNow as ag, timingSince as ah, timingLogger as ai, timedDb as aj, generateId$1 as ak, tabEvents as al, TPropertyConstructor as b, TPropertyDataType as c, TPropertyDefs as d, TStorageType as e, TValidationRules as f, normalizePropertyRecordSchema as g, eventEmitter as h, isDataType as i, INTERNAL_SCHEMA_IDS as j, generateId as k, isInternalSchema as l, INTERNAL_DATA_TYPES as m, normalizeDataType as n, isBrowser as o, emitAcrossTabs as p, getExtensionForMimeType as q, INTERNAL_STORAGE_MODEL_FILE_IDS as r, supportsOpfsFileDownloads as s, resolveUploadMimeType as t, isNode as u, INTERNAL_PROPERTY_NAMES as v, defaultAttestationData as w, convertTxIdToImage as x, SeedModels as y, TabLockTimeoutError as z };
+//# sourceMappingURL=tabEvents-BnBzIdEi.js.map