@seedprotocol/sdk 0.7.9-next.1189.g5e63267 → 0.7.9

package/dist/tabEvents-CaVmngqr.js

@@ -0,0 +1,3804 @@
+import debug from 'debug';
+import { B as BaseDb, t as schemas, d as models, j as modelSchemas, v as versions, s as seeds, l as properties, p as pendingWrites, a as appState, w as BaseFileManager, m as metadata, g as entityChanges } from './BaseFileManager-BAlySv8w.js';
+import { eq, getTableColumns, and, inArray, isNotNull, desc, or, sql, gt, lt } from 'drizzle-orm';
+import { waitFor } from 'xstate';
+import { DEFAULT_NAME_MATCH_LEVEL, isNameMatchLevel, compareNameMatchTiers, VERSION_SCHEMA_UID, localNamesInBestMatchTier, easName, BaseQueryClient, BaseEasClient, GET_FILES_METADATA } from '@seedprotocol/eas';
+import { alias } from 'drizzle-orm/sqlite-core';
+import 'pluralize';
+import { Type } from '@sinclair/typebox';
+import { ensureReadGatewaySelected, getArweaveReadBaseUrls, BaseArweaveClient, getTransactionTagsByIds } from '@seedprotocol/arweave';
+import { customAlphabet } from 'nanoid';
+import { alphanumeric } from 'nanoid-dictionary';
+import { sha256 } from '@noble/hashes/sha256';
+import { sha3_256 } from '@noble/hashes/sha3';
+import { bytesToHex } from '@noble/hashes/utils';
+import { throttle } from 'lodash-es';
+
+var MachineIds;
+(function (MachineIds) {
+    MachineIds["CLIENT_MANAGER"] = "@seedSdk/clientManager";
+    MachineIds["EAS_SYNC_MANAGER"] = "@seedSdk/easSyncManager";
+    MachineIds["GLOBAL"] = "@seedSdk/global";
+    MachineIds["INTERNAL"] = "@seedSdk/internal";
+    MachineIds["EAS"] = "@seedSdk/eas";
+    MachineIds["ITEM"] = "@seedSdk/item";
+    MachineIds["ALL_ITEMS"] = "@seedSdk/allItems";
+    MachineIds["MODEL"] = "@seedSdk/model";
+    MachineIds["FILE_SYSTEM"] = "@seedSdk/fileSystem";
+})(MachineIds || (MachineIds = {}));
+var ClientManagerState;
+(function (ClientManagerState) {
+    ClientManagerState["UNINITIALIZED"] = "uninitialized";
+    ClientManagerState["PLATFORM_CLASSES_INIT"] = "platformClassesInit";
+    ClientManagerState["FILE_SYSTEM_INIT"] = "fileSystemInit";
+    ClientManagerState["DB_INIT"] = "dbInit";
+    ClientManagerState["SAVE_CONFIG"] = "saveConfig";
+    ClientManagerState["ADD_MODELS_TO_DB"] = "addModelsToDb";
+    ClientManagerState["PROCESS_SCHEMA_FILES"] = "processSchemaFiles";
+    ClientManagerState["IDLE"] = "idle";
+    ClientManagerState["INIT_FAILED"] = "initFailed";
+})(ClientManagerState || (ClientManagerState = {}));
+var ClientManagerEvents;
+(function (ClientManagerEvents) {
+    ClientManagerEvents["UPDATE_CONTEXT"] = "updateContext";
+    ClientManagerEvents["SAVE_APP_STATE_SUCCESS"] = "saveAppStateSuccess";
+    ClientManagerEvents["SAVE_APP_STATE_ERROR"] = "saveAppStateError";
+    ClientManagerEvents["SET_ADDRESSES"] = "setAddresses";
+})(ClientManagerEvents || (ClientManagerEvents = {}));
+
+// Set by ClientManager when it loads. Importing it here would pull in most of the SDK, and
+// readiness is read from inside that graph (entity loads, downloads).
+let getClientActor;
+/** @internal ClientManager registers the getter for its current actor (init after stop replaces it). */
+function registerClientActor(getter) {
+    getClientActor = getter;
+}
+// Client states in which the app database is open: dbInit finishes before saveConfig starts.
+const DB_OPEN_STATES = new Set([
+    ClientManagerState.SAVE_CONFIG,
+    ClientManagerState.PROCESS_SCHEMA_FILES,
+    ClientManagerState.ADD_MODELS_TO_DB,
+    ClientManagerState.IDLE,
+]);
+/** Whether a clientManager snapshot is a running client that finished init. */
+function isClientReadySnapshot(snapshot) {
+    return snapshot.status === 'active' && snapshot.value === ClientManagerState.IDLE;
+}
+/**
+ * Whether `client.init` finished and the app database is open. False before init, while it runs,
+ * and after `client.stop()`.
+ */
+function isClientReady() {
+    const actor = getClientActor?.();
+    return !!actor && isClientReadySnapshot(actor.getSnapshot()) && BaseDb.isAppDbReady();
+}
+/**
+ * The app database, once client init has opened it. Waits up to `timeoutMs` for init to get that
+ * far; returns undefined when it doesn't (no init, a failed or stopped client).
+ */
+async function whenDbReady(timeoutMs = 30000) {
+    if (BaseDb.isAppDbReady())
+        return BaseDb.getAppDb();
+    const actor = getClientActor?.();
+    if (!actor)
+        return undefined;
+    try {
+        await waitFor(actor, (snapshot) => DB_OPEN_STATES.has(snapshot.value), {
+            timeout: timeoutMs,
+        });
+    }
+    catch {
+        return undefined;
+    }
+    return BaseDb.isAppDbReady() ? BaseDb.getAppDb() : undefined;
+}
+
+let refresher;
+function setCachedPropertyRefresher(fn) {
+    refresher = fn;
+}
+/** Give cached ModelProperty instances of these properties their rows' current values. */
+async function refreshCachedProperties(propertyFileIds) {
+    if (!refresher || propertyFileIds.length === 0)
+        return;
+    await refresher(propertyFileIds);
+}
+
+const level = (value) => (isNameMatchLevel(value) ? value : undefined);
+const tighter = (a, b) => a === undefined || compareNameMatchTiers(b, a) < 0 ? b : a;
+/** The levels in one schema file for one of its models, or undefined when the file lacks the model. */
+const modelLevelsFromFile = (file, modelName) => {
+    const modelDef = file.models?.[modelName];
+    if (!modelDef)
+        return undefined;
+    const model = level(modelDef.nameMatch) ?? level(file.nameMatch) ?? DEFAULT_NAME_MATCH_LEVEL;
+    const properties = new Map();
+    for (const [propertyName, def] of Object.entries(modelDef.properties ?? {})) {
+        properties.set(propertyName, level(def?.nameMatch) ?? model);
+    }
+    return { model, properties };
+};
+/**
+ * Builds NameMatchLevels from the schema files that own each model row. Exported for tests;
+ * use {@link nameMatchLevels}.
+ */
+const nameMatchLevelsFromRows = (rows) => {
+    const byFileId = new Map();
+    const byName = new Map();
+    const parsed = new Map();
+    for (const row of rows) {
+        if (!row.schemaData)
+            continue;
+        if (!parsed.has(row.schemaData)) {
+            try {
+                parsed.set(row.schemaData, JSON.parse(row.schemaData));
+            }
+            catch {
+                parsed.set(row.schemaData, undefined);
+            }
+        }
+        const file = parsed.get(row.schemaData);
+        const levels = file && modelLevelsFromFile(file, row.modelName);
+        if (!levels)
+            continue;
+        if (row.modelFileId)
+            byFileId.set(row.modelFileId, levels);
+        const seen = byName.get(row.modelName);
+        if (!seen) {
+            byName.set(row.modelName, { model: levels.model, properties: new Map(levels.properties) });
+            continue;
+        }
+        seen.model = tighter(seen.model, levels.model);
+        for (const [name, value] of levels.properties)
+            seen.properties.set(name, tighter(seen.properties.get(name), value));
+    }
+    return {
+        model: (modelName) => byName.get(modelName)?.model ?? DEFAULT_NAME_MATCH_LEVEL,
+        property: (modelName, propertyName, modelFileId) => {
+            const levels = (modelFileId ? byFileId.get(modelFileId) : undefined) ?? byName.get(modelName);
+            return levels?.properties.get(propertyName) ?? levels?.model ?? DEFAULT_NAME_MATCH_LEVEL;
+        },
+    };
+};
+const DEFAULT_LEVELS = {
+    model: () => DEFAULT_NAME_MATCH_LEVEL,
+    property: () => DEFAULT_NAME_MATCH_LEVEL,
+};
+let current;
+let loading;
+/** Reads the levels from the schema files stored with each model's schema row (schemas.schema_data). */
+const loadNameMatchLevels = async (db = BaseDb.getAppDb()) => {
+    if (!db)
+        return DEFAULT_LEVELS;
+    const load = (async () => {
+        const rows = (await db
+            .select({ modelName: models.name, modelFileId: models.schemaFileId, schemaData: schemas.schemaData })
+            .from(models)
+            .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
+            .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id)));
+        return nameMatchLevelsFromRows(rows);
+    })();
+    loading = load;
+    try {
+        const levels = await load;
+        if (loading === load) {
+            current = levels;
+            previous = undefined;
+        }
+        return levels;
+    }
+    finally {
+        if (loading === load)
+            loading = undefined;
+    }
+};
+/** The levels, loaded once and reused until a schema write clears them. */
+const nameMatchLevels = async (db = BaseDb.getAppDb()) => current ?? loading ?? loadNameMatchLevels(db);
+/**
+ * The last loaded levels, for synchronous callers (Model.findByModelType). Init loads them before
+ * it reports ready. After a schema write clears them, this returns the levels from before the
+ * write until the reload that clear starts finishes.
+ */
+const currentNameMatchLevels = () => current ?? previous ?? DEFAULT_LEVELS;
+let previous;
+let reloadScheduled = false;
+/**
+ * Called when a schema row or its models are written. The next {@link nameMatchLevels} read
+ * reloads, and a reload starts on the next tick (one per burst of writes) for synchronous callers.
+ */
+const clearNameMatchLevels = () => {
+    if (current)
+        previous = current;
+    current = undefined;
+    loading = undefined;
+    if (reloadScheduled)
+        return;
+    reloadScheduled = true;
+    setTimeout(() => {
+        reloadScheduled = false;
+        if (current || loading || !BaseDb.isAppDbReady())
+            return;
+        loadNameMatchLevels().catch(() => {
+            // The next nameMatchLevels() read retries.
+        });
+    }, 0);
+};
+/**
+ * `nameMatch` values in a schema file that aren't a level. They are ignored (the next level up
+ * applies); schema loads warn about them.
+ */
+const invalidNameMatchValues = (file) => {
+    const problems = [];
+    const check = (where, value) => {
+        if (value !== undefined && !isNameMatchLevel(value)) {
+            problems.push(`${where} nameMatch ${JSON.stringify(value)} is not 'exact', 'normalized' or 'fuzzy'`);
+        }
+    };
+    check('schema', file.nameMatch);
+    for (const [modelName, modelDef] of Object.entries(file.models ?? {})) {
+        check(modelName, modelDef?.nameMatch);
+        for (const [propertyName, def] of Object.entries(modelDef?.properties ?? {})) {
+            check(`${modelName}.${propertyName}`, def?.nameMatch);
+        }
+    }
+    return problems;
+};
+/** Warns about {@link invalidNameMatchValues}. */
+const warnOnInvalidNameMatch = (file) => {
+    const problems = invalidNameMatchValues(file);
+    for (const problem of problems) {
+        console.warn(`[seed] schema ${file.metadata?.name ?? ''}: ${problem}; it is ignored.`);
+    }
+    return problems;
+};
+
+// 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',
+};
+
+/**
+ * SQLite builds before 3.32 (and builds that keep the old default) allow at most 999 bound
+ * parameters per statement (SQLITE_MAX_VARIABLE_NUMBER). sqlite-wasm and libsql allow 32766, but a
+ * statement that binds one parameter per synced item still has to stay under 999 to work everywhere.
+ */
+const SQLITE_DEFAULT_MAX_VARIABLE_NUMBER = 999;
+/**
+ * Values per `IN (...)` list. Leaves room under {@link SQLITE_DEFAULT_MAX_VARIABLE_NUMBER} for the
+ * statement's other parameters (a second list, `SET` values, other conditions).
+ */
+const IN_LIST_BATCH = 400;
+/**
+ * Rows per multi-row INSERT into `table` so the statement binds at most
+ * {@link SQLITE_DEFAULT_MAX_VARIABLE_NUMBER} parameters even with every column set.
+ */
+const rowsPerInsert = (table) => Math.max(1, Math.floor(SQLITE_DEFAULT_MAX_VARIABLE_NUMBER / Object.keys(getTableColumns(table)).length));
+/** Splits `values` into chunks of at most `size` (one empty list gives no chunks). */
+const chunkValues = (values, size = IN_LIST_BATCH) => {
+    if (!Number.isInteger(size) || size < 1) {
+        throw new Error(`chunkValues: size must be a positive integer, got ${size}`);
+    }
+    const chunks = [];
+    for (let i = 0; i < values.length; i += size) {
+        chunks.push(values.slice(i, i + size));
+    }
+    return chunks;
+};
+/**
+ * Runs `query` once per chunk of `values` (see {@link chunkValues}), one after another, and
+ * concatenates the rows. Use it for `inArray(column, values)` reads whose list can be large.
+ */
+const selectInBatches = async (values, query, size = IN_LIST_BATCH) => {
+    const rows = [];
+    for (const chunk of chunkValues(values, size)) {
+        rows.push(...(await query(chunk)));
+    }
+    return rows;
+};
+/** Runs `write` once per chunk of `values`, one after another (deletes / updates with an `IN` list). */
+const writeInBatches = async (values, write, size = IN_LIST_BATCH) => {
+    for (const chunk of chunkValues(values, size)) {
+        await write(chunk);
+    }
+};
+
+/**
+ * The local seed row for each seed attestation uid. A uid recorded on a seed's versions
+ * (`versions.seed_uid`) belongs to that seed: its current uid, or an old one from before it was
+ * unpublished and published again (the seed row then holds the new uid, the old version rows keep
+ * the old one). A uid no version records resolves by `seeds.uid`. Uids with no local seed are left
+ * out of the map.
+ *
+ * Going through versions first also resolves a republished seed's old uid to the item when an
+ * older sync left a second, version-less seed row with that uid (migration 0024 removes those).
+ */
+const findSeedRowsByUid = async (uids, 
+/** The database or transaction to read; the app database by default. */
+db = BaseDb.getAppDb()) => {
+    const result = new Map();
+    const appDb = db;
+    const wanted = [...new Set(uids.filter(Boolean))];
+    if (!appDb || wanted.length === 0)
+        return result;
+    const owners = await selectInBatches(wanted, (chunk) => appDb
+        .selectDistinct({ seedUid: versions.seedUid, seedLocalId: versions.seedLocalId })
+        .from(versions)
+        .where(and(inArray(versions.seedUid, chunk), isNotNull(versions.seedLocalId))));
+    const ownerLocalIds = [...new Set(owners.map((o) => o.seedLocalId))];
+    const ownerRows = await selectInBatches(ownerLocalIds, (chunk) => appDb.select().from(seeds).where(inArray(seeds.localId, chunk)));
+    const ownerByLocalId = new Map(ownerRows.map((row) => [row.localId, row]));
+    for (const { seedUid, seedLocalId } of owners) {
+        const row = ownerByLocalId.get(seedLocalId);
+        if (!seedUid || !row)
+            continue;
+        // Versions of two seeds recording one uid shouldn't happen; the seed that holds it wins.
+        const current = result.get(seedUid);
+        if (!current || (current.uid !== seedUid && row.uid === seedUid))
+            result.set(seedUid, row);
+    }
+    const rest = wanted.filter((uid) => !result.has(uid));
+    const byUid = await selectInBatches(rest, (chunk) => appDb.select().from(seeds).where(inArray(seeds.uid, chunk)));
+    for (const row of byUid) {
+        if (row.uid && !result.has(row.uid))
+            result.set(row.uid, row);
+    }
+    return result;
+};
+
+/**
+ * The local seed row for an item known by local id, seed uid or both. The local id wins: it names
+ * one row, while a uid can be an old one the seed held before it was unpublished and published
+ * again. A uid (when the local id is absent or matches nothing) resolves as
+ * {@link findSeedRowsByUid} resolves it: the seed whose versions record it (`versions.seed_uid`),
+ * else the row with that `seeds.uid`. The zero uid matches nothing.
+ */
+const findSeedRow = async ({ localId, uid }, 
+/** The database or transaction to read; the app database by default. */
+db = BaseDb.getAppDb()) => {
+    if (!db)
+        return undefined;
+    if (localId) {
+        const [row] = await db.select().from(seeds).where(eq(seeds.localId, localId)).limit(1);
+        if (row?.localId)
+            return row;
+    }
+    if (!uid || uid === ZERO_BYTES32)
+        return undefined;
+    const row = (await findSeedRowsByUid([uid], db)).get(uid);
+    return row?.localId ? row : undefined;
+};
+
+var findSeedRow$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    findSeedRow: findSeedRow
+});
+
+/**
+ * Thrown when a model name exists in more than one schema and nothing says which one is meant.
+ * Model names are only unique within a schema; pass `schemaName` (or `modelFileId`) to choose.
+ */
+class AmbiguousModelError extends Error {
+    constructor(modelName, schemaNames) {
+        const names = [...new Set(schemaNames)].sort();
+        super(`Model "${modelName}" exists in schemas ${names.map((n) => `"${n}"`).join(', ')}; ` +
+            `pass schemaName (or modelFileId) to choose one.`);
+        this.name = 'AmbiguousModelError';
+        this.modelName = modelName;
+        this.schemaNames = names;
+    }
+}
+
+const columns = {
+    id: models.id,
+    name: models.name,
+    schemaFileId: models.schemaFileId,
+};
+/**
+ * Resolve a models row from a model name plus whatever scope is known, most specific first:
+ * modelFileId, modelId, propertyFileId, then schemaId/schemaName + name, then the name alone (not
+ * with `strict` and a schema scope). The name alone is only accepted when it is unambiguous;
+ * otherwise this throws AmbiguousModelError.
+ */
+const resolveModelRecord = async (modelName, scope = {}, db = BaseDb.getAppDb()) => {
+    if (!db)
+        return undefined;
+    if (scope.modelFileId) {
+        const rows = await db
+            .select(columns)
+            .from(models)
+            .where(eq(models.schemaFileId, scope.modelFileId))
+            .limit(1);
+        if (rows.length > 0)
+            return rows[0];
+    }
+    if (scope.modelId) {
+        const rows = await db.select(columns).from(models).where(eq(models.id, scope.modelId)).limit(1);
+        if (rows.length > 0)
+            return rows[0];
+    }
+    if (scope.propertyFileId) {
+        const rows = await db
+            .select(columns)
+            .from(properties)
+            .innerJoin(models, eq(properties.modelId, models.id))
+            .where(eq(properties.schemaFileId, scope.propertyFileId))
+            .limit(1);
+        if (rows.length > 0)
+            return rows[0];
+    }
+    if (!modelName)
+        return undefined;
+    if (scope.schemaId || scope.schemaName) {
+        const rows = await db
+            .select(columns)
+            .from(models)
+            .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
+            .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
+            .where(and(eq(models.name, modelName), scope.schemaId ? eq(schemas.id, scope.schemaId) : eq(schemas.name, scope.schemaName)))
+            .limit(1);
+        if (rows.length > 0)
+            return rows[0];
+        if (scope.strict)
+            return undefined;
+    }
+    return resolveModelRecordByNameOnly(modelName, db);
+};
+/**
+ * Name of the schema a models row is linked to (the newest version's when several are), or
+ * undefined for an unlinked stub.
+ */
+const getModelSchemaName = async (modelId, db = BaseDb.getAppDb()) => {
+    if (!db)
+        return undefined;
+    const rows = await db
+        .select({ schemaName: schemas.name })
+        .from(modelSchemas)
+        .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
+        .where(eq(modelSchemas.modelId, modelId))
+        .orderBy(desc(schemas.version))
+        .limit(1);
+    return rows[0]?.schemaName ?? undefined;
+};
+/** The model a property row (by its schemaFileId) belongs to, and the property's data type. */
+const resolvePropertyModelRecord = async (propertyFileId, db = BaseDb.getAppDb()) => {
+    if (!db || !propertyFileId)
+        return undefined;
+    const rows = await db
+        .select({ ...columns, dataType: properties.dataType })
+        .from(properties)
+        .innerJoin(models, eq(properties.modelId, models.id))
+        .where(eq(properties.schemaFileId, propertyFileId))
+        .limit(1);
+    const row = rows[0];
+    return row ? { id: row.id, name: row.name, schemaFileId: row.schemaFileId, dataType: row.dataType ?? '' } : undefined;
+};
+/**
+ * Name-only resolution. Rows linked to a schema win over unlinked stubs (null-schemaFileId rows
+ * from ref resolution); if more than one linked row has the name it is ambiguous and this throws.
+ * `label` names the lookup in the error (defaults to the model name).
+ */
+const resolveModelRecordByNameOnly = async (modelName, db, label = Array.isArray(modelName) ? modelName.join(', ') : modelName) => {
+    const rows = (await db
+        .select({ ...columns, schemaName: schemas.name })
+        .from(models)
+        .leftJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
+        .leftJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
+        .where(Array.isArray(modelName) ? inArray(models.name, modelName) : eq(models.name, modelName))
+        .orderBy(desc(models.id)));
+    if (rows.length === 0)
+        return undefined;
+    const linked = rows.filter((r) => r.schemaName);
+    const linkedIds = new Set(linked.map((r) => r.id));
+    if (linkedIds.size > 1) {
+        throw new AmbiguousModelError(label, linked.map((r) => r.schemaName));
+    }
+    const chosen = linked[0] ?? rows[0];
+    return { id: chosen.id, name: chosen.name, schemaFileId: chosen.schemaFileId };
+};
+/**
+ * The model names a model name or EAS model type can refer to: the name itself, else the names
+ * that match it in the tightest tier (ADR 0008, as Model.findByModelType matches): `new_model` →
+ * "New model", `sync_storage_post` → "SyncStoragePost", `htmlpage` → "HTMLPage". Each name at its
+ * nameMatch level (ADR 0009).
+ */
+const modelNamesForNameOrType = async (nameOrType, db) => {
+    const rows = (await db.selectDistinct({ name: models.name }).from(models));
+    const names = rows.map((r) => r.name);
+    if (names.includes(nameOrType))
+        return [nameOrType];
+    const levels = await nameMatchLevels(db);
+    return [...localNamesInBestMatchTier(nameOrType, names, { level: (name) => levels.model(name) })];
+};
+/**
+ * resolveModelRecord for a model name **or** an EAS model type (snake_case model name, what sync
+ * stores in seeds.type): "New model" resolves from `new_model`. Scope and ambiguity behave as in
+ * resolveModelRecord: modelFileId/modelId first, then the schema, then the name(s) alone, which throws
+ * AmbiguousModelError when models in several schemas match.
+ */
+const resolveModelRecordByNameOrType = async (nameOrType, scope = {}, db = BaseDb.getAppDb()) => {
+    if (!db)
+        return undefined;
+    if (scope.modelFileId || scope.modelId || scope.propertyFileId) {
+        const byId = await resolveModelRecord(undefined, scope, db);
+        if (byId)
+            return byId;
+    }
+    if (!nameOrType)
+        return undefined;
+    const names = await modelNamesForNameOrType(nameOrType, db);
+    if (names.length === 0)
+        return undefined;
+    if (names.length === 1) {
+        return resolveModelRecord(names[0], { ...scope, modelFileId: undefined, modelId: undefined, propertyFileId: undefined }, db);
+    }
+    // Several model names map to this type (e.g. "New model" and "NewModel" in different schemas).
+    if (scope.schemaId || scope.schemaName) {
+        const rows = (await db
+            .select(columns)
+            .from(models)
+            .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
+            .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
+            .where(and(inArray(models.name, names), scope.schemaId ? eq(schemas.id, scope.schemaId) : eq(schemas.name, scope.schemaName))));
+        if (new Set(rows.map((r) => r.id)).size === 1)
+            return rows[0];
+        if (scope.strict && rows.length === 0)
+            return undefined;
+    }
+    return resolveModelRecordByNameOnly(names, db, nameOrType);
+};
+/**
+ * The model name that a model name or EAS model type (`seeds.type`, `metadata.model_type`) refers
+ * to, resolved as {@link resolveModelRecordByNameOrType} resolves it: `blog_post` → "Blog Post"
+ * through the model's easName at its nameMatch level, never by re-casing the type. Undefined when
+ * no model matches; throws AmbiguousModelError when models in several schemas do.
+ */
+const modelNameForType = async (nameOrType, scope = {}, db = BaseDb.getAppDb()) => (await resolveModelRecordByNameOrType(nameOrType, scope, db))?.name;
+/**
+ * Work out which model (schemaFileId) an item belongs to from whatever is at hand: an explicit
+ * modelFileId, the seed's model_file_id, or a metadata row's property_id → properties.model_id.
+ */
+const resolveItemModelFileId = async (hints, db = BaseDb.getAppDb()) => {
+    if (hints.modelFileId)
+        return hints.modelFileId;
+    if (!db)
+        return undefined;
+    if (hints.seedLocalId || hints.seedUid) {
+        const seed = await findSeedRow({ localId: hints.seedLocalId, uid: hints.seedUid }, db);
+        if (seed?.modelFileId)
+            return seed.modelFileId;
+    }
+    if (hints.propertyId) {
+        const rows = await db
+            .select({ modelFileId: models.schemaFileId })
+            .from(properties)
+            .innerJoin(models, eq(properties.modelId, models.id))
+            .where(eq(properties.id, hints.propertyId))
+            .limit(1);
+        if (rows[0]?.modelFileId)
+            return rows[0].modelFileId;
+    }
+    return undefined;
+};
+/** ModelScope for an Item (or ItemProperty) instance: its recorded modelFileId (context or seed row) and schemaName. */
+const getItemModelScope = async (item) => {
+    let context;
+    try {
+        context = item.getService?.().getSnapshot().context;
+    }
+    catch {
+        context = undefined;
+    }
+    const modelFileId = await resolveItemModelFileId({
+        modelFileId: context?.modelFileId,
+        seedLocalId: item.seedLocalId ?? context?.seedLocalId,
+        seedUid: item.seedUid ?? context?.seedUid,
+        propertyId: context?.propertyId,
+    });
+    return { modelFileId, schemaName: context?.schemaName };
+};
+/**
+ * Resolve a ref (e.g. a Relation's target model) by name from the schema(s) its owning model belongs
+ * to, so "Tag" means the owner schema's Tag rather than any Tag. Falls back to resolveModelRecord.
+ */
+const resolveRefModelRecord = async (refModelName, owner, db = BaseDb.getAppDb()) => {
+    if (!db || !refModelName)
+        return undefined;
+    const ownerRow = owner.modelFileId || owner.modelId ? await resolveModelRecord(undefined, owner, db) : undefined;
+    const schemaFilter = ownerRow
+        ? inArray(modelSchemas.schemaId, 
+        // any schema the owner is linked to
+        db.select({ schemaId: modelSchemas.schemaId }).from(modelSchemas).where(eq(modelSchemas.modelId, ownerRow.id)))
+        : owner.schemaId
+            ? eq(modelSchemas.schemaId, owner.schemaId)
+            : owner.schemaName
+                ? eq(schemas.name, owner.schemaName)
+                : undefined;
+    if (schemaFilter) {
+        const rows = await db
+            .select(columns)
+            .from(models)
+            .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
+            .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
+            .where(and(eq(models.name, refModelName), schemaFilter))
+            .limit(1);
+        if (rows.length > 0)
+            return rows[0];
+    }
+    return resolveModelRecord(refModelName, {}, db);
+};
+
+var resolveModelRecord$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getItemModelScope: getItemModelScope,
+    getModelSchemaName: getModelSchemaName,
+    modelNameForType: modelNameForType,
+    resolveItemModelFileId: resolveItemModelFileId,
+    resolveModelRecord: resolveModelRecord,
+    resolveModelRecordByNameOrType: resolveModelRecordByNameOrType,
+    resolvePropertyModelRecord: resolvePropertyModelRecord,
+    resolveRefModelRecord: resolveRefModelRecord
+});
+
+/**
+ * Lowercase + trim an address for persist and compare.
+ * Does not checksum or validate — test and placeholder addresses must keep working.
+ */
+function normalizeHexAddress(addr) {
+    return addr.trim().toLowerCase();
+}
+/**
+ * Lowercase, drop empties, and dedupe (first-seen order).
+ */
+function normalizeAddressList(addrs) {
+    if (!addrs?.length)
+        return [];
+    const seen = new Set();
+    const out = [];
+    for (const addr of addrs) {
+        if (addr == null || addr === '')
+            continue;
+        const normalized = normalizeHexAddress(String(addr));
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out;
+}
+/**
+ * Lowercase a publisher stamp. Empty / null → undefined (omit on write).
+ */
+function normalizePublisher(publisher) {
+    if (publisher == null || publisher === '')
+        return undefined;
+    const normalized = normalizeHexAddress(publisher);
+    return normalized || undefined;
+}
+/**
+ * Normalizes AddressConfiguration to { owned, watched }.
+ * - string[] -> { owned: addresses, watched: [] }
+ * - { owned, watched? } -> { owned, watched: watched ?? [] }
+ * Addresses are lowercased and deduped.
+ */
+function normalizeAddressConfig(addresses) {
+    if (!addresses) {
+        return { owned: [], watched: [] };
+    }
+    if (Array.isArray(addresses)) {
+        return { owned: normalizeAddressList(addresses), watched: [] };
+    }
+    return {
+        owned: normalizeAddressList(addresses.owned),
+        watched: normalizeAddressList(addresses.watched),
+    };
+}
+
+/** 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. */
+};
+
+/** Schema file spellings that normalizePropertyRecordSchema maps to internal fields. */
+const FILE_ALIAS_KEYS = ['type', 'model', 'items', 'storage'];
+/**
+ * Fields an instance or a row carries that aren't part of the definition. Keys starting with `_`
+ * (`_dbId`, `_propertyFileId`, `_originalValues`, ...) are dropped too.
+ */
+const NON_DEFINITION_KEYS = new Set([
+    ...FILE_ALIAS_KEYS,
+    'name',
+    'modelId',
+    'modelName',
+    'refModelId',
+    'refModelName',
+    'schemaName',
+    'isEdited',
+    'TObject',
+]);
+const parseDefinition = (json) => {
+    if (!json)
+        return {};
+    try {
+        const parsed = JSON.parse(json);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+};
+/** A definition in any accepted shape, reduced to what the column stores. */
+const toStoredDefinition = (def) => {
+    const normalized = normalizePropertyRecordSchema(def ?? {});
+    const hasRef = normalized.dataType === ModelPropertyDataTypes.Relation || normalized.dataType === ModelPropertyDataTypes.List;
+    const out = {};
+    for (const [key, value] of Object.entries(normalized)) {
+        if (value === undefined || typeof value === 'function')
+            continue;
+        if (key.startsWith('_') || NON_DEFINITION_KEYS.has(key))
+            continue;
+        if (key === 'ref' && !hasRef)
+            continue;
+        out[key] = value;
+    }
+    return out;
+};
+/**
+ * The `definition` column value for a definition in any accepted shape (schema file property,
+ * Model.create property, ModelProperty context). With `previous` (the row's current value), fields
+ * the new definition doesn't have are kept: a write that only knows the columns (a creation
+ * payload, a row-built instance) must not drop the validation a schema file or code stored.
+ */
+function propertyDefinitionColumn(def, previous) {
+    const stored = toStoredDefinition(def);
+    return JSON.stringify(previous ? { ...toStoredDefinition(parseDefinition(previous)), ...stored } : stored);
+}
+/**
+ * A row as a {@link PropertyDefinition}. `refModelName` is the name of the row's `ref_model_id`
+ * model; without one, a Relation or List keeps the definition's `ref` (a target not stored yet).
+ */
+function propertyDefinitionFromRow(row, refModelName) {
+    const stored = toStoredDefinition(parseDefinition(row.definition));
+    const dataType = normalizeDataType(row.dataType);
+    const hasRef = dataType === ModelPropertyDataTypes.Relation || dataType === ModelPropertyDataTypes.List;
+    const ref = refModelName ?? (hasRef ? stored.ref : undefined);
+    const def = {
+        ...stored,
+        id: row.schemaFileId ?? undefined,
+        _dbId: row.id,
+        name: row.name,
+        modelId: row.modelId,
+        dataType,
+        ref,
+        refModelName: ref,
+        refModelId: row.refModelId ?? undefined,
+        refValueType: row.refValueType ? normalizeDataType(row.refValueType) : undefined,
+        storageType: row.storageType ?? undefined,
+        localStorageDir: row.localStorageDir ?? undefined,
+        filenameSuffix: row.filenameSuffix ?? undefined,
+        required: row.required ?? stored.required ?? undefined,
+    };
+    for (const key of Object.keys(def))
+        if (def[key] === undefined)
+            delete def[key];
+    return def;
+}
+const refModels = alias(models, 'ref_model');
+const selectDefinitionRows = (db) => db
+    .select({ property: properties, refModelName: refModels.name })
+    .from(properties)
+    .leftJoin(refModels, eq(refModels.id, properties.refModelId));
+/**
+ * The complete definition of one property, from its row: by row id (`metadata.property_id`), or by
+ * model row id and property name. Undefined when there's no such row.
+ */
+async function getPropertyDefinition(target, db = BaseDb.getAppDb()) {
+    if (!db)
+        throw new Error('Database not available');
+    const where = typeof target === 'number'
+        ? eq(properties.id, target)
+        : and(eq(properties.modelId, target.modelId), eq(properties.name, target.name));
+    const [row] = await selectDefinitionRows(db).where(where).limit(1);
+    return row ? propertyDefinitionFromRow(row.property, row.refModelName) : undefined;
+}
+/** {@link getPropertyDefinition} for every property of one model, by property name, in one read. */
+async function getPropertyDefinitions(modelId, db = BaseDb.getAppDb()) {
+    if (!db)
+        throw new Error('Database not available');
+    const rows = await selectDefinitionRows(db).where(eq(properties.modelId, modelId));
+    return new Map(rows.map((row) => [
+        row.property.name,
+        propertyDefinitionFromRow(row.property, row.refModelName),
+    ]));
+}
+/** Fields only a definition holds (no column), which code-defined properties can set. */
+const DEFINITION_ONLY_FIELDS = ['validation', 'htmlEmbeddedDataUriPolicy', 'description'];
+/** The {@link DEFINITION_ONLY_FIELDS} a definition sets. */
+const definitionOnlyFields = (def) => Object.fromEntries(DEFINITION_ONLY_FIELDS.filter((key) => def?.[key] !== undefined).map((key) => [key, def[key]]));
+/**
+ * Stores code-defined fields ({@link definitionOnlyFields}) in the row's definition, when the row
+ * exists and its definition differs. For properties whose row was written before the code that
+ * defines them ran (a schema file's row, an earlier run), so their rules persist at create time.
+ */
+async function persistDefinitionFields(where, fields, db = BaseDb.getAppDb()) {
+    if (!db || Object.keys(fields).length === 0)
+        return;
+    const condition = 'id' in where ? eq(properties.id, where.id) : eq(properties.schemaFileId, where.schemaFileId);
+    const [row] = await db.select({ id: properties.id, definition: properties.definition }).from(properties).where(condition).limit(1);
+    if (!row)
+        return;
+    const next = propertyDefinitionColumn(fields, row.definition);
+    if (row.definition && JSON.stringify(toStoredDefinition(parseDefinition(row.definition))) === next)
+        return;
+    await db.update(properties).set({ definition: next }).where(eq(properties.id, row.id));
+}
+
+var propertyDefinition = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    DEFINITION_ONLY_FIELDS: DEFINITION_ONLY_FIELDS,
+    definitionOnlyFields: definitionOnlyFields,
+    getPropertyDefinition: getPropertyDefinition,
+    getPropertyDefinitions: getPropertyDefinitions,
+    persistDefinitionFields: persistDefinitionFields,
+    propertyDefinitionColumn: propertyDefinitionColumn,
+    propertyDefinitionFromRow: propertyDefinitionFromRow
+});
+
+/**
+ * The writers of definition rows: `schemas`, `models`, `properties` and `model_schemas` (SDK audit
+ * T9). One upsert per table. Every function takes the database to write, normally a transaction
+ * from {@link inDefinitionsTransaction}, and reads only through it: in the browser a query on
+ * `BaseDb.getAppDb()` waits for an open transaction to end.
+ *
+ * The lookups here decide which row a definition is (a schema by file id, then by name; a model by
+ * file id, then an adoptable row of that name; a property by file id, then by name in its model).
+ * The unique keys (`schema_file_id` on all three tables, `properties(name, model_id)`,
+ * `model_schemas(model_id, schema_id)`) are enforced by the database, and inserts resolve a
+ * conflict with ON CONFLICT instead of a second lookup.
+ */
+const logger$7 = debug('seedSdk:db:write:definitions');
+/**
+ * Runs one user action on definitions (an apply, a save, a rename) in one transaction. `fn` must
+ * write through `tx` only and have no other side effects: it is retried whole when another tab
+ * holds the database.
+ */
+const inDefinitionsTransaction = (fn) => BaseDb.transaction(fn);
+// ---------------------------------------------------------------------------------------------
+// model_schemas
+/** Links a model to a schema. Returns true when this call inserted the link. */
+async function linkModelToSchemaRow(db, modelId, schemaId) {
+    const inserted = await db
+        .insert(modelSchemas)
+        .values({ modelId, schemaId })
+        .onConflictDoNothing()
+        .returning({ id: modelSchemas.id });
+    return inserted.length > 0;
+}
+/**
+ * Writes a schema row and returns it with `inserted` set when it is new.
+ *
+ * The row is the one with `schemaFileId`, else one of that name: a draft write takes a draft of
+ * that name; a published write takes a published row, else a draft (which it publishes). A
+ * published row keeps its schemaFileId against another id of the same version, and keeps its newer
+ * version against an older version's file. With `rowId` that row is written, found by the caller
+ * (a rename finds it by the old name), and takes `schemaFileId`.
+ */
+async function upsertSchemaRow(db, input, options = {}) {
+    // The stored schema file may change its nameMatch levels (ADR 0009).
+    clearNameMatchLevels();
+    const { schemaFileId, schemaData, isDraft, isEdited, contentHash } = input;
+    const update = async (existing, updates) => {
+        if (input.name && existing.name !== input.name)
+            updates.name = input.name;
+        if (schemaData !== undefined)
+            updates.schemaData = schemaData;
+        if (contentHash !== undefined && existing.contentHash !== contentHash)
+            updates.contentHash = contentHash;
+        if (input.version !== undefined && existing.version !== input.version)
+            updates.version = input.version;
+        if (isDraft !== undefined && existing.isDraft !== isDraft)
+            updates.isDraft = isDraft;
+        if (isEdited !== undefined && existing.isEdited !== isEdited)
+            updates.isEdited = isEdited;
+        if (input.updatedAt && existing.updatedAt !== input.updatedAt)
+            updates.updatedAt = input.updatedAt;
+        if (Object.keys(updates).length > 0) {
+            await db.update(schemas).set(updates).where(eq(schemas.id, existing.id));
+        }
+        return { ...existing, ...updates, inserted: false };
+    };
+    if (options.rowId !== undefined) {
+        const [row] = await db.select().from(schemas).where(eq(schemas.id, options.rowId)).limit(1);
+        if (!row)
+            throw new Error(`Schema row ${options.rowId} not found`);
+        return update(row, schemaFileId && row.schemaFileId !== schemaFileId ? { schemaFileId } : {});
+    }
+    if (schemaFileId) {
+        const [byFileId] = await db.select().from(schemas).where(eq(schemas.schemaFileId, schemaFileId)).limit(1);
+        if (byFileId)
+            return update(byFileId, {});
+    }
+    if (isDraft === true) {
+        const [byName] = await db.select().from(schemas).where(eq(schemas.name, input.name)).limit(1);
+        if (byName?.isDraft === true) {
+            const updates = { updatedAt: input.updatedAt || Date.now() };
+            if (schemaFileId && byName.schemaFileId !== schemaFileId)
+                updates.schemaFileId = schemaFileId;
+            return update(byName, updates);
+        }
+    }
+    // By name: a published write prefers a published row, then takes a draft of that name.
+    let [existing] = await db
+        .select()
+        .from(schemas)
+        .where(isDraft === false ? and(eq(schemas.name, input.name), eq(schemas.isDraft, false)) : eq(schemas.name, input.name))
+        .limit(1);
+    if (!existing && isDraft === false) {
+        [existing] = await db
+            .select()
+            .from(schemas)
+            .where(and(eq(schemas.name, input.name), eq(schemas.isDraft, true)))
+            .limit(1);
+    }
+    if (existing) {
+        // A complete schema file can bring a version under its own id (imported files may not keep it).
+        const isOtherVersionFile = !!schemaFileId &&
+            !!existing.schemaFileId &&
+            existing.schemaFileId !== schemaFileId &&
+            existing.isDraft !== true &&
+            input.version !== undefined &&
+            input.version !== existing.version;
+        if (isOtherVersionFile && input.version < existing.version) {
+            // An older version's file: rolling the row back to it would leave the newer version's id
+            // pointing at the older version's data.
+            logger$7(`Keeping schema "${input.name}" at v${existing.version}; not replacing it with older v${input.version}`);
+            return { ...existing, inserted: false };
+        }
+        const updates = {};
+        // A published row keeps its id unless this is a newer version's file; a draft or id-less row
+        // takes the new one.
+        if (schemaFileId &&
+            existing.schemaFileId !== schemaFileId &&
+            (existing.isDraft === true || !existing.schemaFileId || isOtherVersionFile)) {
+            updates.schemaFileId = schemaFileId;
+        }
+        return update(existing, updates);
+    }
+    const [row] = await db
+        .insert(schemas)
+        .values({
+        name: input.name,
+        version: input.version,
+        schemaFileId: schemaFileId || null,
+        schemaData: schemaData || null,
+        contentHash: contentHash ?? null,
+        isDraft: isDraft ?? false,
+        isEdited: isEdited ?? false,
+        createdAt: input.createdAt,
+        updatedAt: input.updatedAt,
+    })
+        .returning();
+    return { ...row, inserted: true };
+}
+// ---------------------------------------------------------------------------------------------
+// models
+/**
+ * Writes the models row with `schemaFileId`, or inserts a name-only row without one. An existing
+ * row takes `name`; `isEdited` is set on insert only.
+ */
+async function upsertModelRow(db, input) {
+    const values = { name: input.name, schemaFileId: input.schemaFileId || null, isEdited: input.isEdited ?? false };
+    if (!values.schemaFileId) {
+        const [row] = await db.insert(models).values(values).returning();
+        return row;
+    }
+    const [row] = await db
+        .insert(models)
+        .values(values)
+        .onConflictDoUpdate({ target: models.schemaFileId, set: { name: input.name } })
+        .returning();
+    return row;
+}
+/** Name-only models rows for the names that have none yet. Returns every row of those names. */
+async function insertModelStubs(db, modelNames) {
+    const columns = { id: models.id, name: models.name, schemaFileId: models.schemaFileId };
+    const rows = modelNames.length
+        ? await db.select(columns).from(models).where(inArray(models.name, modelNames))
+        : [];
+    const missing = [...new Set(modelNames)].filter((name) => !rows.some((row) => row.name === name));
+    if (missing.length > 0) {
+        rows.push(...(await db.insert(models).values(missing.map((name) => ({ name }))).returning(columns)));
+    }
+    return rows;
+}
+const isLinkedTo = async (db, modelId, schemaId) => {
+    const links = await db
+        .select({ schemaId: modelSchemas.schemaId })
+        .from(modelSchemas)
+        .where(eq(modelSchemas.modelId, modelId));
+    return {
+        any: links.length > 0,
+        other: links.some((link) => link.schemaId !== schemaId),
+    };
+};
+/**
+ * Finds or creates the models row for `modelName` in a schema, by `modelFileId` (preferred) or
+ * name. Model names are only unique per schema, so a same-name row is reused only when no other
+ * schema claims it: a null-schemaFileId stub (from ref resolution or init), or for a ref without a
+ * file id, this schema's row. A row with a file id that no schema links is a deleted schema's
+ * leftover and is not adopted. An adopted row takes `modelFileId`.
+ */
+async function findOrCreateModelRow(db, modelName, modelFileId, schemaId) {
+    if (modelFileId) {
+        const [byFileId] = await db.select().from(models).where(eq(models.schemaFileId, modelFileId)).limit(1);
+        if (byFileId) {
+            if (byFileId.name === modelName)
+                return byFileId;
+            await db.update(models).set({ name: modelName }).where(eq(models.id, byFileId.id));
+            return { ...byFileId, name: modelName };
+        }
+    }
+    const byName = await db.select().from(models).where(eq(models.name, modelName));
+    let chosen;
+    if (byName.length > 0) {
+        if (!modelFileId && schemaId && byName.length > 1) {
+            for (const candidate of byName) {
+                const links = await isLinkedTo(db, candidate.id, schemaId);
+                if (links.any && !links.other) {
+                    chosen = candidate;
+                    break;
+                }
+            }
+        }
+        chosen ?? (chosen = byName.find((row) => !row.schemaFileId));
+        if (!chosen && modelFileId) {
+            // Every same-name row has another file id: adopt only one no other schema claims.
+            for (const candidate of byName) {
+                const links = await isLinkedTo(db, candidate.id, schemaId);
+                if (candidate.schemaFileId && !links.any)
+                    continue;
+                if (!links.other) {
+                    chosen = candidate;
+                    break;
+                }
+            }
+        }
+        else if (!chosen) {
+            chosen = (byName.length === 1 ? byName[0] : undefined) || byName.find((row) => !!row.schemaFileId) || byName[0];
+        }
+    }
+    if (chosen && modelFileId && chosen.schemaFileId !== modelFileId) {
+        // Adopt a stub or an unclaimed same-name row by giving it this file id.
+        await db.update(models).set({ schemaFileId: modelFileId, isEdited: false }).where(eq(models.id, chosen.id));
+        logger$7(`Adopted existing model "${modelName}" (id: ${chosen.id}) with schemaFileId "${modelFileId}"`);
+        return { ...chosen, schemaFileId: modelFileId, isEdited: false };
+    }
+    if (chosen)
+        return chosen;
+    return upsertModelRow(db, { name: modelName, schemaFileId: modelFileId });
+}
+/**
+ * Finds or creates the models row a Relation property on `ownerModelId` points to: the ref model
+ * in the owner's schema(s) first, since model names are only unique per schema.
+ */
+async function findOrCreateRefModelRow(db, refModelName, ownerModelId) {
+    try {
+        const ref = await resolveRefModelRecord(refModelName, { modelId: ownerModelId }, db);
+        if (ref)
+            return ref;
+    }
+    catch (error) {
+        // Not in the owner's schema and defined by several others: pick/create like an import does
+        if (!(error instanceof AmbiguousModelError))
+            throw error;
+    }
+    const [ownerLink] = await db
+        .select({ schemaId: modelSchemas.schemaId })
+        .from(modelSchemas)
+        .where(eq(modelSchemas.modelId, ownerModelId))
+        .limit(1);
+    return findOrCreateModelRow(db, refModelName, undefined, ownerLink?.schemaId ?? undefined);
+}
+/**
+ * Renames a model. With `schemaNameOrId` only that schema's model is renamed; without it the name
+ * alone is used, which throws AmbiguousModelError when several schemas define it. When the new
+ * name already exists in the scope that row is returned unchanged. Unscoped, a missing model is
+ * inserted under the new name.
+ */
+async function renameModelRow(db, oldName, newName, schemaNameOrId) {
+    const scope = schemaNameOrId === undefined
+        ? {}
+        : typeof schemaNameOrId === 'number'
+            ? { schemaId: schemaNameOrId, strict: true }
+            : { schemaName: schemaNameOrId, strict: true };
+    const model = await resolveModelRecord(oldName, scope, db);
+    if (!model) {
+        if (schemaNameOrId !== undefined)
+            throw new Error(`Model "${oldName}" not found in schema "${schemaNameOrId}"`);
+        return upsertModelRow(db, { name: newName });
+    }
+    const existingWithNewName = await resolveModelRecord(newName, scope, db);
+    if (existingWithNewName)
+        return existingWithNewName;
+    await db.update(models).set({ name: newName }).where(eq(models.id, model.id));
+    return { ...model, name: newName };
+}
+const propertyRowFields = [
+    'name',
+    'modelId',
+    'dataType',
+    'schemaFileId',
+    'refModelId',
+    'refValueType',
+    'required',
+    'isEdited',
+    'storageType',
+    'localStorageDir',
+    'filenameSuffix',
+    'definition',
+];
+/**
+ * Writes the properties row for a property definition. The row is the one with `schemaFileId`,
+ * else the one named `previousName` or `name` in the model. A row with that schema_file_id on
+ * another model is left alone. The rules for fields the input leaves out are on
+ * {@link PropertyRowInput}; an unchanged row is not written.
+ */
+async function upsertPropertyRow(db, input, options = {}) {
+    let existing;
+    if (input.schemaFileId) {
+        [existing] = await db.select().from(properties).where(eq(properties.schemaFileId, input.schemaFileId)).limit(1);
+        if (existing && existing.modelId !== input.modelId) {
+            logger$7(`Property ${input.name} (${input.schemaFileId}) belongs to model row ${existing.modelId}, not ${input.modelId}; left as is`);
+            return { row: existing, changed: false };
+        }
+    }
+    for (const name of [input.previousName, input.name]) {
+        if (existing || !name)
+            continue;
+        [existing] = await db
+            .select()
+            .from(properties)
+            .where(and(eq(properties.name, name), eq(properties.modelId, input.modelId)))
+            .limit(1);
+    }
+    if (existing && options.keepEditedRow && existing.isEdited === true) {
+        logger$7(`Keeping locally edited property row ${existing.name} (id ${existing.id})`);
+        return { row: existing, changed: false };
+    }
+    let refModelId = input.refModelId ?? null;
+    if (input.refModelName && input.refModelId == null) {
+        refModelId = (await findOrCreateRefModelRow(db, input.refModelName, input.modelId)).id ?? null;
+    }
+    const values = {
+        name: input.name,
+        modelId: input.modelId,
+        dataType: input.dataType ? normalizeDataType(input.dataType) : (existing?.dataType ?? ''),
+        schemaFileId: (options.keepStoredSchemaFileId && existing?.schemaFileId) || input.schemaFileId || existing?.schemaFileId || null,
+        refModelId,
+        refValueType: input.refValueType ? normalizeDataType(input.refValueType) : null,
+        required: input.required ?? existing?.required ?? false,
+        isEdited: input.isEdited ?? existing?.isEdited ?? false,
+        storageType: input.storage ? (input.storage.storageType ?? null) : (existing?.storageType ?? null),
+        localStorageDir: input.storage ? (input.storage.localStorageDir ?? null) : (existing?.localStorageDir ?? null),
+        filenameSuffix: input.storage ? (input.storage.filenameSuffix ?? null) : (existing?.filenameSuffix ?? null),
+        definition: input.definition
+            ? propertyDefinitionColumn(input.definition, input.replaceDefinition ? null : existing?.definition)
+            : (existing?.definition ?? null),
+    };
+    if (existing) {
+        const unchanged = propertyRowFields.every((field) => (existing[field] ?? null) === (values[field] ?? null));
+        if (unchanged)
+            return { row: existing, changed: false };
+        await db.update(properties).set(values).where(eq(properties.id, existing.id));
+        return { row: { ...existing, ...values }, changed: true };
+    }
+    const { name, modelId, ...rest } = values;
+    const [row] = await db
+        .insert(properties)
+        .values(values)
+        .onConflictDoUpdate(values.schemaFileId
+        ? { target: properties.schemaFileId, set: { name, ...rest } }
+        : { target: [properties.name, properties.modelId], set: rest })
+        .returning();
+    return { row, changed: true };
+}
+
+var definitions = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    findOrCreateModelRow: findOrCreateModelRow,
+    findOrCreateRefModelRow: findOrCreateRefModelRow,
+    inDefinitionsTransaction: inDefinitionsTransaction,
+    insertModelStubs: insertModelStubs,
+    linkModelToSchemaRow: linkModelToSchemaRow,
+    renameModelRow: renameModelRow,
+    upsertModelRow: upsertModelRow,
+    upsertPropertyRow: upsertPropertyRow,
+    upsertSchemaRow: upsertSchemaRow
+});
+
+const logger$6 = debug('seedSdk:helpers:db');
+/**
+ * Posts one message and closes the channel. A message already posted is still delivered after its
+ * sender closes, and an open BroadcastChannel keeps a Node process alive (each was a MessagePort
+ * handle that stopped scripts exiting).
+ */
+const postBroadcast = (channelName, message) => {
+    const channel = new BroadcastChannel(channelName);
+    try {
+        channel.postMessage(message);
+    }
+    finally {
+        channel.close();
+    }
+};
+/**
+ * The `properties` storage columns for a property definition, in either the internal shape
+ * (`storageType`, `localStorageDir`, `filenameSuffix`) or the schema-file shape
+ * (`storage: { type, path, extension }`). All null when the definition has no storage config.
+ */
+function propertyStorageColumns(def) {
+    const normalized = normalizePropertyRecordSchema((def ?? {}));
+    return {
+        storageType: normalized.storageType ?? null,
+        localStorageDir: normalized.localStorageDir ?? null,
+        filenameSuffix: normalized.filenameSuffix ?? null,
+    };
+}
+/** True when the definition carries any storage setting (so writing its columns can't wipe them by omission). */
+const hasStorageSettings = (columns) => columns.storageType != null || columns.localStorageDir != null || columns.filenameSuffix != null;
+/**
+ * A model's ItemStorage properties as stored in `properties` (storage_type 'ItemStorage'), with
+ * their storage path and extension. Reads the table, not ModelProperty instances, so it doesn't
+ * depend on whether (or from where) the model's property instances have loaded.
+ */
+async function getItemStoragePropertiesForModel(modelNameOrType, scope = {}) {
+    const db = BaseDb.getAppDb();
+    if (!db || !modelNameOrType)
+        return [];
+    const modelRecord = await resolveModelRecordByNameOrType(modelNameOrType, scope, db);
+    if (!modelRecord)
+        return [];
+    return db
+        .select({
+        id: properties.id,
+        name: properties.name,
+        localStorageDir: properties.localStorageDir,
+        filenameSuffix: properties.filenameSuffix,
+    })
+        .from(properties)
+        .where(and(eq(properties.modelId, modelRecord.id), eq(properties.storageType, 'ItemStorage')));
+}
+/**
+ * Moves a renamed property's pending outbox edits (ADR 0019) to its new name, so they apply as the
+ * property's. Its metadata rows need no move: readers match them by property_id (decision D4).
+ * Returns the number of ops renamed.
+ */
+async function renamePendingWritesForProperty(modelName, oldPropertyName, newPropertyName) {
+    const db = BaseDb.getAppDb();
+    if (!db)
+        return 0;
+    const renamed = await db
+        .update(pendingWrites)
+        .set({ propertyName: newPropertyName })
+        .where(and(eq(pendingWrites.propertyName, oldPropertyName), eq(pendingWrites.status, 'pending'), inArray(pendingWrites.seedLocalId, db.select({ localId: seeds.localId }).from(seeds).where(eq(seeds.type, easName(modelName))))))
+        .returning({ opId: pendingWrites.opId });
+    return renamed.length;
+}
+/** Tells React's useSchemas a schemas row was inserted (its live query may not re-run). */
+const broadcastSchemasInvalidate = () => {
+    if (typeof BroadcastChannel === 'undefined')
+        return;
+    try {
+        postBroadcast('seed-schemas-invalidate', {});
+    }
+    catch (_) { }
+};
+/** Tells React's useModels a model was linked to a schema (its live query may not re-run). */
+const broadcastModelsInvalidate = (schema) => {
+    if (typeof BroadcastChannel === 'undefined')
+        return;
+    try {
+        postBroadcast('seed-models-invalidate', {
+            schemaName: schema.name ?? undefined,
+            schemaFileId: schema.schemaFileId ?? undefined,
+        });
+    }
+    catch (_) { }
+};
+/**
+ * Writes a schema row ({@link upsertSchemaRow} has the matching rules) and returns it.
+ * @param schemaFileId - Optional schemaFileId from JSON file for change tracking
+ * @param schemaData - Optional full schema content as JSON string (SchemaFileFormat)
+ * @param isDraft - Optional flag indicating if schema is in draft state (default: false)
+ * @param isEdited - Optional flag indicating if schema has been edited locally (default: false)
+ * @param options.db - Write on this transaction; the caller then tells React after it commits.
+ *   Without it the write runs in its own transaction.
+ * @param options.contentHash - The applied file's hash (applySchemaFile); written with schemaData
+ */
+const addSchemaToDb = async (schema, schemaFileId, schemaData, isDraft, isEdited, options = {}) => {
+    if (!options.db && !BaseDb.getAppDb()) {
+        throw new Error('Database not found');
+    }
+    const input = {
+        name: schema.name,
+        version: schema.version,
+        createdAt: schema.createdAt,
+        updatedAt: schema.updatedAt,
+        schemaFileId,
+        schemaData,
+        isDraft,
+        isEdited,
+        contentHash: options.contentHash,
+    };
+    if (options.db) {
+        const { inserted: _inserted, ...row } = await upsertSchemaRow(options.db, input);
+        return row;
+    }
+    const { inserted, ...row } = await inDefinitionsTransaction((tx) => upsertSchemaRow(tx, input));
+    if (inserted)
+        broadcastSchemasInvalidate();
+    return row;
+};
+/**
+ * Renames a model ({@link renameModelRow}), in its own transaction unless `db` is given.
+ * @param schemaNameOrId - Schema name or id to scope the rename (required when multiple schemas have models with the same name)
+ */
+const renameModelInDb = async (oldName, newName, schemaNameOrId, db) => {
+    if (db)
+        return renameModelRow(db, oldName, newName, schemaNameOrId);
+    if (!BaseDb.getAppDb())
+        throw new Error('Database not found');
+    return inDefinitionsTransaction((tx) => renameModelRow(tx, oldName, newName, schemaNameOrId));
+};
+/**
+ * Writes a schema file's models, their property rows and their model_schemas links.
+ * @param models - Models to write besides those in schemaFileData.propertyDefinitions
+ * @param schema - Optional schema to link models to (a row, or written first when it has no id)
+ * @param modelRenames - Optional map of old model names to new model names
+ * @param schemaFileData - The file's ids and property definitions: { schemaFileId, modelFileIds: Map<modelName, id>, propertyFileIds: Map<modelName, Map<propertyName, id>>, propertyDefinitions }
+ * @param options.db - Write on this transaction; the caller refreshes cached ModelProperty
+ *   instances with the returned ids once it has committed. Without it the write runs in its own
+ *   transaction and refreshes them itself.
+ * @returns The schemaFileIds of the property rows this call changed
+ */
+const addModelsToDb = async (models, schema, modelRenames, schemaFileData, options = {}) => {
+    if (!options.db) {
+        if (!BaseDb.getAppDb())
+            throw new Error('Database not found');
+        const changed = await inDefinitionsTransaction((tx) => addModelsToDb(models, schema, modelRenames, schemaFileData, { db: tx }));
+        // A cached instance is otherwise never re-read from its row (createById returns it as is)
+        await refreshCachedProperties(changed);
+        return changed;
+    }
+    const db = options.db;
+    // Model rows and their schema links decide which schema file's nameMatch applies (ADR 0009).
+    clearNameMatchLevels();
+    // The schema may already be a row (with id)
+    let schemaRecord;
+    if (schema) {
+        schemaRecord =
+            schema.id !== null && schema.id !== undefined
+                ? schema
+                : await addSchemaToDb(schema, schemaFileData?.schemaFileId, undefined, undefined, undefined, { db });
+    }
+    if (modelRenames && schemaRecord) {
+        const schemaNameOrId = schemaRecord.name ?? schemaRecord.id;
+        for (const [oldName, newName] of modelRenames.entries()) {
+            await renameModelRow(db, oldName, newName, schemaNameOrId);
+        }
+    }
+    const modelRecords = new Map();
+    const modelProcessingErrors = [];
+    // Property rows this call changed, so cached ModelProperty instances can be given the new values
+    const updatedPropertyFileIds = [];
+    const { generateId } = await Promise.resolve().then(function () { return generateId$1; });
+    const modelNames = [...new Set([...Object.keys(models), ...(schemaFileData?.propertyDefinitions?.keys() ?? [])])];
+    for (const modelName of modelNames) {
+        try {
+            const modelFileId = schemaFileData?.modelFileIds?.get(modelName);
+            const modelRecord = modelRecords.get(modelName) ?? (await findOrCreateModelRow(db, modelName, modelFileId, schemaRecord?.id));
+            modelRecords.set(modelName, modelRecord);
+            const definitions = schemaFileData?.propertyDefinitions?.get(modelName) ?? {};
+            for (const [propertyName, propertyValues] of Object.entries(definitions)) {
+                if (!propertyValues) {
+                    throw new Error(`Property values not found for ${propertyName}`);
+                }
+                // IDs are assigned before this is called; a generated one doesn't replace a stored id.
+                const propertyFileId = schemaFileData?.propertyFileIds?.get(modelName)?.get(propertyName);
+                let refModelId = null;
+                const refModelName = propertyValues.ref || propertyValues.refModelName;
+                if (refModelName) {
+                    let refModel = modelRecords.get(refModelName);
+                    if (!refModel) {
+                        const refModelFileId = schemaFileData?.modelFileIds?.get(refModelName);
+                        refModel = await findOrCreateModelRow(db, refModelName, refModelFileId, schemaRecord?.id);
+                        modelRecords.set(refModelName, refModel);
+                    }
+                    refModelId = refModel.id ?? null;
+                }
+                // ADR 0008: a rename needs the property's id. A name that matches no stored property by id
+                // or name is a new property. The schema file is the source of truth for every column, and
+                // a property edited locally keeps its row.
+                const { row, changed } = await upsertPropertyRow(db, {
+                    modelId: modelRecord.id,
+                    name: propertyName,
+                    dataType: propertyValues.dataType,
+                    schemaFileId: propertyFileId ?? generateId(),
+                    refModelId,
+                    refValueType: propertyValues.refValueType ?? null,
+                    required: propertyValues.required ?? false,
+                    storage: propertyStorageColumns(propertyValues),
+                    isEdited: false,
+                    definition: schemaFileData?.propertyFileDefinitions?.get(modelName)?.[propertyName] ?? propertyValues,
+                    replaceDefinition: true,
+                }, { keepStoredSchemaFileId: !propertyFileId, keepEditedRow: true });
+                if (changed && row?.schemaFileId)
+                    updatedPropertyFileIds.push(row.schemaFileId);
+            }
+        }
+        catch (error) {
+            const errorMessage = error?.message || String(error);
+            logger$6(`Error processing model "${modelName}": ${errorMessage}`);
+            modelProcessingErrors.push({ modelName, error: errorMessage });
+            // Continue processing other models even if one fails
+        }
+    }
+    if (modelProcessingErrors.length > 0) {
+        console.warn(`[addModelsToDb] Errors occurred while processing ${modelProcessingErrors.length} model(s):`, modelProcessingErrors.map(e => `${e.modelName}: ${e.error}`).join('; '));
+    }
+    if (schemaRecord?.id) {
+        for (const [modelName, record] of modelRecords) {
+            if (!record.id)
+                continue;
+            if (await linkModelToSchemaRow(db, record.id, schemaRecord.id)) {
+                logger$6(`Linked model ${modelName} (id: ${record.id}) to schema (id: ${schemaRecord.id})`);
+            }
+        }
+    }
+    return updatedPropertyFileIds;
+};
+/**
+ * The models linked to a schema row (model_schemas) with their property rows, in schema-file
+ * shape: `{ [modelName]: { id, properties: { [name]: { dataType, schemaFileId, ref, ... } } } }`.
+ * Properties carry their row's definition (validation, description, ...); model-level fields only a
+ * schema file holds aren't here, see {@link mergeDbModelsIntoSchemaModels}.
+ * @param schemaId - The ID of the schema record in the database
+ */
+const loadModelsFromDbForSchema = async (schemaId, db = BaseDb.getAppDb()) => {
+    if (!db) {
+        logger$6('Database not found, cannot load models from DB');
+        return {};
+    }
+    try {
+        const linked = await db
+            .select({ modelId: modelSchemas.modelId, modelName: models.name, schemaFileId: models.schemaFileId })
+            .from(modelSchemas)
+            .innerJoin(models, eq(modelSchemas.modelId, models.id))
+            .where(eq(modelSchemas.schemaId, schemaId));
+        const modelIds = linked.map((row) => row.modelId).filter((id) => id != null);
+        if (modelIds.length === 0)
+            return {};
+        const refModels = alias(models, 'ref_models');
+        const propertyRows = await db
+            .select({ property: properties, refName: refModels.name })
+            .from(properties)
+            .leftJoin(refModels, eq(properties.refModelId, refModels.id))
+            .where(inArray(properties.modelId, modelIds));
+        const models$1 = {};
+        const nameById = new Map();
+        for (const { modelId, modelName, schemaFileId } of linked) {
+            if (!modelId || !modelName)
+                continue;
+            nameById.set(modelId, modelName);
+            // The id (schemaFileId) lets Model.create find the existing row instead of adding a "Post 1".
+            models$1[modelName] = { properties: {}, ...(schemaFileId ? { id: schemaFileId } : {}) };
+        }
+        for (const { property: prop, refName } of propertyRows) {
+            const modelName = nameById.get(prop.modelId);
+            if (!modelName)
+                continue;
+            // The row's definition without its row keys; `required` stays the file's
+            const { id: _id, _dbId, name: _name, modelId: _modelId, refModelId: _refModelId, refModelName: _refModelName, required: _required, ...definition } = propertyDefinitionFromRow(prop, refName);
+            models$1[modelName].properties[prop.name] = {
+                ...definition,
+                ...(prop.schemaFileId ? { schemaFileId: prop.schemaFileId } : {}),
+            };
+        }
+        logger$6(`Loaded ${Object.keys(models$1).length} models from database for schema ${schemaId}`);
+        return models$1;
+    }
+    catch (error) {
+        logger$6(`Error loading models from database for schema ${schemaId}:`, error);
+        return {};
+    }
+};
+/**
+ * Merges the models {@link loadModelsFromDbForSchema} read from the database into a schema's
+ * models. The database decides which models and properties exist and their stored fields; the
+ * schema keeps what only it holds (nameMatch, description, validation, ...), found by id first so
+ * a property renamed in the database keeps them. A schema property whose id a database property
+ * has is dropped under its old name.
+ */
+const mergeDbModelsIntoSchemaModels = (schemaModels, dbModels) => {
+    const merged = { ...(schemaModels ?? {}) };
+    for (const [modelName, dbModel] of Object.entries(dbModels)) {
+        const schemaModel = schemaModels?.[modelName];
+        if (!schemaModel) {
+            merged[modelName] = dbModel;
+            continue;
+        }
+        const schemaProps = schemaModel.properties ?? {};
+        const dbProps = dbModel.properties ?? {};
+        const schemaNameById = new Map();
+        for (const [name, prop] of Object.entries(schemaProps)) {
+            const id = prop?.id ?? prop?.schemaFileId;
+            if (id)
+                schemaNameById.set(id, name);
+        }
+        const properties = {};
+        const matched = new Set();
+        for (const [name, dbProp] of Object.entries(dbProps)) {
+            const byId = dbProp?.schemaFileId ? schemaNameById.get(dbProp.schemaFileId) : undefined;
+            const byName = schemaProps[name];
+            const byNameId = byName?.id ?? byName?.schemaFileId;
+            // By name only when the ids don't say it's another property.
+            const schemaName = byId ?? (byName && !(byNameId && dbProp?.schemaFileId && byNameId !== dbProp.schemaFileId) ? name : undefined);
+            const schemaProp = schemaName ? schemaProps[schemaName] : undefined;
+            if (schemaName && schemaProp)
+                matched.add(schemaName);
+            // The database's dataType and ref replace the file's type and model.
+            const { type, model, ...fromSchema } = schemaProp ?? {};
+            properties[name] = {
+                ...fromSchema,
+                ...(dbProp?.dataType === undefined && type !== undefined ? { type } : {}),
+                ...(dbProp?.ref === undefined && model !== undefined ? { model } : {}),
+                ...dbProp,
+            };
+        }
+        const unmatched = Object.fromEntries(Object.entries(schemaProps).filter(([name]) => !matched.has(name)));
+        merged[modelName] = { ...schemaModel, ...dbModel, properties: { ...unmatched, ...properties } };
+    }
+    return merged;
+};
+/**
+ * Saves a ModelProperty's edit to its properties row (is_edited true) without updating the schema
+ * file, in one transaction. A context without `required` or storage settings leaves the row's.
+ * @param property - The ModelPropertyMachineContext with updated values
+ */
+const savePropertyToDb = async (property) => {
+    if (!BaseDb.getAppDb()) {
+        throw new Error('Database not found');
+    }
+    const name = property.name;
+    if (!name) {
+        throw new Error('Property name is required');
+    }
+    const schemaFileId = property._propertyFileId || (typeof property.id === 'string' ? property.id : undefined);
+    const storage = propertyStorageColumns(property);
+    await inDefinitionsTransaction(async (tx) => {
+        // modelId, then the model of the property row (by its schemaFileId), then modelName in the
+        // property's schema. context.modelName can also hold the model's schemaFileId.
+        const modelRecord = await resolveModelRecord(property.modelName, {
+            modelId: typeof property.modelId === 'number' ? property.modelId : undefined,
+            propertyFileId: schemaFileId,
+            modelFileId: property.modelName,
+            schemaName: property._schemaName,
+        }, tx);
+        if (!modelRecord) {
+            throw new Error(`Model not found in database (modelId=${property.modelId}, modelName=${property.modelName})`);
+        }
+        await upsertPropertyRow(tx, {
+            modelId: modelRecord.id,
+            name,
+            dataType: property.dataType,
+            schemaFileId,
+            previousName: property._originalValues?.name,
+            refModelName: property.refModelName,
+            refModelId: property.refModelName ? undefined : (property.refModelId ?? null),
+            refValueType: property.refValueType ?? null,
+            required: property.required,
+            storage: hasStorageSettings(storage) ? storage : undefined,
+            isEdited: true,
+            definition: property,
+        });
+    });
+    logger$6(`Saved property ${property.modelName}:${property.name}`);
+};
+function parseAddressConfig(value) {
+    if (!value)
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        if (Array.isArray(parsed)) {
+            return normalizeAddressConfig(parsed);
+        }
+        if (parsed && typeof parsed === 'object' && Array.isArray(parsed.owned)) {
+            return normalizeAddressConfig({
+                owned: parsed.owned,
+                watched: Array.isArray(parsed.watched) ? parsed.watched : [],
+            });
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+const getOwnedAddressesFromDb = async () => {
+    const config = await getAddressConfigFromDb();
+    return config?.owned ?? [];
+};
+const getWatchedAddressesFromDb = async () => {
+    const config = await getAddressConfigFromDb();
+    return config?.watched ?? [];
+};
+/**
+ * Returns persisted owned or watched addresses for list filters.
+ * Does not include `getAdditionalSyncAddresses` (those are extra EAS indexers).
+ */
+const getAddressesForItemsFilter = async (addressFilter) => {
+    if (addressFilter === 'owned') {
+        return getOwnedAddressesFromDb();
+    }
+    return getWatchedAddressesFromDb();
+};
+/**
+ * Returns owned + watched addresses. Use for EAS sync and file download.
+ */
+const getAllAddressesFromDb = async () => {
+    const config = await getAddressConfigFromDb();
+    if (!config)
+        return [];
+    return [...config.owned, ...config.watched];
+};
+async function getAddressConfigFromDb() {
+    // Before init opens the database (or with no init) there are no stored addresses to read
+    const appDb = await whenDbReady();
+    if (!appDb)
+        return null;
+    const appStatesRecords = await appDb
+        .select()
+        .from(appState)
+        .where(eq(appState.key, 'addresses'))
+        .limit(1);
+    if (!appStatesRecords || appStatesRecords.length === 0) {
+        return null;
+    }
+    const addressArrayString = appStatesRecords[0].value;
+    return parseAddressConfig(addressArrayString);
+}
+/**
+ * Writes a runtime-created model: its models row (is_edited true when new), its model_schemas link
+ * and the properties given, in one transaction. Returns the model's row id.
+ * @param modelFileId - The model file ID (schema_file_id)
+ * @param data - Model data including modelName, schemaId, and optional properties
+ */
+async function writeModelToDb(modelFileId, data) {
+    if (!BaseDb.getAppDb())
+        throw new Error('Database not available');
+    if (!data.schemaId || !Number.isInteger(data.schemaId) || data.schemaId <= 0) {
+        throw new Error(`Invalid schemaId: ${data.schemaId}. Schema record must exist before creating join entry.`);
+    }
+    const { generateId } = await Promise.resolve().then(function () { return generateId$1; });
+    const { linked, schema, modelId } = await inDefinitionsTransaction(async (tx) => {
+        const [schema] = await tx
+            .select({ id: schemas.id, name: schemas.name, schemaFileId: schemas.schemaFileId })
+            .from(schemas)
+            .where(eq(schemas.id, data.schemaId))
+            .limit(1);
+        if (!schema) {
+            throw new Error(`Schema with id ${data.schemaId} does not exist in database. Cannot create join record.`);
+        }
+        const model = await upsertModelRow(tx, { name: data.modelName, schemaFileId: modelFileId, isEdited: true });
+        const linked = await linkModelToSchemaRow(tx, model.id, data.schemaId);
+        for (const [propName, propData] of Object.entries(data.properties ?? {})) {
+            const refModelName = propData.refModelName || propData.ref;
+            const storage = propertyStorageColumns(propData);
+            // A stored row keeps its id; the given or a generated one is for a new row.
+            await upsertPropertyRow(tx, {
+                modelId: model.id,
+                name: propName,
+                dataType: propData.dataType,
+                schemaFileId: propData.id ?? generateId(),
+                refModelName,
+                refModelId: refModelName ? undefined : (propData.refModelId ?? null),
+                refValueType: propData.refValueType ?? null,
+                required: propData.required,
+                storage: hasStorageSettings(storage) ? storage : undefined,
+                definition: propData,
+            }, { keepStoredSchemaFileId: true });
+        }
+        return { linked, schema, modelId: model.id };
+    });
+    if (linked)
+        broadcastModelsInvalidate(schema);
+    logger$6(`Wrote model ${data.modelName} (${modelFileId}) to database`);
+    return modelId;
+}
+/**
+ * Writes a property's row by its file id ({@link upsertPropertyRow}), in its own transaction.
+ * `required` and storage settings the data leaves out keep the row's.
+ * @param propertyFileId - The property file ID (schema_file_id)
+ * @param data - Property data including modelId, name, dataType, and other property fields
+ * @param isEdited - Optional flag indicating if property has been edited locally. Left unset, an update
+ *   keeps the row's flag (a load or creation write must not clear an unsaved edit) and an insert stores false.
+ */
+async function writePropertyToDb(propertyFileId, data, isEdited) {
+    if (!BaseDb.getAppDb())
+        throw new Error('Database not available');
+    const refModelName = data.refModelName || data.ref;
+    const storage = propertyStorageColumns(data);
+    await inDefinitionsTransaction((tx) => upsertPropertyRow(tx, {
+        modelId: data.modelId,
+        name: data.name,
+        dataType: data.dataType,
+        schemaFileId: propertyFileId,
+        refModelName,
+        refModelId: refModelName ? undefined : (data.refModelId ?? null),
+        refValueType: data.refValueType ?? null,
+        required: data.required,
+        storage: hasStorageSettings(storage) ? storage : undefined,
+        isEdited,
+        definition: data,
+    }));
+    logger$6(`Wrote property ${data.name} (${propertyFileId})`);
+}
+
+var db = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    addModelsToDb: addModelsToDb,
+    addSchemaToDb: addSchemaToDb,
+    broadcastSchemasInvalidate: broadcastSchemasInvalidate,
+    getAddressesForItemsFilter: getAddressesForItemsFilter,
+    getAllAddressesFromDb: getAllAddressesFromDb,
+    getItemStoragePropertiesForModel: getItemStoragePropertiesForModel,
+    getOwnedAddressesFromDb: getOwnedAddressesFromDb,
+    getWatchedAddressesFromDb: getWatchedAddressesFromDb,
+    loadModelsFromDbForSchema: loadModelsFromDbForSchema,
+    mergeDbModelsIntoSchemaModels: mergeDbModelsIntoSchemaModels,
+    propertyStorageColumns: propertyStorageColumns,
+    renameModelInDb: renameModelInDb,
+    renamePendingWritesForProperty: renamePendingWritesForProperty,
+    savePropertyToDb: savePropertyToDb,
+    writeModelToDb: writeModelToDb,
+    writePropertyToDb: writePropertyToDb
+});
+
+/**
+ * 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();
+};
+/**
+ * NODE_ENV is 'test' or IS_SEED_DEV is set. Bundlers compile `process.env.NODE_ENV` in, but
+ * not IS_SEED_DEV, so that is only read where a `process` global exists: browsers have none.
+ */
+const isTestOrSeedDev = () => process.env.NODE_ENV === 'test' || (typeof process !== 'undefined' && !!process.env?.IS_SEED_DEV);
+
+/**
+ * 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$5 = 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$5(`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();
+}
+
+const logger$4 = 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$4(`${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)]));
+};
+
+/**
+ * Tag every Seed upload carries with the hex digest of its data. Producers: the SDK's
+ * `getPublishUploadData` / `getPublishUploads` (and through them both the L1 transaction path and
+ * the bundler / DataItem path in `@seedprotocol/publish`). Consumer: the files download
+ * (`events/files/download.ts` and the download worker), which verifies downloaded bytes against it.
+ */
+const CONTENT_SHA256_TAG = 'Content-SHA-256';
+const CONTENT_TYPE_TAG = 'Content-Type';
+/**
+ * Lowercase hex SHA-256 of `data`: the value of the {@link CONTENT_SHA256_TAG} tag.
+ *
+ * Uses @noble/hashes rather than WebCrypto so it also works outside secure contexts (WebCrypto's
+ * `crypto.subtle` is missing on plain-http origins); the digest is the same.
+ *
+ * In SDK 0.7.2 and earlier the L1 transaction path (`getPublishUploads`) wrote SHA3-256 under this tag name
+ * while the bundler path wrote SHA-256. Uploads from that path still carry SHA3-256 digests; use
+ * {@link contentSha256TagMatches} to check a tag value against bytes.
+ */
+const getContentSha256 = (data) => bytesToHex(sha256(data));
+/**
+ * True when `tagValue` (a {@link CONTENT_SHA256_TAG} value read from Arweave) is the digest of
+ * `data`. Accepts SHA-256 and, for uploads made by SDK 0.7.2 and earlier through the L1 transaction path,
+ * SHA3-256.
+ */
+const contentSha256TagMatches = (data, tagValue) => {
+    const expected = tagValue.trim().toLowerCase();
+    if (!expected)
+        return false;
+    return getContentSha256(data) === expected || bytesToHex(sha3_256(data)) === expected;
+};
+/**
+ * Tags for one upload, in the order every upload uses: content hash, content type, then any
+ * configured extra tags (e.g. App-Name from `arweaveUploadTags`).
+ */
+const buildArweaveContentTags = (contentHash, contentType, extra) => {
+    const tags = [];
+    if (contentHash)
+        tags.push({ name: CONTENT_SHA256_TAG, value: contentHash });
+    if (contentType)
+        tags.push({ name: CONTENT_TYPE_TAG, value: contentType });
+    if (extra?.length)
+        tags.push(...extra);
+    return tags;
+};
+
+/** Subdirectory of the files root that holds a storage seed's file, by its data type. */
+const getStorageSubdirForDataType = (dataType) => {
+    switch (normalizeDataType(dataType ?? undefined)) {
+        case 'Image':
+            return 'images';
+        case 'Html':
+            return 'html';
+        case 'Json':
+            return 'json';
+        case 'File':
+        default:
+            // Unknown types are generic files; `images/` is only for what the SDK knows is an image.
+            return 'files';
+    }
+};
+/**
+ * Subdirectory (relative to the files root, no leading slash) for an ItemStorage property's file:
+ * its model's `storage.path` (`localStorageDir`), else `files`.
+ */
+const getItemStorageSubdir = (localStorageDir) => (localStorageDir ?? '').replace(/^\/+/, '').replace(/\/+$/, '') || 'files';
+/**
+ * File name a local save gives an ItemStorage property: `<seedUid or seedLocalId><extension>`
+ * (see saveItemStorage). Downloaded content is named after its transaction instead
+ * (`<txId><extension>`, see syncDbWithEas), which is what the metadata row's refResolvedValue says.
+ */
+const getItemStorageLocalFileName = (seedId, filenameSuffix) => `${seedId}${filenameSuffix ?? ''}`;
+
+/** Rows per query: well under SQLite's bound-parameter limit. */
+const CHUNK_SIZE = 400;
+/**
+ * Where the download worker saves each child of a composite upload, by transaction id then child
+ * (property) name: a path relative to the files root.
+ *
+ * The paths come from the ItemStorage rows sync derives from a `storage_transaction_id`
+ * attestation (see `createMetadataRecordsForStorageTransactionId`): property value = the
+ * transaction id, `refResolvedValue` = `<txId><extension>`, `localStorageDir` = the model's storage
+ * directory. Those rows are what hydration reads, so a child saved here is found as that property's
+ * file. Transactions with no such rows are left out; the worker then falls back to the legacy
+ * html / json layout.
+ */
+const getCompositeChildPaths = async (transactionIds) => {
+    const out = {};
+    const appDb = BaseDb.getAppDb();
+    if (!appDb || transactionIds.length === 0)
+        return out;
+    for (let i = 0; i < transactionIds.length; i += CHUNK_SIZE) {
+        const chunk = transactionIds.slice(i, i + CHUNK_SIZE);
+        const rows = await appDb
+            .select({
+            transactionId: metadata.propertyValue,
+            propertyName: metadata.propertyName,
+            refResolvedValue: metadata.refResolvedValue,
+            localStorageDir: metadata.localStorageDir,
+        })
+            .from(metadata)
+            .where(and(isNotNull(metadata.derivedFromUid), isNotNull(metadata.refResolvedValue), inArray(metadata.propertyValue, chunk)));
+        for (const row of rows) {
+            const { transactionId, propertyName, refResolvedValue } = row;
+            if (!transactionId || !propertyName || !refResolvedValue)
+                continue;
+            // A file name, never a path: anything else is not where the SDK would look.
+            if (refResolvedValue.includes('/') || refResolvedValue.includes('\\'))
+                continue;
+            const byName = (out[transactionId] ?? (out[transactionId] = {}));
+            byName[propertyName] ?? (byName[propertyName] = `${getItemStorageSubdir(row.localStorageDir)}/${refResolvedValue}`);
+        }
+    }
+    return out;
+};
+
+const logger$3 = debug('seedSdk:files:download');
+const AUTO_BULK_DOWNLOAD_THROTTLE_MS = 10000;
+/** Avoid refetch-on-every-call: transient empty indexer responses were overwriting good cache (see trailing throttle ~10s after success). */
+const GET_FILES_METADATA_STALE_MS = 120000;
+let bulkDownloadInFlight = null;
+const lazyDownloadInFlightByTransactionId = new Map();
+const getExcludedTransactions = async () => {
+    const appDb = await whenDbReady();
+    if (!appDb) {
+        return new Set();
+    }
+    const excludedTransactionsQuery = await appDb
+        .select()
+        .from(appState)
+        .where(eq(appState.key, 'excludedTransactions'));
+    const excludedTransactions = new Set();
+    if (excludedTransactionsQuery && excludedTransactionsQuery.length === 1) {
+        const valueString = excludedTransactionsQuery[0].value;
+        if (valueString) {
+            const excludedTransactionsArray = JSON.parse(valueString);
+            for (const txId of excludedTransactionsArray) {
+                excludedTransactions.add(txId);
+            }
+        }
+    }
+    return excludedTransactions;
+};
+/** Arweave transaction ids are 43 chars in the URL-safe base64 alphabet. */
+const ARWEAVE_TX_ID_RE$1 = /^[a-z0-9_-]{43}$/i;
+const normalizeArweaveTxId = (raw) => {
+    if (raw == null || raw === '')
+        return undefined;
+    const t = String(raw).trim();
+    if (ARWEAVE_TX_ID_RE$1.test(t))
+        return t;
+    const m = t.match(/^([a-z0-9_-]{43})(?:\.[^/]+)?$/i);
+    if (m)
+        return m[1];
+    // Values may be full gateway URLs or paths; scan for an embedded tx id. It must be 43 characters
+    // on its own, not the start of a longer run: the first 43 of a bytes32 value (`0x0000…0020`,
+    // an EAS UID) are in the alphabet too.
+    const embedded = t.match(/(?<![a-z0-9_-])[a-z0-9_-]{43}(?![a-z0-9_-])/gi);
+    return embedded?.[0];
+};
+const mergeAddressLists = (a, b) => {
+    const seen = new Set();
+    const out = [];
+    for (const addr of [...(a ?? []), ...(b ?? [])]) {
+        if (!addr || !addr.trim())
+            continue;
+        const k = addr.toLowerCase();
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        out.push(addr);
+    }
+    return out;
+};
+const collectTransactionIdsFromLocalMetadata = async () => {
+    const appDb = await whenDbReady();
+    if (!appDb) {
+        return [];
+    }
+    const nameOr = or(eq(metadata.propertyName, 'storageTransactionId'), eq(metadata.propertyName, 'storage_transaction_id'), eq(metadata.propertyName, 'transactionId'));
+    const propRows = await appDb
+        .select({ propertyValue: metadata.propertyValue })
+        .from(metadata)
+        .where(and(nameOr, isNotNull(metadata.propertyValue)));
+    const refRows = await appDb
+        .select({ refResolvedValue: metadata.refResolvedValue })
+        .from(metadata)
+        .where(isNotNull(metadata.refResolvedValue));
+    const ids = new Set();
+    for (const row of propRows) {
+        const id = normalizeArweaveTxId(row.propertyValue ?? undefined);
+        if (id)
+            ids.add(id);
+    }
+    for (const row of refRows) {
+        const id = normalizeArweaveTxId(row.refResolvedValue ?? undefined);
+        if (id)
+            ids.add(id);
+    }
+    return Array.from(ids);
+};
+const parseTransactionIdsFromMetadata = (filesMetadata, excludedTransactions) => {
+    const transactionIds = [];
+    for (const fileMetadata of filesMetadata) {
+        // Validate and parse decodedDataJson
+        if (!fileMetadata.decodedDataJson || fileMetadata.decodedDataJson.trim() === '') {
+            console.warn('[events/files] [download] empty decodedDataJson for fileMetadata: ', fileMetadata.id);
+            continue;
+        }
+        let json;
+        try {
+            json = JSON.parse(fileMetadata.decodedDataJson);
+        }
+        catch (error) {
+            console.warn('[events/files] [download] failed to parse decodedDataJson for fileMetadata: ', fileMetadata.id, error);
+            continue;
+        }
+        if (!Array.isArray(json) || json.length === 0 || !json[0]?.value?.value) {
+            console.warn('[events/files] [download] invalid decodedDataJson structure for fileMetadata: ', fileMetadata.id);
+            continue;
+        }
+        const rawTx = json[0].value.value;
+        if (typeof rawTx !== 'string' || rawTx.trim().length === 0) {
+            continue;
+        }
+        const transactionId = normalizeArweaveTxId(rawTx.trim());
+        if (!transactionId) {
+            continue;
+        }
+        if (excludedTransactions.has(transactionId) || excludedTransactions.has(rawTx.trim())) {
+            continue;
+        }
+        transactionIds.push(transactionId);
+    }
+    return transactionIds;
+};
+/** How long looked-up transaction tags stay cached. */
+const TRANSACTION_TAGS_CACHE_MS = 5 * 60 * 1000;
+/** Content-SHA-256 tag values for the transactions that have one, from one batched tag lookup (cached). */
+const getExpectedContentHashes = async (transactionIds) => {
+    const queryClient = BaseQueryClient.getQueryClient();
+    const tagsById = new Map();
+    const toFetch = [];
+    for (const transactionId of transactionIds) {
+        // Tags never change once a transaction is indexed, so a cached lookup stays good.
+        const cached = queryClient.getQueryData?.(['getTransactionTags', transactionId]);
+        if (cached)
+            tagsById.set(transactionId, cached);
+        else
+            toFetch.push(transactionId);
+    }
+    if (toFetch.length > 0) {
+        try {
+            const fetched = await getTransactionTagsByIds(toFetch, {
+                client: BaseArweaveClient.getArweaveClient(),
+                onError: (error) => logger$3('[download] transaction tags lookup failed', error),
+            });
+            for (const [transactionId, tags] of fetched) {
+                tagsById.set(transactionId, tags);
+                // Seed the per-transaction cache entry (the client interface has no setQueryData).
+                void queryClient
+                    .fetchQuery({
+                    queryKey: ['getTransactionTags', transactionId],
+                    queryFn: async () => tags,
+                    // The query client keeps a result only as long as the caller's staleTime.
+                    staleTime: TRANSACTION_TAGS_CACHE_MS,
+                })
+                    .catch(() => { });
+            }
+        }
+        catch (error) {
+            logger$3('[download] transaction tags lookup failed', error);
+        }
+    }
+    const out = {};
+    for (const [transactionId, tags] of tagsById) {
+        const value = tags.find((tag) => tag.name === CONTENT_SHA256_TAG)?.value?.trim();
+        if (value)
+            out[transactionId] = value;
+    }
+    return out;
+};
+const downloadTransactionIds = async (rawTransactionIds, options) => {
+    if (!supportsOpfsFileDownloads()) {
+        return false;
+    }
+    const transactionIds = Array.from(new Set(rawTransactionIds.filter((tx) => !!tx && tx.trim().length > 0)));
+    if (transactionIds.length === 0) {
+        return false;
+    }
+    const excludedTransactions = await getExcludedTransactions();
+    await ensureReadGatewaySelected();
+    // Browser: do not call getTransactionStatus() — many gateways (e.g. g8way.io) redirect or omit
+    // CORS headers, so fetch() fails and we would wrongly exclude txs. The OPFS worker fetch decides success.
+    const transactionIdsToDownload = transactionIds.filter((id) => !excludedTransactions.has(id));
+    if (transactionIdsToDownload.length === 0) {
+        return false;
+    }
+    // One batched lookup for every upload's Content-SHA-256 tag; downloads are verified against it.
+    // Missing tags (old uploads, or a just-published one not indexed yet) just mean no verification.
+    const expectedContentHashes = await getExpectedContentHashes(transactionIdsToDownload);
+    // Preferred gateways first: a just-published item is only on the gateway it was uploaded through.
+    const arweaveBaseUrls = getArweaveReadBaseUrls();
+    // Where each ItemStorage child of a composite goes (the worker cannot read the DB or the schema).
+    const compositeChildPaths = await getCompositeChildPaths(transactionIdsToDownload).catch((error) => {
+        logger$3('[download] composite child paths lookup failed', error);
+        return {};
+    });
+    let result;
+    if (transactionIdsToDownload.length === 1) {
+        const transactionId = transactionIdsToDownload[0];
+        result = await BaseFileManager.downloadFileByTransactionId({
+            transactionId,
+            arweaveHost: BaseArweaveClient.getBaseUrl(),
+            arweaveBaseUrls,
+            excludedTransactions,
+            expectedContentHash: expectedContentHashes[transactionId],
+            compositeChildPaths: compositeChildPaths[transactionId],
+            skipExisting: options?.skipExisting,
+        });
+    }
+    else {
+        result = await BaseFileManager.downloadAllFiles({
+            transactionIds: transactionIdsToDownload,
+            arweaveHost: BaseArweaveClient.getBaseUrl(),
+            arweaveBaseUrls,
+            excludedTransactions,
+            expectedContentHashes,
+            compositeChildPaths,
+            skipExisting: options?.skipExisting,
+        });
+    }
+    if (result) {
+        for (const transactionId of result.hashMismatchTransactionIds) {
+            // Not saved by the worker; left for a later run (a gateway may serve the right bytes then).
+            logger$3(`[download] ${transactionId}: downloaded bytes do not match Content-SHA-256; skipped`);
+        }
+    }
+    return true;
+};
+const runBulkDownloadWithDedupe = async (transactionIds) => {
+    if (bulkDownloadInFlight) {
+        return bulkDownloadInFlight;
+    }
+    bulkDownloadInFlight = (async () => {
+        try {
+            await downloadTransactionIds(transactionIds, { skipExisting: true });
+        }
+        finally {
+            bulkDownloadInFlight = null;
+        }
+    })();
+    return bulkDownloadInFlight;
+};
+const downloadAllFilesBinaryRequestHandler = async (addressesHint) => {
+    if (!supportsOpfsFileDownloads()) {
+        return;
+    }
+    // Waits for init to open the database, if it hasn't yet
+    const fromDb = await getAllAddressesFromDb();
+    const addresses = mergeAddressLists(addressesHint, fromDb);
+    if (!addresses || addresses.length === 0) {
+        return;
+    }
+    const queryClient = BaseQueryClient.getQueryClient();
+    const easClient = BaseEasClient.getEasClient();
+    const filesMetadataQueryKey = ['getFilesMetadata', ...addresses];
+    const fetchFilesMetadata = () => easClient.request(GET_FILES_METADATA, {
+        where: {
+            attester: {
+                in: addresses,
+            },
+            schema: {
+                is: {
+                    id: {
+                        equals: '0x55fdefb36fcbbaebeb7d6b41dc3a1a9666e4e42154267c889de064faa7ede517',
+                    },
+                },
+            },
+        },
+    });
+    let { filesMetadata } = await queryClient.fetchQuery({
+        queryKey: filesMetadataQueryKey,
+        queryFn: fetchFilesMetadata,
+        staleTime: GET_FILES_METADATA_STALE_MS,
+    });
+    if ((!Array.isArray(filesMetadata) || filesMetadata.length === 0) && addresses.length > 0) {
+        await queryClient.removeQueries({ queryKey: filesMetadataQueryKey });
+        ({ filesMetadata } = await queryClient.fetchQuery({
+            queryKey: filesMetadataQueryKey,
+            queryFn: fetchFilesMetadata,
+            staleTime: GET_FILES_METADATA_STALE_MS,
+        }));
+    }
+    const filesRoot = BaseFileManager.getWorkingDir();
+    await BaseFileManager.createDirIfNotExists(filesRoot);
+    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('html'));
+    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('json'));
+    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('images'));
+    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('files'));
+    const excludedTransactions = await getExcludedTransactions();
+    const fromEas = parseTransactionIdsFromMetadata(filesMetadata ?? [], excludedTransactions);
+    const fromLocal = await collectTransactionIdsFromLocalMetadata();
+    const transactionIds = Array.from(new Set([...fromEas, ...fromLocal]));
+    await runBulkDownloadWithDedupe(transactionIds);
+};
+const downloadTransactionIdWithDedupe = async (transactionId) => {
+    if (!supportsOpfsFileDownloads() || !transactionId || transactionId.trim().length === 0) {
+        return false;
+    }
+    const normalizedTxId = normalizeArweaveTxId(transactionId);
+    if (!normalizedTxId) {
+        logger$3(`[download] not an Arweave transaction id: ${transactionId}`);
+        return false;
+    }
+    const existing = lazyDownloadInFlightByTransactionId.get(normalizedTxId);
+    if (existing) {
+        return existing;
+    }
+    const inFlight = (async () => {
+        try {
+            // No skipExisting: the caller found no local file, so a file on disk it could not see is
+            // written again and announced.
+            const ok = await downloadTransactionIds([normalizedTxId]);
+            return ok;
+        }
+        finally {
+            lazyDownloadInFlightByTransactionId.delete(normalizedTxId);
+        }
+    })();
+    lazyDownloadInFlightByTransactionId.set(normalizedTxId, inFlight);
+    return inFlight;
+};
+const scheduleBulkFilesDownloadFromEasSyncThrottled = throttle((addressesHint) => {
+    void downloadAllFilesBinaryRequestHandler(addressesHint).catch((error) => {
+        logger$3('[scheduleBulkFilesDownloadFromEasSync] failed', error);
+    });
+}, AUTO_BULK_DOWNLOAD_THROTTLE_MS, { leading: true, trailing: false });
+const scheduleBulkFilesDownloadFromEasSync = (addressesHint) => {
+    if (!supportsOpfsFileDownloads()) {
+        return;
+    }
+    scheduleBulkFilesDownloadFromEasSyncThrottled(addressesHint);
+};
+
+var download = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    downloadAllFilesBinaryRequestHandler: downloadAllFilesBinaryRequestHandler,
+    downloadTransactionIdWithDedupe: downloadTransactionIdWithDedupe,
+    scheduleBulkFilesDownloadFromEasSync: scheduleBulkFilesDownloadFromEasSync
+});
+
+const isFile = async (path) => {
+    try {
+        const fs = await BaseFileManager.getFs();
+        return (await fs.promises.stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * A file in `subdir` (relative to the files root) for a stored reference: the file of that exact
+ * name, else the first whose name contains one of `needles` (a downloaded file is named after its
+ * transaction id, sometimes with an extension). Folders (an image's size variants) don't count.
+ */
+async function findFileInDir(subdir, needles) {
+    const wanted = needles.filter((n) => !!n);
+    if (wanted.length === 0)
+        return undefined;
+    for (const needle of wanted) {
+        const exact = BaseFileManager.getFilesPath(subdir, needle);
+        if ((await BaseFileManager.pathExists(exact)) && (await isFile(exact)))
+            return exact;
+    }
+    const dirPath = BaseFileManager.getFilesPath(subdir);
+    if (!(await BaseFileManager.pathExists(dirPath)))
+        return undefined;
+    const fs = await BaseFileManager.getFs();
+    const path = BaseFileManager.getPathModule();
+    const names = await fs.promises.readdir(dirPath);
+    for (const needle of wanted) {
+        for (const name of names) {
+            if (!path.basename(name).includes(needle))
+                continue;
+            const candidate = BaseFileManager.getFilesPath(subdir, name);
+            if (await isFile(candidate))
+                return candidate;
+        }
+    }
+    return undefined;
+}
+
+var findFile = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    findFileInDir: findFileInDir
+});
+
+const logger$2 = debug('seedSdk:helpers:ensureImageLocal');
+/** Arweave transaction ids are 43 chars in the URL-safe base64 alphabet. */
+const ARWEAVE_TX_ID_RE = /^[a-z0-9_-]{43}$/i;
+const IMAGE_SIZES = [
+    ImageSize.EXTRA_SMALL,
+    ImageSize.SMALL,
+    ImageSize.MEDIUM,
+    ImageSize.LARGE,
+    ImageSize.EXTRA_LARGE,
+];
+const inFlightByKey = new Map();
+const normalizeArweaveTxIdForEnsure = (raw) => {
+    if (raw == null || raw === '')
+        return undefined;
+    const t = String(raw).trim();
+    if (ARWEAVE_TX_ID_RE.test(t))
+        return t;
+    const m = t.match(/^([a-z0-9_-]{43})(?:\.[^/]+)?$/i);
+    if (m)
+        return m[1];
+    const embedded = t.match(/[a-z0-9_-]{43}/gi);
+    if (embedded) {
+        for (const candidate of embedded) {
+            if (ARWEAVE_TX_ID_RE.test(candidate))
+                return candidate;
+        }
+    }
+    return undefined;
+};
+const closestImageSize = (width) => {
+    let best = ImageSize.EXTRA_SMALL;
+    let bestDist = Math.abs(best - width);
+    for (const size of IMAGE_SIZES) {
+        const dist = Math.abs(size - width);
+        if (dist < bestDist) {
+            best = size;
+            bestDist = dist;
+        }
+    }
+    return best;
+};
+const mapRequestedWidthsToImageSizes = (widths) => {
+    const requested = widths && widths.length > 0 ? widths : [ImageSize.EXTRA_SMALL];
+    const unique = new Set();
+    for (const w of requested) {
+        if (typeof w !== 'number' || !Number.isFinite(w) || w <= 0)
+            continue;
+        unique.add(closestImageSize(w));
+    }
+    if (unique.size === 0) {
+        unique.add(ImageSize.EXTRA_SMALL);
+    }
+    return Array.from(unique).sort((a, b) => a - b);
+};
+const getBasename = (filePath) => {
+    const path = BaseFileManager.getPathModule();
+    return path.basename(filePath);
+};
+const getBasenameWithoutExtension = (fileName) => {
+    const match = fileName.match(/^(.*[\/\\])?([^\/\\]+?)(\.[^.\/\\]*)?$/);
+    return match?.[2] ?? fileName;
+};
+const sizedVariantPath = (originalFilePath, size) => {
+    const path = BaseFileManager.getPathModule();
+    const dir = path.dirname(originalFilePath);
+    const base = getBasenameWithoutExtension(getBasename(originalFilePath));
+    return path.join(dir, String(size), `${base}.webp`);
+};
+const ensureKey = (txId, fileName, sizes) => {
+    const idPart = txId ?? fileName ?? '';
+    return `${idPart}|${sizes.join(',')}`;
+};
+const runEnsureImageLocal = async (params) => {
+    if (!supportsOpfsFileDownloads()) {
+        return { status: 'unsupported' };
+    }
+    const fileName = params.fileName?.trim() || undefined;
+    const txId = normalizeArweaveTxIdForEnsure(params.transactionId) ??
+        normalizeArweaveTxIdForEnsure(fileName);
+    if (!txId && !fileName) {
+        return { status: 'missing-id' };
+    }
+    const targetSizes = mapRequestedWidthsToImageSizes(params.widths);
+    const needles = [fileName, txId].filter((n) => typeof n === 'string' && n.length > 0);
+    try {
+        let filePath = await findFileInDir('images', needles);
+        if (!filePath && txId) {
+            await downloadTransactionIdWithDedupe(txId);
+            filePath = await findFileInDir('images', needles);
+        }
+        if (!filePath) {
+            return { status: 'failed' };
+        }
+        const createdWidths = [];
+        for (const size of targetSizes) {
+            const variantPath = sizedVariantPath(filePath, size);
+            const exists = await BaseFileManager.pathExists(variantPath);
+            if (exists)
+                continue;
+            await BaseFileManager.resizeImage({
+                filePath,
+                width: size,
+                height: size,
+            });
+            createdWidths.push(size);
+        }
+        return {
+            status: 'ready',
+            filePath,
+            createdWidths,
+        };
+    }
+    catch (error) {
+        logger$2('ensureImageLocal failed', error);
+        return { status: 'failed' };
+    }
+};
+/**
+ * Ensure an image original exists in OPFS (downloading from Arweave if needed)
+ * and create only the requested ImageSize variant(s) for that one file.
+ */
+const ensureImageLocal = async (params) => {
+    if (!supportsOpfsFileDownloads()) {
+        return { status: 'unsupported' };
+    }
+    const fileName = params.fileName?.trim() || undefined;
+    const txId = normalizeArweaveTxIdForEnsure(params.transactionId) ??
+        normalizeArweaveTxIdForEnsure(fileName);
+    if (!txId && !fileName) {
+        return { status: 'missing-id' };
+    }
+    const targetSizes = mapRequestedWidthsToImageSizes(params.widths);
+    const key = ensureKey(txId, fileName, targetSizes);
+    const existing = inFlightByKey.get(key);
+    if (existing) {
+        return existing;
+    }
+    const inFlight = (async () => {
+        try {
+            return await runEnsureImageLocal({
+                transactionId: txId,
+                fileName,
+                widths: targetSizes,
+            });
+        }
+        finally {
+            inFlightByKey.delete(key);
+        }
+    })();
+    inFlightByKey.set(key, inFlight);
+    return inFlight;
+};
+
+var ensureImageLocal$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    closestImageSize: closestImageSize,
+    ensureImageLocal: ensureImageLocal,
+    normalizeArweaveTxIdForEnsure: normalizeArweaveTxIdForEnsure
+});
+
+/**
+ * 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-Bf4kWKpH.js');
+        const _ns_0 = _mod_0.b5;
+        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 { isNode as $, AmbiguousModelError as A, getAllAddressesFromDb as B, loadNameMatchLevels as C, DEFAULT_TEXT_MAX_LENGTH as D, scheduleBulkFilesDownloadFromEasSync as E, isBrowser as F, emitAcrossTabs as G, findSeedRowsByUid as H, INTERNAL_SCHEMA_IDS as I, normalizeHexAddress as J, selectInBatches as K, nameMatchLevels as L, ModelPropertyDataTypes as M, getItemStoragePropertiesForModel as N, resolveItemModelFileId as O, Property as P, EAS_SEED_DATA_SYNCED_TO_DB_EVENT as Q, getExtensionForMimeType as R, SEED_PROTOCOL_SCHEMA_NAME as S, THtmlEmbeddedDataUriPolicy as T, INTERNAL_STORAGE_MODEL_FILE_IDS as U, resolveUploadMimeType as V, getContentSha256 as W, buildArweaveContentTags as X, getItemStorageSubdir as Y, ZERO_BYTES32 as Z, getItemStorageLocalFileName as _, TProperty as a, TAB_ID as a$, INTERNAL_PROPERTY_NAMES as a0, defaultAttestationData as a1, definitionOnlyFields as a2, persistDefinitionFields as a3, getPropertyDefinition as a4, propertyDefinitionFromRow as a5, setCachedPropertyRefresher as a6, convertTxIdToImage as a7, ADDRESSES_PERSISTED_EVENT as a8, CONTENT_SHA256_TAG as a9, sniffMimeType as aA, notifyFilesWrittenOutsideCache as aB, createSessionObjectUrl as aC, withSeedDbLock as aD, countDbStatements as aE, startChangeFeed as aF, countLiveQueryRuns as aG, writeModelToDb as aH, writePropertyToDb as aI, currentNameMatchLevels as aJ, renameModelInDb as aK, postTabMessage as aL, onTabMessage as aM, listenForOtherTabsEvents as aN, startTabCoordination as aO, isTestOrSeedDev as aP, insertModelStubs as aQ, warnOnInvalidNameMatch as aR, refreshCachedProperties as aS, tryWithTabLock as aT, notifyFileSaved as aU, ClientManagerEvents as aV, getWatchedAddressesFromDb as aW, getOwnedAddressesFromDb as aX, CLIENT_NOT_INITIALIZED as aY, registerClientActor as aZ, PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP as a_, CONTENT_TYPE_TAG as aa, ClientManagerState as ab, FILES_CHANGED_EVENT as ac, ImageSize as ad, LOCAL_COPIES_REMOVED_EVENT as ae, MachineIds as af, SeedModels as ag, TabLockTimeoutError as ah, VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA as ai, closestImageSize as aj, contentSha256TagMatches as ak, ensureImageLocal as al, getAddressesForItemsFilter as am, isChangeFeedRunning as an, isClientReadySnapshot as ao, isLeaderTab as ap, normalizeAddressConfig as aq, normalizeAddressList as ar, normalizeArweaveTxIdForEnsure as as, parseAddressesPersistedPayload as at, watchEntityChanges as au, watchEntityRows as av, whenDbReady as aw, whenLeaderTab as ax, withDbTabLock as ay, MIME_TO_EXTENSION as az, TPropertyConstructor as b, getModelSchemaName as b0, normalizeMimeType as b1, findFileInDir as b2, getStorageSubdirForDataType as b3, timingMarks as b4, withTabLock as b5, revokeSessionObjectUrl as b6, timed as b7, isSessionObjectUrl as b8, timingNow as b9, timingSince as ba, timingLogger as bb, timedDb as bc, findSeedRow$1 as bd, resolveModelRecord$1 as be, propertyDefinition as bf, definitions as bg, db as bh, generateId$1 as bi, download as bj, findFile as bk, ensureImageLocal$1 as bl, tabEvents as bm, TPropertyDataType as c, TPropertyDefs as d, TStorageType as e, TValidationRules as f, normalizePropertyRecordSchema as g, eventEmitter as h, isDataType as i, findSeedRow as j, getPropertyDefinitions as k, resolveModelRecordByNameOrType as l, generateId as m, normalizeDataType as n, addSchemaToDb as o, isInternalSchema as p, inDefinitionsTransaction as q, resolveModelRecord as r, isClientReady as s, broadcastSchemasInvalidate as t, upsertSchemaRow as u, INTERNAL_DATA_TYPES as v, writeInBatches as w, normalizePublisher as x, chunkValues as y, rowsPerInsert as z };
+//# sourceMappingURL=tabEvents-CaVmngqr.js.map