@seedprotocol/sdk 0.7.7 → 0.7.8-next.1066.gac32194

package/dist/{ClientManager-2GtDWHq6.js → ClientManager-Dcju5x4k.js}

@@ -1,10 +1,10 @@
 import { startCase, isEqual } from 'lodash-es';
-import { B as BaseDb, o as easSyncProcesses, I as eventEmitter, ac as isBrowser, a1 as isNode, aE as normalizeAddressConfig, aS as isTestOrSeedDev, j as appState, aT as downloadAllFilesRequestHandler, aU as downloadAllFilesBinaryRequestHandler, h as BaseFileManager, ag as loadNameMatchLevels, t as models$1, s as modelUids, C as seeds, aF as normalizeAddressList, A as schemas, aP as loadModelsFromDbForSchema, aM as addSchemaToDb, aJ as isInternalSchema, ai as generateId, aR as clearNameMatchLevels, aV as warnOnInvalidNameMatch, aW as INTERNAL_SCHEMA_IDS, aX as linkModelToSchema, n as normalizeDataType, ab as easPropertyNameForPublish, au as SEED_PROTOCOL_SCHEMA_NAME, r as modelSchemas, m as metadata$1, v as properties, L as resolveItemModelFileId, F as versions, ae as normalizePublisher, p as htmlEmbeddedImageCoPublish, k as arweaveL1FinalizeJobs, z as publishProcesses, aY as getWatchedAddressesFromDb, aZ as getOwnedAddressesFromDb, a_ as CLIENT_NOT_INITIALIZED } from './index-DpgQMIRq.js';
+import { F as BaseDb, l as easSyncProcesses, I as eventEmitter, am as isBrowser, a2 as isNode, aG as normalizeAddressConfig, aU as isTestOrSeedDev, h as appState, aV as downloadAllFilesRequestHandler, aW as downloadAllFilesBinaryRequestHandler, N as BaseFileManager, af as loadNameMatchLevels, s as models$1, r as modelUids, B as seeds, aH as normalizeAddressList, A as schemas, aR as loadModelsFromDbForSchema, aO as addSchemaToDb, aL as isInternalSchema, ai as generateId, aT as clearNameMatchLevels, aX as warnOnInvalidNameMatch, aY as INTERNAL_SCHEMA_IDS, aZ as linkModelToSchema, n as normalizeDataType, ac as easPropertyNameForPublish, aw as SEED_PROTOCOL_SCHEMA_NAME, q as modelSchemas, a0 as getItemStorageSubdir, a1 as getItemStorageLocalFileName, m as metadata$1, v as properties, L as resolveItemModelFileId, E as versions, ad as normalizePublisher, u as pendingWrites, a_ as getMetadataPropertyNamesForQuery, o as htmlEmbeddedImageCoPublish, j as arweaveL1FinalizeJobs, z as publishProcesses, a$ as getWatchedAddressesFromDb, b0 as getOwnedAddressesFromDb, b1 as CLIENT_NOT_INITIALIZED } from './index-CI0NFf4B.js';
 import debug from 'debug';
 import { createActor, setup, assign, fromPromise, fromCallback, waitFor } from 'xstate';
-import { u as MachineIds, a0 as ClientManagerEvents, a1 as withLockedItemStorageRow, a2 as getItemStorageFilePath, a3 as writeItemStorageFile, e as compareMetadataRowsLatestFirst, w as writeInBatches, a4 as resolvePublisherFromSeedRow, C as ClientManagerState, G as isLocalUnsealedDraft, s as selectInBatches, I as Item } from './Item-D6j0IvBP.js';
-import { eq, inArray, and, isNotNull, ne, desc, countDistinct, isNull, or, sql, like } from 'drizzle-orm';
-import { a as withDbTabLock, i as isLeaderTab, c as postTabMessage, o as onTabMessage, w as whenLeaderTab, l as listenForOtherTabsEvents, s as startTabCoordination, b as withSeedDbLock, e as emitAcrossTabs, A as ADDRESSES_PERSISTED_EVENT, p as parseAddressesPersistedPayload, L as LOCAL_COPIES_REMOVED_EVENT } from './tabEvents-DksXwk3X.js';
+import { Y as MachineIds, an as ClientManagerEvents, D as compareMetadataRowsLatestFirst, u as writeInBatches, ao as resolvePublisherFromSeedRow, ap as getSeedPublisher, aq as propertyNameVariants, M as METADATA_LATEST_FIRST_ORDER_SQL, L as selectInBatches, ar as createSeed, as as createMetadata, at as updateItemPropertyValue, s as registerOutboxApplier, q as outboxOpValue, i as OutboxOpDeferredError, t as startOutbox, j as OutboxOpFailedError, z as OwnershipError, B as isItemOwned, G as parseListPropertyValueFromStorage, X as ClientManagerState, a5 as isLocalUnsealedDraft, I as Item } from './Item-DZfNz7xl.js';
+import { eq, inArray, and, isNotNull, ne, desc, countDistinct, isNull, or, sql, like, lt } from 'drizzle-orm';
+import { a as withDbTabLock, i as isLeaderTab, d as postTabMessage, o as onTabMessage, w as whenLeaderTab, l as listenForOtherTabsEvents, s as startTabCoordination, b as withSeedDbLock, e as emitAcrossTabs, A as ADDRESSES_PERSISTED_EVENT, t as tryWithTabLock, f as withTabLock, g as notifyFileSaved, p as parseAddressesPersistedPayload, L as LOCAL_COPIES_REMOVED_EVENT } from './tabEvents-CIlzHSKZ.js';
 import { seedGatewayConfigFromSeedConfig, setPreferredArweaveReadBaseUrls, resolveSeedGatewayEndpoints, setResolvedSeedGatewayEndpoints, BaseArweaveClient, ensureReadGatewaySelected, DEFAULT_ARWEAVE_HOST } from '@seedprotocol/arweave';
 import { configureEasReadChain, easName, BaseQueryClient, BaseEasClient, GET_SCHEMAS, whenEasReadChainSettled, getEasReadChainId, DEFAULT_EAS_CHAIN_ID, isEasReadChainConfigured, isPlaceholderUid, localNamesInBestMatchTier, isValidEasAttestationUid } from '@seedprotocol/eas';
 import 'pluralize';
@@ -212,7 +212,7 @@ function toRunSyncArg(options) {
     return undefined;
 }
 const runEasSync = fromPromise(async ({ input, }) => {
-    const { runSyncFromEas } = await import('./syncDbWithEas-CAOlw3i-.js');
+    const { runSyncFromEas } = await import('./syncDbWithEas-BZ6AI-IC.js');
     // Sync checks for rows and then inserts the rest (no unique index on uids), so syncs in
     // different tabs take turns. A sync can run for minutes, so wait without a timeout.
     await withDbTabLock('eas-sync', async () => {
@@ -590,7 +590,7 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
         if (!config) {
             throw new Error('client.init requires a config');
         }
-        const _mod_0 = await import('./configurePlatform-Bbpw_R4y.js');
+        const _mod_0 = await import('./configurePlatform-CtA7fydC.js');
         const _ns_0 = _mod_0.a;
         const { configurePlatform } = _ns_0;
         if (isBrowser()) {
@@ -1141,6 +1141,29 @@ async function assertLocalDbChain() {
     configureEasReadChain('localDb', { chainId: localChainId ?? chainId });
 }
 
+/** The addresses this tab last announced, as a comparable key. Cleared when the client stops. */
+let lastAnnounced;
+const addressKey = ({ owned, watched }) => {
+    const norm = (list) => [...new Set(list.map((a) => a.trim().toLowerCase()))].sort();
+    return JSON.stringify({ owned: norm(owned), watched: norm(watched) });
+};
+/**
+ * Emits ADDRESSES_PERSISTED_EVENT when the stored addresses differ from the ones this tab last
+ * announced. Listeners re-key their queries on it (React's `useItems` reloads its list from
+ * scratch), and wallets save the same addresses on every connect.
+ */
+function announceAddressesPersisted(payload) {
+    const key = addressKey(payload);
+    if (key === lastAnnounced)
+        return;
+    lastAnnounced = key;
+    emitAcrossTabs(ADDRESSES_PERSISTED_EVENT, payload);
+}
+/** Forgets the last announcement, so the next client's first save is announced. */
+function resetAddressesPersistedAnnouncement() {
+    lastAnnounced = undefined;
+}
+
 const logger$9 = debug('seedSdk:client:actors:saveConfig');
 let warnedKeptStoredAddresses = false;
 /**
@@ -1179,7 +1202,7 @@ async function persistInitAddresses(appDb, { addresses, addressesProvided, owned
         .onConflictDoUpdate({ target: appState.key, set: { value } });
     // Same event setAddresses emits, so listeners (e.g. React's session context) also see the
     // addresses init saved. Their sync is init's startup sync, which reads them from the DB.
-    emitAcrossTabs(ADDRESSES_PERSISTED_EVENT, { owned, watched });
+    announceAddressesPersisted({ owned, watched });
 }
 const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
     logger$9('saveConfig starting');
@@ -1980,8 +2003,8 @@ function getRefValueType(prop) {
  * @returns Promise that resolves when properties are found, or rejects if not found after max retries
  */
 const verifyPropertiesPersisted = async (db, modelId, modelName, maxRetries = 10, retryDelay = 100) => {
-    const _mod_1 = await import('./index-DpgQMIRq.js');
-    const _ns_1 = _mod_1.bd;
+    const _mod_1 = await import('./index-CI0NFf4B.js');
+    const _ns_1 = _mod_1.bh;
     const modelSchemaMod = _ns_1;
     const { properties: propertiesTable } = modelSchemaMod;
     const drizzleMod = await import('drizzle-orm');
@@ -2387,8 +2410,8 @@ async function importSchema(importFilePathOrContents, version, options) {
         // Check DB for existing schema by name+version (same as minimal path)
         const db = BaseDb.getAppDb();
         if (db) {
-            const _mod_2 = await import('./index-DpgQMIRq.js');
-            const _ns_2 = _mod_2.bf;
+            const _mod_2 = await import('./index-CI0NFf4B.js');
+            const _ns_2 = _mod_2.bj;
             const schemaSchemaMod = _ns_2;
             const { schemas: schemasTable } = schemaSchemaMod;
             const drizzleMod = await import('drizzle-orm');
@@ -2479,8 +2502,8 @@ async function importSchema(importFilePathOrContents, version, options) {
         // For minimal imports: check DB for existing schema before creating new file
         const db = BaseDb.getAppDb();
         if (db) {
-            const _mod_3 = await import('./index-DpgQMIRq.js');
-            const _ns_3 = _mod_3.bf;
+            const _mod_3 = await import('./index-CI0NFf4B.js');
+            const _ns_3 = _mod_3.bj;
             const schemaSchemaMod = _ns_3;
             const { schemas: schemasTable } = schemaSchemaMod;
             const drizzleMod = await import('drizzle-orm');
@@ -2662,8 +2685,8 @@ async function importSchema(importFilePathOrContents, version, options) {
             updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
         };
         // Use dynamic import to break circular dependency
-        const _mod_4 = await import('./index-DpgQMIRq.js');
-        const _ns_4 = _mod_4.bi;
+        const _mod_4 = await import('./index-CI0NFf4B.js');
+        const _ns_4 = _mod_4.bm;
         const dbMod = _ns_4;
         const { addSchemaToDb, addModelsToDb } = dbMod;
         // Try to add schema and models to database if database is available
@@ -2684,12 +2707,12 @@ async function importSchema(importFilePathOrContents, version, options) {
                     });
                     // Verify expected models are linked (single attempt - addModelsToDb already confirmed)
                     const expectedModelNames = Object.keys(schemaFile.models || {});
-                    const _mod_5 = await import('./index-DpgQMIRq.js');
-                    const _ns_5 = _mod_5.bg;
+                    const _mod_5 = await import('./index-CI0NFf4B.js');
+                    const _ns_5 = _mod_5.bk;
                     const modelSchemaSchemaMod = _ns_5;
                     const { modelSchemas } = modelSchemaSchemaMod;
-                    const _mod_6 = await import('./index-DpgQMIRq.js');
-                    const _ns_6 = _mod_6.bd;
+                    const _mod_6 = await import('./index-CI0NFf4B.js');
+                    const _ns_6 = _mod_6.bh;
                     const modelSchemaMod = _ns_6;
                     const { models: modelsTable } = modelSchemaMod;
                     const drizzleMod = await import('drizzle-orm');
@@ -2890,8 +2913,8 @@ async function applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, prope
         createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
         updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
     };
-    const _mod_7 = await import('./index-DpgQMIRq.js');
-    const _ns_7 = _mod_7.bi;
+    const _mod_7 = await import('./index-CI0NFf4B.js');
+    const _ns_7 = _mod_7.bm;
     const dbMod = _ns_7;
     const { addSchemaToDb, addModelsToDb } = dbMod;
     const db = BaseDb.getAppDb();
@@ -2922,8 +2945,8 @@ async function applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, prope
  * draft (its edits aren't the app's to undo) or a newer version than schemaFile.
  */
 async function getModelsDroppedFromStoredSchema(db, schemaFile) {
-    const _mod_8 = await import('./index-DpgQMIRq.js');
-    const _ns_8 = _mod_8.bf;
+    const _mod_8 = await import('./index-CI0NFf4B.js');
+    const _ns_8 = _mod_8.bj;
     const { schemas: schemasTable } = _ns_8;
     const { eq } = await import('drizzle-orm');
     const rows = await db
@@ -2950,11 +2973,11 @@ async function getModelsDroppedFromStoredSchema(db, schemaFile) {
 }
 /** Delete the model_schemas rows linking the named models to the schema. The models and their items stay. */
 async function unlinkModelsFromSchema(db, schemaId, modelNames) {
-    const _mod_9 = await import('./index-DpgQMIRq.js');
-    const _ns_9 = _mod_9.bg;
+    const _mod_9 = await import('./index-CI0NFf4B.js');
+    const _ns_9 = _mod_9.bk;
     const { modelSchemas } = _ns_9;
-    const _mod_10 = await import('./index-DpgQMIRq.js');
-    const _ns_10 = _mod_10.bd;
+    const _mod_10 = await import('./index-CI0NFf4B.js');
+    const _ns_10 = _mod_10.bh;
     const { models: modelsTable } = _ns_10;
     const { and, eq, inArray } = await import('drizzle-orm');
     const links = await db
@@ -3116,12 +3139,12 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                 ]));
                 const { schemaRecord } = await applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, propertyFileIds, propertyDefinitions).finally(rowsWritten.settle);
                 // Query the database to get model IDs that were just created
-                const _mod_11 = await import('./index-DpgQMIRq.js');
-                const _ns_11 = _mod_11.bg;
+                const _mod_11 = await import('./index-CI0NFf4B.js');
+                const _ns_11 = _mod_11.bk;
                 const modelSchemaSchemaMod = _ns_11;
                 const { modelSchemas } = modelSchemaSchemaMod;
-                const _mod_12 = await import('./index-DpgQMIRq.js');
-                const _ns_12 = _mod_12.bd;
+                const _mod_12 = await import('./index-CI0NFf4B.js');
+                const _ns_12 = _mod_12.bh;
                 const modelSchemaMod = _ns_12;
                 const { models: modelsTable } = modelSchemaMod;
                 const drizzleMod = await import('drizzle-orm');
@@ -3186,8 +3209,8 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                 // After properties are created (file path), ensure schemaFile has the correct IDs from database
                 // Query the database to get the actual schemaFileId values that were used
                 // This ensures schemaData matches what's actually in the database
-                const _mod_13 = await import('./index-DpgQMIRq.js');
-                const _ns_13 = _mod_13.bd;
+                const _mod_13 = await import('./index-CI0NFf4B.js');
+                const _ns_13 = _mod_13.bh;
                 const modelSchemaMod2 = _ns_13;
                 const { properties: propertiesTable } = modelSchemaMod2;
                 let schemaFileUpdated = false;
@@ -3222,8 +3245,8 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                 // This is important even if nothing changed, to ensure consistency
                 const updatedSchemaData = JSON.stringify(schemaFile, null, 2);
                 // Update the schema record in the database with current schemaData
-                const _mod_14 = await import('./index-DpgQMIRq.js');
-                const _ns_14 = _mod_14.bf;
+                const _mod_14 = await import('./index-CI0NFf4B.js');
+                const _ns_14 = _mod_14.bj;
                 const schemaSchemaMod = _ns_14;
                 const { schemas: schemasTable } = schemaSchemaMod;
                 await db
@@ -3349,8 +3372,8 @@ const createRowsWrittenSignal = () => {
 const createModelFromJson = async (modelName, modelDef, schemaName, modelFileId, // Optional modelFileId from JSON file
 propertyFileIds, // Optional map of property names to their file IDs from the JSON file
 persistedBy) => {
-    const _mod_15 = await import('./errors-KM-yq2MD.js');
-    const _ns_15 = _mod_15.j;
+    const _mod_15 = await import('./errors-BGk_IJO5.js');
+    const _ns_15 = _mod_15.i;
     const modelMod = _ns_15;
     const { Model } = modelMod;
     const convertedProperties = jsonPropertiesToSchemaProperties(modelName, modelDef, propertyFileIds);
@@ -3363,12 +3386,15 @@ persistedBy) => {
     else {
         logger$7(`Warning: Creating schema model "${modelName}" without modelFileId - it will be renamed if duplicates exist`);
     }
+    // The schema holds its models once (Model.takeSchemaHold); a model it already holds takes no more.
+    const schemaHold = Model.takeSchemaHold(modelFileId);
     const modelInstance = Model.create(modelName, schemaName, {
         modelFileId: modelFileId, // Pass modelFileId (preferred) as id (schemaFileId) from JSON file
         id: modelFileId, // Also pass as id for backward compatibility
         properties: convertedProperties,
         waitForReady: false,
         persistedBy,
+        ...(!schemaHold && { hold: false }),
     });
     return modelInstance;
 };
@@ -3956,6 +3982,90 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
     };
 });
 
+/** Absolute path of the file {@link writeItemStorageFile} writes for `target`. */
+const getItemStorageFilePath = (target) => BaseFileManager.getFilesPath(getItemStorageSubdir(target.localStorageDir), target.fileName || getItemStorageLocalFileName(target.seedId, target.filenameSuffix));
+/**
+ * Write an ItemStorage property's content to its local file, where saveItemStorage, reads, publish
+ * (resolveItemStorageChildFile) and download all look for it. Returns what the metadata row records:
+ * `refResolvedValue` (the file name) and `localStorageDir` (with a leading slash).
+ *
+ * Callers that also update the file's metadata row hold {@link withItemStorageFileLock} around
+ * both, so another writer of the same file can't land in between.
+ */
+const writeItemStorageFile = async (target, content) => {
+    const dir = getItemStorageSubdir(target.localStorageDir);
+    const fileName = target.fileName || getItemStorageLocalFileName(target.seedId, target.filenameSuffix);
+    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath(dir));
+    const filePath = BaseFileManager.getFilesPath(dir, fileName);
+    await BaseFileManager.saveFile(filePath, content);
+    return { fileName, filePath, localStorageDir: target.localStorageDir || `/${dir}` };
+};
+/**
+ * Lock name for one ItemStorage file: `seed:item-storage:<absolute file path>`. The path starts
+ * with the files root, which also names the database (`<filesDir>/db/seed.db`), so the name is
+ * per database as well as per file.
+ */
+const itemStorageFileLockName = (filePath) => `seed:item-storage:${filePath}`;
+/**
+ * Runs `fn` holding the lock of one ItemStorage file, across tabs (Web Locks) and within this JS
+ * realm (an in-process queue where Web Locks are missing, e.g. Node < 24.5; see `withTabLock`).
+ *
+ * Writers of a local draft's file (saveItemStorage, convertVerbatimItemStorageRow, createNewItem)
+ * hold it across "read the row → write the file → update the row", so the file and the row end
+ * with the same writer's content. See docs/MULTI_TAB.md.
+ *
+ * Lock ordering: this lock is always the innermost. It may be taken while holding a broader lock
+ * (`seed:item-storage-migration:<db>`, `seed:publish:<seedLocalId>`), never the other way round,
+ * and no other lock (nor a second file lock) is requested while it is held. Keep the section to
+ * local DB and file I/O: no network. Not re-entrant.
+ */
+function withItemStorageFileLock(filePath, fn) {
+    return withTabLock(itemStorageFileLockName(filePath), fn);
+}
+/** {@link withItemStorageFileLock} only if the lock is free now (see `tryWithTabLock`). */
+function tryWithItemStorageFileLock(filePath, fn) {
+    return tryWithTabLock(itemStorageFileLockName(filePath), fn);
+}
+/** Lock attempts before giving up when the row's target file keeps changing under us. */
+const ROW_LOCK_ATTEMPTS = 3;
+const readRow = async (localId) => {
+    const rows = await BaseDb.getAppDb()
+        .select()
+        .from(metadata$1)
+        .where(eq(metadata$1.localId, localId))
+        .limit(1);
+    return rows[0];
+};
+/**
+ * Runs `fn` with a fresh read of metadata row `localId`, holding the lock of the file that row's
+ * content goes to. `fileOf` names that file (absolute path) for a row, or returns undefined when
+ * there is nothing to write (then `fn` isn't called and the result is undefined).
+ *
+ * The file depends on the row, so the row is read once to pick the lock and again once it is held;
+ * if the row now points at another file (another writer changed it meanwhile), the lock is
+ * released and taken again for that file.
+ */
+async function withLockedItemStorageRow(localId, fileOf, fn) {
+    for (let attempt = 0; attempt < ROW_LOCK_ATTEMPTS; attempt++) {
+        const row = await readRow(localId);
+        const filePath = row && fileOf(row);
+        if (!filePath)
+            return undefined;
+        const outcome = await withItemStorageFileLock(filePath, async () => {
+            const fresh = await readRow(localId);
+            const freshPath = fresh && fileOf(fresh);
+            if (!freshPath)
+                return { done: true, value: undefined };
+            if (freshPath !== filePath)
+                return { done: false };
+            return { done: true, value: await fn(fresh, filePath) };
+        });
+        if (outcome.done)
+            return outcome.value;
+    }
+    throw new Error(`ItemStorage file of metadata row ${localId} kept changing; not written`);
+}
+
 /**
  * A legacy ItemStorage draft row: a local edit (no attestation uid, not derived from one) that holds
  * the content itself in property_value, with no file reference. Item.create / createNewItem stored
@@ -4594,6 +4704,584 @@ function startCanonicalizeModelTypes() {
     });
 }
 
+const createVersion = async ({ seedLocalId, seedUid, seedType, uid, }, options = {}) => {
+    const appDb = options.db ?? BaseDb.getAppDb();
+    const newVersionLocalId = generateId();
+    // A version belongs to its seed's wallet (none yet for a draft made with no wallet connected).
+    const publisher = await getSeedPublisher(seedLocalId, appDb);
+    await appDb.insert(versions).values({
+        localId: newVersionLocalId,
+        createdAt: Date.now(),
+        seedLocalId,
+        seedUid: seedUid ?? null,
+        seedType,
+        uid: uid ?? null,
+        ...(publisher && { publisher }),
+    });
+    return newVersionLocalId;
+};
+
+/**
+ * Conflicts between a local edit and a value sync wrote after it (ADR 0019). The local edit wins:
+ * a pending edit applies over the synced row as a new draft, and a draft already written stays the
+ * newest row. The conflict is recorded on an op row, so the app can show both values and let the
+ * user pick.
+ */
+/**
+ * The conflict a `set` op meets when it applies: sync wrote an attested row for the property after
+ * the edit was made, and its value differs from both the value the edit was made against and the
+ * edit's own. A row with the base row's uid (the same attestation synced again) is not a conflict,
+ * nor is a published row carrying the base value (a publish of the edit's base). Reads through `db`
+ * (the op's transaction).
+ */
+async function findSetConflict(op, value, db) {
+    if (!op.propertyName)
+        return null;
+    const names = getMetadataPropertyNamesForQuery(op.propertyName, value.dataType, value.refValueType);
+    const [newest] = await db
+        .select({
+        localId: metadata$1.localId,
+        uid: metadata$1.uid,
+        propertyValue: metadata$1.propertyValue,
+        createdAt: metadata$1.createdAt,
+    })
+        .from(metadata$1)
+        .where(and(eq(metadata$1.seedLocalId, op.seedLocalId), inArray(metadata$1.propertyName, names)))
+        .orderBy(sql.raw(METADATA_LATEST_FIRST_ORDER_SQL))
+        .limit(1);
+    if (!newest?.uid || newest.localId === op.baseRowId)
+        return null;
+    const [base] = op.baseRowId
+        ? await db
+            .select({ uid: metadata$1.uid, propertyValue: metadata$1.propertyValue })
+            .from(metadata$1)
+            .where(eq(metadata$1.localId, op.baseRowId))
+            .limit(1)
+        : [];
+    if (base?.uid && base.uid === newest.uid)
+        return null;
+    // With no base row, only a row written after the edit counts: an older one was there to see
+    if (!base && (newest.createdAt ?? 0) <= op.createdAt)
+        return null;
+    const baseValue = base?.propertyValue ?? null;
+    const remoteValue = newest.propertyValue ?? null;
+    if (remoteValue === baseValue || remoteValue === value.newValue)
+        return null;
+    return {
+        seedLocalId: op.seedLocalId,
+        propertyName: op.propertyName,
+        baseValue,
+        remoteValue,
+        localValue: value.newValue,
+        remoteUid: newest.uid,
+        opId: op.opId,
+    };
+}
+/**
+ * Records `conflict` on the op that met it, and clears the property's earlier conflicts: a newer
+ * local edit settles them (it was made with the synced value in view, or overrides it again).
+ */
+async function recordPropertyEdit(op, conflict, db) {
+    if (!op.propertyName)
+        return;
+    await db
+        .update(pendingWrites)
+        .set({ conflictResolvedAt: Date.now() })
+        .where(and(eq(pendingWrites.seedLocalId, op.seedLocalId), eq(pendingWrites.propertyName, op.propertyName), lt(pendingWrites.id, op.id), isNotNull(pendingWrites.conflict), isNull(pendingWrites.conflictResolvedAt)));
+    if (conflict) {
+        await db.update(pendingWrites).set({ conflict: JSON.stringify(conflict) }).where(eq(pendingWrites.opId, op.opId));
+    }
+}
+const unresolved = (seedLocalId) => and(eq(pendingWrites.status, 'applied'), eq(pendingWrites.seedLocalId, seedLocalId), isNotNull(pendingWrites.conflict), isNull(pendingWrites.conflictResolvedAt));
+const parse = (row) => {
+    try {
+        return row.conflict ? JSON.parse(row.conflict) : null;
+    }
+    catch {
+        return null;
+    }
+};
+/** The item's unresolved conflicts, the newest per property. */
+async function getItemConflicts(seedLocalId) {
+    const db = BaseDb.getAppDb();
+    if (!db || !seedLocalId)
+        return [];
+    const rows = await db
+        .select({ propertyName: pendingWrites.propertyName, conflict: pendingWrites.conflict })
+        .from(pendingWrites)
+        .where(unresolved(seedLocalId))
+        .orderBy(desc(pendingWrites.id));
+    const seen = new Set();
+    const conflicts = [];
+    for (const row of rows) {
+        if (!row.propertyName || seen.has(row.propertyName))
+            continue;
+        seen.add(row.propertyName);
+        const conflict = parse(row);
+        if (conflict)
+            conflicts.push(conflict);
+    }
+    return conflicts;
+}
+/** The property's unresolved conflict, if it has one. */
+async function getPropertyConflict(seedLocalId, propertyName) {
+    if (!seedLocalId || !propertyName)
+        return null;
+    const db = BaseDb.getAppDb();
+    if (!db)
+        return null;
+    const [row] = await db
+        .select({ conflict: pendingWrites.conflict })
+        .from(pendingWrites)
+        .where(and(unresolved(seedLocalId), inArray(pendingWrites.propertyName, propertyNameVariants(propertyName))))
+        .orderBy(desc(pendingWrites.id))
+        .limit(1);
+    return row ? parse(row) : null;
+}
+/** Marks the property's conflicts resolved. */
+async function markPropertyConflictsResolved(seedLocalId, propertyName) {
+    const db = BaseDb.getAppDb();
+    if (!db)
+        return;
+    await db
+        .update(pendingWrites)
+        .set({ conflictResolvedAt: Date.now() })
+        .where(and(unresolved(seedLocalId), inArray(pendingWrites.propertyName, propertyNameVariants(propertyName))));
+}
+/**
+ * The conflict rule for rows sync just inserted (`synced`) over a local draft already written: the
+ * draft stays the property's value. When a synced row is newer than the draft, the draft's time is
+ * moved just past it (readers take the newest row). A conflict is recorded, on an `applied` op row
+ * of its own, when the synced value differs from both the draft's and the attested value the draft
+ * replaced. Properties with a pending value op are left to the drainer, which applies the same rule.
+ */
+async function keepLocalDraftsOverSyncedRows(synced) {
+    const db = BaseDb.getAppDb();
+    if (!db)
+        return;
+    const live = synced.filter((row) => row.seedLocalId && row.propertyName && row.uid && row.revokedAt == null);
+    if (live.length === 0)
+        return;
+    const seedIds = [...new Set(live.map((row) => row.seedLocalId))];
+    const candidates = await selectInBatches(seedIds, (chunk) => db
+        .select()
+        .from(metadata$1)
+        .where(and(inArray(metadata$1.seedLocalId, chunk), isNull(metadata$1.derivedFromUid), isNull(metadata$1.revokedAt))));
+    const drafts = candidates.filter((row) => isPlaceholderUid(row.uid));
+    if (drafts.length === 0)
+        return;
+    const syncedIds = new Set(live.map((row) => row.localId ?? ''));
+    for (const draft of drafts) {
+        const key = (row) => row.seedLocalId === draft.seedLocalId && row.propertyName === draft.propertyName;
+        const remote = live
+            .filter(key)
+            .sort((a, b) => (b.attestationCreatedAt ?? 0) - (a.attestationCreatedAt ?? 0))[0];
+        if (!remote || !draft.localId || !draft.seedLocalId || !draft.propertyName)
+            continue;
+        const [pending] = await db
+            .select({ id: pendingWrites.id })
+            .from(pendingWrites)
+            .where(and(eq(pendingWrites.seedLocalId, draft.seedLocalId), eq(pendingWrites.propertyName, draft.propertyName), eq(pendingWrites.status, 'pending')))
+            .limit(1);
+        if (pending)
+            continue;
+        const now = Date.now();
+        const remoteAt = remote.attestationCreatedAt ?? 0;
+        if (remoteAt >= (draft.createdAt ?? 0)) {
+            await db
+                .update(metadata$1)
+                .set({ createdAt: remoteAt + 1, updatedAt: now })
+                .where(eq(metadata$1.localId, draft.localId));
+        }
+        // The attested value the draft replaced: the newest attested row that sync didn't just write
+        const base = candidates
+            .filter((row) => key(row) && !isPlaceholderUid(row.uid) && !syncedIds.has(row.localId ?? ''))
+            .sort((a, b) => (b.attestationCreatedAt ?? 0) - (a.attestationCreatedAt ?? 0))[0];
+        const baseValue = base?.propertyValue ?? null;
+        const remoteValue = remote.propertyValue ?? null;
+        const localValue = draft.propertyValue ?? null;
+        if (remoteValue === localValue || remoteValue === baseValue)
+            continue;
+        const opId = generateId();
+        const conflict = {
+            seedLocalId: draft.seedLocalId,
+            propertyName: draft.propertyName,
+            baseValue,
+            remoteValue,
+            localValue,
+            remoteUid: remote.uid,
+            opId,
+        };
+        await db.insert(pendingWrites).values({
+            opId,
+            seedLocalId: draft.seedLocalId,
+            propertyName: draft.propertyName,
+            kind: 'set',
+            value: JSON.stringify({ newValue: localValue }),
+            baseRowId: draft.localId,
+            createdAt: now,
+            status: 'applied',
+            appliedAt: now,
+            conflict: JSON.stringify(conflict),
+        });
+        eventEmitter.emit('itemProperty.conflict', conflict);
+    }
+}
+
+var conflicts = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    findSetConflict: findSetConflict,
+    getItemConflicts: getItemConflicts,
+    getPropertyConflict: getPropertyConflict,
+    keepLocalDraftsOverSyncedRows: keepLocalDraftsOverSyncedRows,
+    markPropertyConflictsResolved: markPropertyConflictsResolved,
+    recordPropertyEdit: recordPropertyEdit
+});
+
+/**
+ * The appliers for item ops (ADR 0019). Every tab registers them at init: the leader applies ops
+ * that other tabs appended.
+ */
+/**
+ * Writes a storage value's rows on `db`. The property's row is looked up here, on `db`, rather than
+ * taken from the edit: two quick edits of a property that had no row would otherwise both create one.
+ */
+async function applyStorageValue(seedLocalId, propertyName, value, db) {
+    const { storageSeed } = value;
+    // The item's publisher as it is now: a draft claimed while the op waited passes it on
+    const parentPublisher = await getSeedPublisher(seedLocalId, db);
+    await createSeed({ type: storageSeed.type, modelFileId: storageSeed.modelFileId }, {
+        db,
+        fields: { ...storageSeed.fields, publisher: parentPublisher ?? storageSeed.fields.publisher },
+        localId: storageSeed.localId,
+    });
+    await createVersion({ seedLocalId: storageSeed.localId, seedType: storageSeed.type }, { db });
+    // Html and File store the property as e.g. htmlId; older rows may use the plain name
+    const baseName = propertyName.endsWith('Id') ? propertyName.slice(0, -2) : propertyName;
+    const [existing] = await db
+        .select({ localId: metadata$1.localId })
+        .from(metadata$1)
+        .where(and(eq(metadata$1.seedLocalId, seedLocalId), or(eq(metadata$1.propertyName, propertyName), eq(metadata$1.propertyName, baseName))))
+        .limit(1);
+    if (existing?.localId) {
+        const result = await updateItemPropertyValue({ ...value.update, localId: existing.localId, seedLocalId, propertyName }, { db });
+        return result ?? null;
+    }
+    const row = await createMetadata({ ...value.create.values, seedLocalId, propertyName }, value.create.propertyRecordSchema, { db });
+    return row.localId ? { localId: row.localId, uid: row.uid ?? null, schemaUid: row.schemaUid ?? '' } : null;
+}
+/** A local edit: no attestation uid of its own and not derived from one. */
+const isLocalDraft = (row) => !row.uid && row.derivedFromUid == null;
+/** The ItemStorage file a new draft of this item writes to (and so the lock to hold). */
+const itemStorageTargetPath = (seedLocalId, value) => getItemStorageFilePath({
+    seedId: value.seedUid || seedLocalId,
+    localStorageDir: value.propertyRecordSchema.localStorageDir,
+    filenameSuffix: value.propertyRecordSchema.filenameSuffix,
+});
+/**
+ * Moves a staged file into place. A retry after the move but before the commit finds the staged
+ * file gone and the target there: already moved.
+ */
+async function moveStagedFile(from, to) {
+    if (!(await BaseFileManager.pathExists(from))) {
+        if (await BaseFileManager.pathExists(to))
+            return;
+        throw new Error(`Staged file ${from} is missing`);
+    }
+    await BaseFileManager.createDirIfNotExists(to.slice(0, to.lastIndexOf('/')));
+    const fs = await BaseFileManager.getFs();
+    await fs.promises.rename(from, to);
+    notifyFileSaved(to);
+}
+/**
+ * Writes an ItemStorage value on `db`: the edit goes into the property's current local draft, or a
+ * new one when there is none or a published row is newer (readers show the newest row). A synced
+ * or derived row is published content and is never written to.
+ */
+async function applyItemStorageValue(seedLocalId, propertyName, op, db) {
+    const value = op.itemStorage;
+    const schema = value.propertyRecordSchema;
+    const where = [eq(metadata$1.propertyName, propertyName), eq(metadata$1.seedLocalId, seedLocalId)];
+    if (value.versionLocalId)
+        where.push(eq(metadata$1.versionLocalId, value.versionLocalId));
+    const rows = await db.select().from(metadata$1).where(and(...where));
+    const latest = [...rows].sort(compareMetadataRowsLatestFirst)[0];
+    let draft = latest && isLocalDraft(latest) ? latest : undefined;
+    if (!draft) {
+        draft = await createMetadata({
+            propertyName,
+            propertyValue: getItemStorageLocalFileName(value.seedUid || seedLocalId, schema.filenameSuffix),
+            modelType: value.modelType ?? undefined,
+            seedLocalId,
+            seedUid: value.seedUid ?? undefined,
+            versionLocalId: value.versionLocalId ?? undefined,
+            versionUid: value.versionUid ?? undefined,
+            localStorageDir: schema.localStorageDir,
+            refValueType: 'file',
+        }, schema, { db });
+    }
+    // No storage.path: the `files` directory, as resolveItemStorageChildFile and download assume.
+    const localStorageDir = schema.localStorageDir || draft.localStorageDir || '/files';
+    const fileName = draft.refResolvedValue ||
+        getItemStorageLocalFileName(draft.seedUid || draft.seedLocalId || seedLocalId, schema.filenameSuffix);
+    await moveStagedFile(value.stagedPath, BaseFileManager.getFilesPath(getItemStorageSubdir(localStorageDir), fileName));
+    // A legacy row (made before Item.create saved ItemStorage values) holds the old content itself in
+    // propertyValue. The file is the content now: drop it, or a fresh load shows the old text until
+    // the file is read. A row whose propertyValue is the file name keeps it.
+    const clearsVerbatimValue = !draft.refResolvedValue && draft.propertyValue != null && draft.propertyValue !== '' && draft.propertyValue !== fileName;
+    const now = Date.now();
+    await db
+        .update(metadata$1)
+        .set({
+        refResolvedValue: fileName,
+        localStorageDir,
+        // The draft is as new as its content (see updateItemPropertyValue).
+        createdAt: now,
+        updatedAt: now,
+        // Same shape as a row the migration or publish converted (convertVerbatimItemStorageRow).
+        ...(clearsVerbatimValue && { propertyValue: null, refValueType: 'file' }),
+    })
+        .where(eq(metadata$1.localId, draft.localId));
+    return { localId: draft.localId, uid: draft.uid ?? null, schemaUid: draft.schemaUid ?? '', fileName, localStorageDir };
+}
+/** Writes a new item's rows on `db` (see CreateItemOp). */
+async function applyCreateItem(seedLocalId, value, db) {
+    await createSeed({ type: value.seed.type, modelFileId: value.seed.modelFileId }, { db, fields: value.seed.fields, localId: seedLocalId });
+    const versionLocalId = await createVersion({ seedLocalId, seedType: value.seed.type }, { db });
+    for (const row of value.rows) {
+        if (row.itemStorage) {
+            const { stagedPath, fileName, localStorageDir } = row.itemStorage;
+            await moveStagedFile(stagedPath, BaseFileManager.getFilesPath(getItemStorageSubdir(localStorageDir), fileName));
+        }
+        await createMetadata({
+            seedLocalId,
+            versionLocalId,
+            propertyName: row.propertyName,
+            propertyValue: row.itemStorage ? undefined : row.propertyValue,
+            ...(row.itemStorage && {
+                refResolvedValue: row.itemStorage.fileName,
+                localStorageDir: row.itemStorage.localStorageDir,
+                refValueType: 'file',
+            }),
+            ...(row.schemaUid && { schemaUid: row.schemaUid }),
+            modelName: value.modelName,
+        }, row.propertyRecordSchema, { db, skipValidation: true, modelFileId: value.seed.modelFileId });
+    }
+    return { seedLocalId, versionLocalId };
+}
+/** Storage seeds a property row points at: Html, Image and File values are seeds of their own. */
+const STORAGE_REF_TYPES = new Set(['html', 'image', 'file']);
+async function applyDelete(op, value, db) {
+    if (value.mode === 'item') {
+        await db.update(seeds).set({ _markedForDeletion: 1 }).where(eq(seeds.localId, op.seedLocalId));
+        return { filePaths: [] };
+    }
+    if (value.mode === 'property') {
+        await db
+            .delete(metadata$1)
+            .where(and(eq(metadata$1.seedLocalId, op.seedLocalId), inArray(metadata$1.propertyName, value.propertyNames)));
+        return { filePaths: [] };
+    }
+    if (value.mode === 'drafts') {
+        await db
+            .delete(metadata$1)
+            .where(and(eq(metadata$1.seedLocalId, op.seedLocalId), inArray(metadata$1.propertyName, value.propertyNames), isNull(metadata$1.uid)));
+        return { filePaths: [] };
+    }
+    const rows = await db
+        .select({
+        propertyValue: metadata$1.propertyValue,
+        refSeedType: metadata$1.refSeedType,
+        refResolvedValue: metadata$1.refResolvedValue,
+        localStorageDir: metadata$1.localStorageDir,
+    })
+        .from(metadata$1)
+        .where(eq(metadata$1.seedLocalId, op.seedLocalId));
+    const childSeedLocalIds = [];
+    const filePaths = [];
+    for (const row of rows) {
+        if (row.refSeedType && STORAGE_REF_TYPES.has(row.refSeedType) && row.propertyValue) {
+            childSeedLocalIds.push(row.propertyValue);
+        }
+        if (row.localStorageDir && row.refResolvedValue) {
+            filePaths.push(BaseFileManager.getFilesPath(row.localStorageDir, row.refResolvedValue));
+        }
+    }
+    const { hardDeleteLocalSeedsByLocalIds } = await Promise.resolve().then(function () { return removeLocalCopiesForAddresses; });
+    await hardDeleteLocalSeedsByLocalIds([op.seedLocalId, ...childSeedLocalIds], { db, keepOpId: op.opId });
+    return { filePaths };
+}
+/** Deletes files after the op that removed their rows applied; best-effort. */
+async function deleteFiles(filePaths) {
+    if (filePaths.length === 0)
+        return;
+    const fs = await BaseFileManager.getFs();
+    for (const path of filePaths) {
+        try {
+            if (!(await BaseFileManager.pathExists(path)))
+                continue;
+            if (fs?.promises?.unlink)
+                await fs.promises.unlink(path);
+            else
+                fs?.unlinkSync?.(path);
+        }
+        catch {
+            // Best-effort: a file left behind has no row pointing at it
+        }
+    }
+}
+const isItemStorageOp = (value) => typeof value === 'object' && value !== null && 'itemStorage' in value;
+/** Deletes the file a storage op wrote, once the op will never apply. */
+async function discardStorageValue(op) {
+    const value = outboxOpValue(op);
+    const path = value && (isItemStorageOp(value) ? value.itemStorage.stagedPath : value.ownedFilePath);
+    if (!path || !(await BaseFileManager.pathExists(path)))
+        return;
+    const fs = await BaseFileManager.getFs();
+    if (fs?.promises?.unlink)
+        await fs.promises.unlink(path);
+    else
+        fs?.unlinkSync?.(path);
+}
+/**
+ * The ownership rule, checked before an op applies (ADR 0019's async rules): the op may come from
+ * another tab, or from before a reload, and the client may have lost the item's wallet since it
+ * was appended. OwnershipError fails the op without a retry.
+ */
+async function requireOwned(op) {
+    if (!(await isItemOwned({ seedLocalId: op.seedLocalId })))
+        throw new OwnershipError();
+}
+/** A Relation value names a local seed that doesn't exist. */
+class RelationTargetError extends Error {
+    constructor(targets) {
+        super(`Relation target not found: ${targets.join(', ')}`);
+        this.targets = targets;
+        this.name = 'RelationTargetError';
+    }
+}
+/** The seed ids a Relation or List-of-Relation value names; none for other values. */
+function relationTargets(value) {
+    const dataType = normalizeDataType(value.dataType);
+    const refValueType = normalizeDataType(value.refValueType);
+    if (!value.newValue)
+        return [];
+    if (dataType === 'Relation' && refValueType !== 'Image')
+        return [value.newValue];
+    if (dataType === 'List' && refValueType === 'Relation')
+        return parseListPropertyValueFromStorage(value.newValue);
+    return [];
+}
+/**
+ * The relation-target rule, checked before a `set` applies: each seed a Relation value names by
+ * local id must exist. An attestation uid may name a seed with no local copy, so uids pass. A
+ * target whose create op is still pending defers the op (OutboxOpDeferredError) until it applies;
+ * any other missing target fails it with RelationTargetError.
+ */
+async function requireRelationTargets(op) {
+    const value = outboxOpValue(op);
+    const localIds = [...new Set(value ? relationTargets(value) : [])].filter((id) => !isValidEasAttestationUid(id));
+    if (localIds.length === 0)
+        return;
+    const db = BaseDb.getAppDb();
+    const found = await db.select({ localId: seeds.localId }).from(seeds).where(inArray(seeds.localId, localIds));
+    const missing = localIds.filter((id) => !found.some((row) => row.localId === id));
+    if (missing.length === 0)
+        return;
+    const creating = await db
+        .select({ seedLocalId: pendingWrites.seedLocalId })
+        .from(pendingWrites)
+        .where(and(inArray(pendingWrites.seedLocalId, missing), eq(pendingWrites.kind, 'create'), eq(pendingWrites.status, 'pending')));
+    if (creating.length > 0)
+        throw new OutboxOpDeferredError(`Relation target ${creating[0].seedLocalId} is being created`);
+    throw new RelationTargetError(missing);
+}
+/**
+ * Rethrows a failed item op's error as its caller expects it: OwnershipError when the drainer
+ * refused the op for ownership, else the OutboxOpFailedError as is.
+ */
+function throwItemWriteError(error) {
+    if (error instanceof OutboxOpFailedError && error.errorName === 'OwnershipError') {
+        throw new OwnershipError(error.message);
+    }
+    throw error;
+}
+let registered$1 = false;
+/** Registers the item appliers and starts draining. Safe to call more than once. */
+function startItemOutbox() {
+    if (!registered$1) {
+        registered$1 = true;
+        registerOutboxApplier('set', {
+            prepare: async (op) => {
+                await requireOwned(op);
+                await requireRelationTargets(op);
+            },
+            apply: async (op, tx) => {
+                const value = outboxOpValue(op);
+                // Before the write, which makes the edit the newest row
+                const conflict = await findSetConflict(op, value, tx);
+                const result = await updateItemPropertyValue({ ...value, seedLocalId: op.seedLocalId, propertyName: op.propertyName ?? undefined }, { db: tx });
+                await recordPropertyEdit(op, conflict, tx);
+                return result ?? null;
+            },
+        });
+        registerOutboxApplier('storage', {
+            prepare: requireOwned,
+            // Storage values record no conflicts: their ops carry no base row (ADR 0019)
+            apply: async (op, tx) => {
+                const value = outboxOpValue(op);
+                const result = isItemStorageOp(value)
+                    ? await applyItemStorageValue(op.seedLocalId, op.propertyName, value, tx)
+                    : await applyStorageValue(op.seedLocalId, op.propertyName, value, tx);
+                await recordPropertyEdit(op, null, tx);
+                return result;
+            },
+            // ItemStorage: the file's lock before the transaction, the order its other writers use. Taken
+            // only when free: another writer holding it would otherwise hold up every other op.
+            around: async (op, run) => {
+                const value = outboxOpValue(op);
+                if (!value || !isItemStorageOp(value))
+                    return run();
+                const path = itemStorageTargetPath(op.seedLocalId, value.itemStorage);
+                const outcome = await tryWithItemStorageFileLock(path, run);
+                if (!outcome.acquired)
+                    throw new OutboxOpDeferredError(`ItemStorage file ${path} is locked`);
+                return outcome.value;
+            },
+            discard: discardStorageValue,
+        });
+        registerOutboxApplier('create', {
+            apply: async (op, tx) => applyCreateItem(op.seedLocalId, outboxOpValue(op), tx),
+            // Staged ItemStorage values of a create that never applied
+            discard: async (op) => {
+                const paths = (outboxOpValue(op)?.rows ?? []).flatMap((row) => row.itemStorage ? [row.itemStorage.stagedPath] : []);
+                await deleteFiles(paths);
+            },
+        });
+        registerOutboxApplier('delete', {
+            // A discarded draft is the client's own create rolled back
+            prepare: async (op) => {
+                if (outboxOpValue(op)?.mode !== 'discard')
+                    await requireOwned(op);
+            },
+            apply: async (op, tx) => applyDelete(op, outboxOpValue(op), tx),
+        });
+    }
+    startOutbox();
+}
+
+var itemAppliers = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    RelationTargetError: RelationTargetError,
+    applyCreateItem: applyCreateItem,
+    applyDelete: applyDelete,
+    applyItemStorageValue: applyItemStorageValue,
+    applyStorageValue: applyStorageValue,
+    deleteFiles: deleteFiles,
+    startItemOutbox: startItemOutbox,
+    throwItemWriteError: throwItemWriteError
+});
+
 const { UNINITIALIZED, PLATFORM_CLASSES_INIT, FILE_SYSTEM_INIT, DB_INIT, SAVE_CONFIG, PROCESS_SCHEMA_FILES, ADD_MODELS_TO_STORE, ADD_MODELS_TO_DB, IDLE, INIT_FAILED, } = ClientManagerState;
 const { UPDATE_CONTEXT, PLATFORM_CLASSES_READY, FILE_SYSTEM_READY, DB_READY, SAVE_CONFIG_SUCCESS, SAVE_APP_STATE_SUCCESS, SAVE_APP_STATE_ERROR, SET_ADDRESSES, ADD_MODELS_TO_STORE_SUCCESS, ADD_MODELS_TO_DB_SUCCESS, PROCESS_SCHEMA_FILES_SUCCESS, } = ClientManagerEvents;
 const logSyncAfterAddressSave = debug("seedSdk:client:clientManagerMachine:syncAfterAddressSave");
@@ -4637,7 +5325,7 @@ function emitAddressesPersistedIfAddressesKey(event) {
     if (event.key !== "addresses")
         return;
     const payload = parseAddressesPersistedPayload(event.value);
-    emitAcrossTabs(ADDRESSES_PERSISTED_EVENT, payload);
+    announceAddressesPersisted(payload);
 }
 function errorFromEvent(event, fallbackMessage) {
     const error = event?.error;
@@ -4830,6 +5518,9 @@ const clientManagerMachine = setup({
                 () => startClearStoredDisplayUrls(),
                 // Stored model types to the ADR 0008 form (html_page), so exact type filters find old rows.
                 () => startCanonicalizeModelTypes(),
+                // Registers the item appliers and resumes outbox ops left pending (a reload, a closed
+                // leader tab) once this tab leads
+                () => startItemOutbox(),
             ],
             on: {
                 [SAVE_APP_STATE_SUCCESS]: {
@@ -5411,15 +6102,21 @@ async function findLocalOnchainCopiesForAddresses(addresses) {
     };
 }
 /**
- * Hard-delete the given seed local ids and related local rows (cascade).
+ * Hard-delete the given seed local ids and related local rows (cascade), their outbox ops included
+ * (ADR 0019: an edit of a removed seed has nothing left to apply to; a waiter on one rejects).
  * Does not touch schemas, app_state, or chain.
  */
-async function hardDeleteLocalSeedsByLocalIds(seedLocalIds) {
+async function hardDeleteLocalSeedsByLocalIds(seedLocalIds, options = {}) {
     if (seedLocalIds.length === 0)
         return;
-    const appDb = BaseDb.getAppDb();
+    const appDb = options.db ?? BaseDb.getAppDb();
     if (!appDb)
         return;
+    await appDb
+        .delete(pendingWrites)
+        .where(options.keepOpId
+        ? and(inArray(pendingWrites.seedLocalId, seedLocalIds), ne(pendingWrites.opId, options.keepOpId))
+        : inArray(pendingWrites.seedLocalId, seedLocalIds));
     await appDb
         .delete(htmlEmbeddedImageCoPublish)
         .where(or(inArray(htmlEmbeddedImageCoPublish.parentSeedLocalId, seedLocalIds), inArray(htmlEmbeddedImageCoPublish.htmlSeedLocalId, seedLocalIds), inArray(htmlEmbeddedImageCoPublish.imageSeedLocalId, seedLocalIds)));
@@ -5434,10 +6131,17 @@ async function hardDeleteLocalSeedsByLocalIds(seedLocalIds) {
     await appDb.delete(seeds).where(inArray(seeds.localId, seedLocalIds));
 }
 
+var removeLocalCopiesForAddresses = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    findLocalOnchainCopiesForAddresses: findLocalOnchainCopiesForAddresses,
+    hardDeleteLocalSeedsByLocalIds: hardDeleteLocalSeedsByLocalIds
+});
+
 const emptyResult = () => ({
     seeds: 0,
     versions: 0,
     metadata: 0,
+    pendingCreates: 0,
     seedLocalIds: [],
 });
 /**
@@ -5445,53 +6149,78 @@ const emptyResult = () => ({
  * uid and no attestationRaw, and those seeds' versions and property rows that are unsealed too.
  * Versions and property rows go only with their seed, so rows of a seed that already has a
  * publisher are never claimed. Sealed rows (real EAS uid or attestationRaw) are never touched.
+ *
+ * Pending Item.create ops with no publisher get it too, in the same transaction: the drainer applies
+ * an op's value as its claim reads it (ADR 0019), so a create applied before or after this one ends
+ * up claimed either way.
  */
 async function claimUnpublishedDrafts(publisher) {
     const normalized = normalizePublisher(publisher);
     if (!normalized)
         return emptyResult();
-    const appDb = BaseDb.getAppDb();
-    if (!appDb)
+    if (!BaseDb.getAppDb())
         return emptyResult();
     const now = Date.now();
     const isClaimable = (row) => typeof row.localId === 'string' && row.localId !== '' && isLocalUnsealedDraft(row);
-    const stamp = async (table, ids) => {
-        await writeInBatches(ids, (chunk) => appDb.update(table).set({ publisher: normalized, updatedAt: now }).where(inArray(table.localId, chunk)));
-    };
-    const seedRows = (await appDb
-        .select({
-        localId: seeds.localId,
-        uid: seeds.uid,
-        publisher: seeds.publisher,
-        attestationRaw: seeds.attestationRaw,
-    })
-        .from(seeds));
-    const seedIds = seedRows.filter(isClaimable).map((row) => row.localId);
-    if (seedIds.length === 0)
-        return emptyResult();
-    const claimChildren = async (table) => {
-        const rows = (await selectInBatches(seedIds, (chunk) => appDb
+    return BaseDb.transaction(async (tx) => {
+        const stamp = async (table, ids) => {
+            await writeInBatches(ids, (chunk) => tx.update(table).set({ publisher: normalized, updatedAt: now }).where(inArray(table.localId, chunk)));
+        };
+        const pendingCreateIds = await claimPendingCreates(tx, normalized);
+        const seedRows = (await tx
             .select({
-            localId: table.localId,
-            uid: table.uid,
-            publisher: table.publisher,
-            attestationRaw: table.attestationRaw,
+            localId: seeds.localId,
+            uid: seeds.uid,
+            publisher: seeds.publisher,
+            attestationRaw: seeds.attestationRaw,
         })
-            .from(table)
-            .where(inArray(table.seedLocalId, chunk))));
-        const ids = rows.filter(isClaimable).map((row) => row.localId);
-        await stamp(table, ids);
-        return ids;
-    };
-    await stamp(seeds, seedIds);
-    const versionIds = await claimChildren(versions);
-    const metadataIds = await claimChildren(metadata$1);
-    return {
-        seeds: seedIds.length,
-        versions: versionIds.length,
-        metadata: metadataIds.length,
-        seedLocalIds: seedIds,
-    };
+            .from(seeds));
+        const seedIds = seedRows.filter(isClaimable).map((row) => row.localId);
+        if (seedIds.length === 0) {
+            return { ...emptyResult(), pendingCreates: pendingCreateIds.length, seedLocalIds: pendingCreateIds };
+        }
+        const claimChildren = async (table) => {
+            const rows = (await selectInBatches(seedIds, (chunk) => tx
+                .select({
+                localId: table.localId,
+                uid: table.uid,
+                publisher: table.publisher,
+                attestationRaw: table.attestationRaw,
+            })
+                .from(table)
+                .where(inArray(table.seedLocalId, chunk))));
+            const ids = rows.filter(isClaimable).map((row) => row.localId);
+            await stamp(table, ids);
+            return ids;
+        };
+        await stamp(seeds, seedIds);
+        const versionIds = await claimChildren(versions);
+        const metadataIds = await claimChildren(metadata$1);
+        return {
+            seeds: seedIds.length,
+            versions: versionIds.length,
+            metadata: metadataIds.length,
+            pendingCreates: pendingCreateIds.length,
+            seedLocalIds: [...seedIds, ...pendingCreateIds],
+        };
+    });
+}
+/** Sets `publisher` on pending create ops that have none; returns their seeds' local ids. */
+async function claimPendingCreates(tx, publisher) {
+    const ops = await tx
+        .select({ opId: pendingWrites.opId, seedLocalId: pendingWrites.seedLocalId, value: pendingWrites.value })
+        .from(pendingWrites)
+        .where(and(eq(pendingWrites.kind, 'create'), eq(pendingWrites.status, 'pending')));
+    const claimed = [];
+    for (const op of ops) {
+        const value = op.value ? JSON.parse(op.value) : undefined;
+        if (!value || value.seed.fields.publisher)
+            continue;
+        value.seed.fields = { ...value.seed.fields, publisher };
+        await tx.update(pendingWrites).set({ value: JSON.stringify(value) }).where(eq(pendingWrites.opId, op.opId));
+        claimed.push(op.seedLocalId);
+    }
+    return claimed;
 }
 
 const logger = debug('seedSdk:client');
@@ -5513,6 +6242,18 @@ const createClientManager = () => {
 };
 // Replaced when init runs after stop(): an xstate actor can't be started again once stopped.
 let { actor: clientManager, actorSubscription: subscription } = createClientManager();
+const serviceListeners = new Set();
+/** Tells subscribeService listeners that the clientManager actor was replaced or stopped. */
+const notifyServiceListeners = () => {
+    for (const listener of [...serviceListeners]) {
+        try {
+            listener(clientManager);
+        }
+        catch (error) {
+            logger('subscribeService listener threw:', error);
+        }
+    }
+};
 /** Config of the init that is running or has succeeded; cleared when init fails or the client stops. */
 let activeInitConfig;
 const INIT_CONFIG_CONFLICT_MESSAGE = 'client.init was already called with a different config. The SDK keeps the config it was ' +
@@ -5537,9 +6278,11 @@ const stopClient = ({ unsubscribe }) => {
     activeInitConfig = undefined;
     cancelAllRetriesWhenOnline();
     unregisterSeedQueryLocalSource();
+    resetAddressesPersistedAnnouncement();
     clientManager.stop();
     if (unsubscribe)
         subscription.unsubscribe();
+    notifyServiceListeners();
 };
 const coalescedInit = createCoalescedAsync(async (options) => {
     // If the actor is stopped (e.g., from a previous failed test), restart it
@@ -5550,6 +6293,7 @@ const coalescedInit = createCoalescedAsync(async (options) => {
         // stop() (or a failed test) stopped it: start over with a new actor and a clean context.
         logger('Client manager was stopped, creating a new one');
         ({ actor: clientManager, actorSubscription: subscription } = createClientManager());
+        notifyServiceListeners();
     }
     // Clear any stale context from previous failed initializations
     // This ensures we start with a clean slate before the new init updates it
@@ -5629,6 +6373,17 @@ const clientInstance = {
         // ensureInitialized();
         return clientManager;
     },
+    /**
+     * Calls `listener` with the clientManager actor when it changes: `init()` after `stop()`
+     * replaces the actor, and `stop()` ends the current one. Subscribe to the actor itself for its
+     * state changes. Returns a function that removes the listener.
+     */
+    subscribeService: (listener) => {
+        serviceListeners.add(listener);
+        return () => {
+            serviceListeners.delete(listener);
+        };
+    },
     /**
      * Initialise the SDK. Calls made while an init is running share it. Once initialised, a
      * call with the same config resolves at once and applies any change in `addresses`; a
@@ -5787,5 +6542,5 @@ var ClientManager$1 = /*#__PURE__*/Object.freeze({
     getClient: getClient
 });
 
-export { requestEasSyncFromEventBus as A, requestEasSyncFromModelsInit as B, ClientManager as C, sendEasSyncClientRequest as D, EAS_CHAIN_ID_APP_STATE_KEY as E, setRetriesWhenOnlineEnabled as F, startEasSyncActor as G, unregisterSeedQueryLocalSource as H, INIT_CONFIG_CONFLICT_MESSAGE as I, createRowsWrittenSignal as J, createModelsFromJson as K, getLatestSchemaVersion as L, jsonPropertiesToSchemaProperties as M, schema as N, ClientManager$1 as O, SEEDPROTOCOL_Seed_Protocol_v1 as S, getContentHash as a, isVerbatimItemStorageDraftRow as b, convertVerbatimItemStorageRow as c, assertLocalDbChain as d, claimUnpublishedDrafts as e, createLocalQueryDataSource as f, getRefValueType as g, hardDeleteLocalSeedsByLocalIds as h, importJsonSchema as i, createSchema as j, easSyncActor as k, loadSchemaFromFile as l, getClient as m, getPublishedSeedRecord as n, getSchemaNameFromId as o, isSeedQueryLocalSourceRegistered as p, listCompleteSchemaFiles as q, readJsonImportFile as r, syncSchemaFromSource as s, transformImportToSchemaFile as t, loadAllSchemasFromDb as u, mergeEasSyncRequestIntents as v, waitForEasReadChain as w, readSchema as x, registerSeedQueryLocalSource as y, requestEasSyncFromAddressChange as z };
-//# sourceMappingURL=ClientManager-2GtDWHq6.js.map
+export { ClientManager$1 as $, getPublishedSeedRecord as A, getSchemaNameFromId as B, ClientManager as C, isSeedQueryLocalSourceRegistered as D, EAS_CHAIN_ID_APP_STATE_KEY as E, listCompleteSchemaFiles as F, loadAllSchemasFromDb as G, mergeEasSyncRequestIntents as H, INIT_CONFIG_CONFLICT_MESSAGE as I, readSchema as J, registerSeedQueryLocalSource as K, requestEasSyncFromAddressChange as L, requestEasSyncFromEventBus as M, requestEasSyncFromModelsInit as N, sendEasSyncClientRequest as O, setRetriesWhenOnlineEnabled as P, startEasSyncActor as Q, RelationTargetError as R, unregisterSeedQueryLocalSource as S, createRowsWrittenSignal as T, createModelsFromJson as U, getLatestSchemaVersion as V, jsonPropertiesToSchemaProperties as W, schema as X, SEEDPROTOCOL_Seed_Protocol_v1 as Y, conflicts as Z, itemAppliers as _, applyCreateItem as a, applyDelete as b, applyItemStorageValue as c, deleteFiles as d, applyStorageValue as e, getPropertyConflict as f, getItemConflicts as g, getRefValueType as h, importJsonSchema as i, syncSchemaFromSource as j, transformImportToSchemaFile as k, loadSchemaFromFile as l, markPropertyConflictsResolved as m, getContentHash as n, isVerbatimItemStorageDraftRow as o, convertVerbatimItemStorageRow as p, assertLocalDbChain as q, readJsonImportFile as r, startItemOutbox as s, throwItemWriteError as t, claimUnpublishedDrafts as u, createLocalQueryDataSource as v, waitForEasReadChain as w, createSchema as x, easSyncActor as y, getClient as z };
+//# sourceMappingURL=ClientManager-Dcju5x4k.js.map