@seedprotocol/sdk 0.7.3-next.613.g79a8dfd → 0.7.3-next.654.g52217f6

package/dist/{Item-D4FigtYS.js → Item-C7sUUu2B.js}

@@ -1,14 +1,14 @@
 import { waitFor, fromCallback, setup, assign, stateIn, createActor, isMachineSnapshot } from 'xstate';
-import { a as BaseDb, v as versions, m as metadata, r as seeds, s as schemas, j as models, g as modelSchemas, Z as ZERO_BYTES32, I as INTERNAL_PROPERTY_NAMES, B as BaseFileManager, D as ImageSize, p as properties, x as INTERNAL_DATA_TYPES, i as modelUids, C as INTERNAL_STORAGE_MODEL_FILE_IDS, P as PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP } from './BasePathResolver-BdxCSIzn.js';
+import { B as BaseDb, v as versions, m as metadata, q as seeds, s as schemas, i as models, f as modelSchemas, Z as ZERO_BYTES32, I as INTERNAL_PROPERTY_NAMES, t as BaseFileManager, D as ImageSize, p as properties, x as INTERNAL_DATA_TYPES, g as modelUids, C as INTERNAL_STORAGE_MODEL_FILE_IDS, P as PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP } from './BasePathResolver-CfSfMW5_.js';
 import { or, isNull, eq, max, count, and, getTableColumns, sql, desc, inArray, isNotNull, gt } from 'drizzle-orm';
 import pluralize from 'pluralize';
-import { n as normalizeDataType, W as getOwnedAddressesFromDb, E as normalizeAddressList, u as normalizeHexAddress, z as getAddressesForItemsFilter, k as isDataType, s as normalizePublisher, M as ModelPropertyDataTypes, r as resolveItemModelFileId, X as getPropertyIdForSchemaFileId, o as getPropertyIdForModelAndName, l as normalizePropertyRecordSchema, m as eventEmitter } from './db-CQt-gcAl.js';
+import { n as normalizeDataType, W as getOwnedAddressesFromDb, E as normalizeAddressList, u as normalizeHexAddress, z as getAddressesForItemsFilter, k as isDataType, s as normalizePublisher, M as ModelPropertyDataTypes, r as resolveItemModelFileId, X as getPropertyIdForSchemaFileId, o as getPropertyIdForModelAndName, l as normalizePropertyRecordSchema, m as eventEmitter } from './db-D9K_f5cF.js';
 import debug from 'debug';
 import { BehaviorSubject } from 'rxjs';
 import { startCase, upperFirst, camelCase, orderBy } from 'lodash-es';
 import { toSnakeCase } from 'drizzle-orm/casing';
 import { isValidEasAttestationUid, isPlaceholderUid, BaseQueryClient, BaseEasClient, GET_SCHEMAS, getEasSchemaUidForSchemaDefinition, getSchemaUidForModelFromCache, cachedSchemaLookup, setSchemaUidForModel, getEasSchemaUidForExactDefinition } from '@seedprotocol/eas';
-import { t as toSnakeCase$1, H as getStorageTransactionIdForSeedUid, I as convertTxIdToImage, h as ensureImageLocal, J as downloadTransactionIdWithDedupe, b as generateId, K as getDataTypeFromString, M as getMimeType, N as notifyFileSaved, g as getCorrectId, a as isStorageSeedRef } from './tabEvents-BZJMY5uK.js';
+import { t as toSnakeCase$1, Q as getStorageTransactionIdForSeedUid, R as convertTxIdToImage, q as ensureImageLocal, S as downloadTransactionIdWithDedupe, j as generateId, U as getDataTypeFromString, V as getMimeType, W as notifyFileSaved, X as withTabLock, a as getItemStorageSubdir, c as getItemStorageLocalFileName, e as getCorrectId, f as isStorageSeedRef } from './tabEvents-DguZpCCv.js';
 import { fetchArweaveRawTextAcrossGateways } from '@seedprotocol/arweave';
 import { modelPropertiesToObject } from './model-DGMe-TTm.js';
 
@@ -708,7 +708,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
         const itemPropertyMod = await Promise.resolve().then(function () { return ItemProperty$1; });
         const { ItemProperty } = itemPropertyMod;
         const { modelPropertiesToObject } = await import('./model-DGMe-TTm.js');
-        const _mod_0 = await import('./index-Xl1_4Lmb.js');
+        const _mod_0 = await import('./index-s15q14rm.js');
         const _ns_0 = _mod_0.f;
         const { Model } = _ns_0;
         // Resolve Model and build property schemas (use getByNameAsync for models not yet in cache)
@@ -726,7 +726,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             const schemaNameToTry = schemaName ?? model?.schemaName;
             if (schemaNameToTry) {
                 try {
-                    const _mod_1 = await import('./Schema-B8xqLWkL.js');
+                    const _mod_1 = await import('./Schema-fXtvd-yL.js');
                     const _ns_1 = _mod_1.b;
                     const { Schema } = _ns_1;
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false });
@@ -742,8 +742,8 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             }
             if (Object.keys(propertySchemas).length === 0) {
                 try {
-                    const _mod_2 = await import('./ClientManager-DDA9956Y.js');
-                    const _ns_2 = _mod_2.G;
+                    const _mod_2 = await import('./ClientManager-C-QXqUK9.js');
+                    const _ns_2 = _mod_2.I;
                     const { loadAllSchemasFromDb } = _ns_2;
                     const allSchemas = await loadAllSchemasFromDb();
                     for (const { schema: schemaFile } of allSchemas) {
@@ -763,10 +763,10 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             }
             if (Object.keys(propertySchemas).length === 0) {
                 try {
-                    const _mod_3 = await import('./ClientManager-DDA9956Y.js');
-                    const _ns_3 = _mod_3.G;
+                    const _mod_3 = await import('./ClientManager-C-QXqUK9.js');
+                    const _ns_3 = _mod_3.I;
                     const { listCompleteSchemaFiles } = _ns_3;
-                    const _mod_4 = await import('./BasePathResolver-BdxCSIzn.js');
+                    const _mod_4 = await import('./BasePathResolver-CfSfMW5_.js');
                     const _ns_4 = _mod_4.O;
                     const { BaseFileManager } = _ns_4;
                     const schemaFiles = await listCompleteSchemaFiles();
@@ -787,7 +787,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await import('./index-BGt4_oPO.js');
+                const schemaMod = await import('./index-CiMEoGu3.js');
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
@@ -804,7 +804,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             }
         }
         // Fallbacks above may return schema-file shape ({ type, model, items }); normalize to dataType/ref/refValueType.
-        const { normalizePropertyRecordSchema } = await import('./property-BrXkY1Rg.js');
+        const { normalizePropertyRecordSchema } = await import('./property-DhmmYAvQ.js');
         propertySchemas = Object.fromEntries(Object.entries(propertySchemas).map(([name, def]) => [name, normalizePropertyRecordSchema(def)]));
         // Collapse rows that map to the same instance key (e.g. authorIdentityIds + authors -> authors).
         // ItemProperty.create cache does not sync propertyValue on hit; processing order would otherwise
@@ -837,7 +837,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 // Infer propertyRecordSchema from metadata when schema is missing (enables persistence)
                 let propSchema = propertySchemas[propertyName];
                 if (!propSchema && isRefTypeFromMeta) {
-                    const schemaMod = await import('./index-BGt4_oPO.js');
+                    const schemaMod = await import('./index-CiMEoGu3.js');
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -1104,9 +1104,9 @@ const runPublish = fromCallback(({ sendBack, input: { context } }) => {
                 sendBack({ type: 'publishError', error: new Error(`Item not found for seedLocalId: ${seedLocalId}`) });
                 return;
             }
-            const getPublishUploadsMod = await import('./getPublishUploads-DHP01KgU.js');
+            const getPublishUploadsMod = await import('./getPublishUploads-BEqRiKIS.js');
             const { getPublishUploads } = getPublishUploadsMod;
-            const _mod_5 = await import('./getPublishPayload-Xl3sRkR-.js');
+            const _mod_5 = await import('./getPublishPayload-BHrxVtzY.js');
             const _ns_5 = _mod_5.g;
             const getPublishPayloadMod = _ns_5;
             const { getPublishPayload } = getPublishPayloadMod;
@@ -1731,8 +1731,9 @@ function isSeedRowOwned(row, ownedAddresses) {
     return publisherIsInOwnedSet(publisher, ownedAddresses);
 }
 /**
- * SQL for `addressFilter: 'owned' | 'watched'`. Empty list → no rows (`1=0`).
- * Compares `lower(publisher)` so checksummed rows match persisted lowercase owned.
+ * SQL for an address list on `publisher`. Empty list → no rows (`1=0`).
+ * Compares `lower(publisher)` so checksummed rows match persisted lowercase addresses.
+ * Used for `addressFilter: 'watched'`; `'owned'` uses {@link ownedSeedsSql}.
  */
 function publisherInAddressListSql(column, addresses) {
     const normalized = normalizeAddressList(addresses);
@@ -1741,10 +1742,37 @@ function publisherInAddressListSql(column, addresses) {
     }
     return inArray(sql `lower(${column})`, normalized);
 }
-/** Owned-list SQL on `seeds.publisher`. */
+/**
+ * @deprecated Matches `seeds.publisher` only. Use {@link ownedSeedsSql}, which agrees
+ * with {@link isSeedRowOwned} (empty owned → local unsealed drafts; attester fallback).
+ */
 function ownedPublisherSql(ownedAddresses) {
     return publisherInAddressListSql(seeds.publisher, ownedAddresses);
 }
+/** SQL form of {@link isPlaceholderUid}: null, `''`, `'NULL'`, or zero bytes32 (trimmed, any case). */
+function placeholderUidSql(column) {
+    return or(isNull(column), eq(column, 'NULL'), sql `trim(${column}) = ''`, sql `lower(trim(${column})) = ${ZERO_BYTES32.toLowerCase()}`);
+}
+const isBlankSql = (column) => or(isNull(column), eq(column, ''));
+/** SQL form of {@link isLocalUnsealedDraft} on `seeds`. */
+function localUnsealedDraftSql() {
+    return and(isBlankSql(seeds.publisher), placeholderUidSql(seeds.uid), isBlankSql(seeds.attestationRaw));
+}
+/**
+ * SQL for `addressFilter: 'owned'`: a row passes exactly when {@link isSeedRowOwned} is true.
+ * - Empty owned → local unsealed drafts (pre-connect authoring), not every row.
+ * - Owned set → `lower(trim(publisher))` in the set, or, when publisher is blank, the
+ *   `attestationRaw.attester` ({@link resolvePublisherFromSeedRow}). `json_valid` guards
+ *   `json_extract`, which throws on malformed JSON.
+ */
+function ownedSeedsSql(ownedAddresses) {
+    const normalized = normalizeAddressList(ownedAddresses);
+    if (normalized.length === 0) {
+        return localUnsealedDraftSql();
+    }
+    const attester = sql `CASE WHEN json_valid(${seeds.attestationRaw}) THEN lower(trim(json_extract(${seeds.attestationRaw}, '$.attester'))) END`;
+    return or(inArray(sql `lower(trim(${seeds.publisher}))`, normalized), and(isBlankSql(seeds.publisher), inArray(attester, normalized)));
+}
 /**
  * Checks if the current user owns the item (publisher is in persisted owned addresses).
  *
@@ -1781,7 +1809,10 @@ var ownership = /*#__PURE__*/Object.freeze({
     isItemOwned: isItemOwned,
     isLocalUnsealedDraft: isLocalUnsealedDraft,
     isSeedRowOwned: isSeedRowOwned,
+    localUnsealedDraftSql: localUnsealedDraftSql,
     ownedPublisherSql: ownedPublisherSql,
+    ownedSeedsSql: ownedSeedsSql,
+    placeholderUidSql: placeholderUidSql,
     publisherInAddressListSql: publisherInAddressListSql,
     publisherIsInOwnedSet: publisherIsInOwnedSet,
     resolvePublisherFromSeedRow: resolvePublisherFromSeedRow
@@ -1801,13 +1832,13 @@ const getItemsData = async ({ modelName, modelFileId, schemaName, deleted, inclu
     const appDb = BaseDb.getAppDb();
     const conditions = [];
     if (!includeEas) {
-        conditions.push(or(isNull(seeds.uid), eq(seeds.uid, ''), eq(seeds.uid, 'NULL'), eq(seeds.uid, ZERO_BYTES32)));
+        conditions.push(placeholderUidSql(seeds.uid));
     }
     if (modelName) {
         conditions.push(eq(seeds.type, toSnakeCase(modelName)));
     }
     if (!modelFileId && schemaName && modelName) {
-        const _mod_6 = await import('./db-CQt-gcAl.js');
+        const _mod_6 = await import('./db-D9K_f5cF.js');
         const _ns_6 = _mod_6.Y;
         const { resolveModelRecord } = _ns_6;
         modelFileId = (await resolveModelRecord(modelName, { schemaName }))?.schemaFileId ?? undefined;
@@ -1819,7 +1850,7 @@ const getItemsData = async ({ modelName, modelFileId, schemaName, deleted, inclu
     }
     if (addressFilter === 'owned') {
         const ownedAddresses = await getAddressesForItemsFilter('owned');
-        conditions.push(publisherInAddressListSql(seeds.publisher, ownedAddresses));
+        conditions.push(ownedSeedsSql(ownedAddresses));
     }
     else if (addressFilter === 'watched') {
         const watchedAddresses = await getAddressesForItemsFilter('watched');
@@ -2090,7 +2121,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
     const { isRelation, propertyValue, propertyName, seedUid, propertyRecordSchema, populatedFromDb, schemaUid, } = context;
     const _resolveRelatedValue = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-BGt4_oPO.js');
+        const schemaMod = await import('./index-CiMEoGu3.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -2525,8 +2556,8 @@ async function readHtmlBodyFromChildStorageArweave(seedLocalId) {
         /* offline / bad tx id */
     }
     try {
-        const _mod_7 = await import('./tabEvents-BZJMY5uK.js');
-        const _ns_7 = _mod_7.O;
+        const _mod_7 = await import('./tabEvents-DguZpCCv.js');
+        const _ns_7 = _mod_7.Y;
         const { downloadTransactionIdWithDedupe } = _ns_7;
         await downloadTransactionIdWithDedupe(txId);
         const retryFp = BaseFileManager.getFilesPath('html', `${seedLocalId}.html`);
@@ -2586,7 +2617,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
     // to use dynamically imported ModelPropertyDataTypes
     const _hydrateFromDb = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-BGt4_oPO.js');
+        const schemaMod = await import('./index-CiMEoGu3.js');
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -2865,11 +2896,11 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
             const modelNameForNew = context.modelName;
             if (modelNameForNew) {
                 try {
-                    const _mod_8 = await import('./index-Xl1_4Lmb.js');
+                    const _mod_8 = await import('./index-s15q14rm.js');
                     const _ns_8 = _mod_8.f;
                     const { Model } = _ns_8;
                     const { modelPropertiesToObject } = await import('./model-DGMe-TTm.js');
-                    const _mod_9 = await import('./db-CQt-gcAl.js');
+                    const _mod_9 = await import('./db-D9K_f5cF.js');
                     const _ns_9 = _mod_9.Y;
                     const { resolveItemModelFileId } = _ns_9;
                     const normalizedModelName = upperFirst(camelCase(modelNameForNew));
@@ -2923,7 +2954,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
         // It ends up in the context below, and later lookups by name (Model.getByName) can't match it.
         const modelName = context.modelName || (metadataRecord.modelType ? upperFirst(camelCase(metadataRecord.modelType)) : undefined);
         // Model names are only unique per schema: pin lookups to the item's own model row.
-        const _mod_10 = await import('./db-CQt-gcAl.js');
+        const _mod_10 = await import('./db-D9K_f5cF.js');
         const _ns_10 = _mod_10.Y;
         const { resolveItemModelFileId, resolveModelRecord } = _ns_10;
         const modelFileId = await resolveItemModelFileId({
@@ -2969,16 +3000,16 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                         };
                         // Merge with schema from file/DB to get validation rules (enum, pattern, etc.) - properties table doesn't store these
                         try {
-                            const { getPropertySchema } = await import('./property-BrXkY1Rg.js');
+                            const { getPropertySchema } = await import('./property-DhmmYAvQ.js');
                             let schemaFromFile = await getPropertySchema(normalizedModelName, propertyName, {
                                 modelFileId: modelRecord?.schemaFileId ?? modelFileId,
                             });
                             if (!schemaFromFile?.validation) {
                                 // Fallback: get validation from schemaData in database (Schema context may not be loaded yet)
-                                const _mod_11 = await import('./BasePathResolver-BdxCSIzn.js');
+                                const _mod_11 = await import('./BasePathResolver-CfSfMW5_.js');
                                 const _ns_11 = _mod_11.Q;
                                 const { schemas: schemasTable } = _ns_11;
-                                const _mod_12 = await import('./BasePathResolver-BdxCSIzn.js');
+                                const _mod_12 = await import('./BasePathResolver-CfSfMW5_.js');
                                 const _ns_12 = _mod_12.R;
                                 const { modelSchemas } = _ns_12;
                                 const modelSchemaRows = await db
@@ -3019,7 +3050,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
         }
         if (!propertyRecordSchema && modelName) {
             try {
-                const _mod_13 = await import('./index-Xl1_4Lmb.js');
+                const _mod_13 = await import('./index-s15q14rm.js');
                 const _ns_13 = _mod_13.f;
                 const { Model } = _ns_13;
                 const { modelPropertiesToObject } = await import('./model-DGMe-TTm.js');
@@ -3396,9 +3427,9 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _analyzeInput = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-BGt4_oPO.js');
+        const schemaMod = await import('./index-CiMEoGu3.js');
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await import('./SchemaValidationService-BPxkfDLU.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-CvRS2HSO.js');
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -3688,7 +3719,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await import('./SchemaValidationService-BPxkfDLU.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-CvRS2HSO.js');
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
             ? normalizeDataType(String(propertyRecordSchema.refValueType))
@@ -4270,7 +4301,7 @@ const saveRelation = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-BGt4_oPO.js');
+        const schemaMod = await import('./index-CiMEoGu3.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -4361,6 +4392,86 @@ const getItemPropertyData = async (props) => {
     return queryRows[0];
 };
 
+/** 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);
+}
+/** 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)
+        .where(eq(metadata.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 local edit: no attestation uid of its own and not derived from one. */
 const isLocalDraft = (row) => !row.uid && row.derivedFromUid == null;
 const saveItemStorage = fromCallback(({ sendBack, input: { context, event } }) => {
@@ -4414,22 +4525,25 @@ const saveItemStorage = fromCallback(({ sendBack, input: { context, event } }) =
             const latest = [...queryRows].sort(compareMetadataRowsLatestFirst)[0];
             propertyData = latest && isLocalDraft(latest) ? latest : undefined;
             if (!propertyData && newValue) {
-                const filename = `${draftSeedUid || draftSeedLocalId}${propertyRecordSchema.filenameSuffix}`;
-                const dir = propertyRecordSchema.localStorageDir?.replace(/^\//, '') || 'files';
-                await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath(dir));
-                const writeToPath = BaseFileManager.getFilesPath(dir, filename);
-                await BaseFileManager.saveFile(writeToPath, newValue);
-                propertyData = await createMetadata({
-                    propertyName,
-                    propertyValue: filename,
-                    modelType: (modelName ?? knownRow?.modelType ?? '').toLowerCase() || undefined,
-                    seedLocalId: draftSeedLocalId,
-                    seedUid: draftSeedUid,
-                    versionLocalId,
-                    versionUid,
+                const target = {
+                    seedId: draftSeedUid || draftSeedLocalId,
                     localStorageDir: propertyRecordSchema.localStorageDir,
-                    refValueType: 'file',
-                }, propertyRecordSchema);
+                    filenameSuffix: propertyRecordSchema.filenameSuffix,
+                };
+                propertyData = await withItemStorageFileLock(getItemStorageFilePath(target), async () => {
+                    const { fileName: filename } = await writeItemStorageFile(target, newValue);
+                    return createMetadata({
+                        propertyName,
+                        propertyValue: filename,
+                        modelType: (modelName ?? knownRow?.modelType ?? '').toLowerCase() || undefined,
+                        seedLocalId: draftSeedLocalId,
+                        seedUid: draftSeedUid,
+                        versionLocalId,
+                        versionUid,
+                        localStorageDir: propertyRecordSchema.localStorageDir,
+                        refValueType: 'file',
+                    }, propertyRecordSchema);
+                });
             }
         }
         else if (propertyData && !isLocalDraft(propertyData)) {
@@ -4438,31 +4552,64 @@ const saveItemStorage = fromCallback(({ sendBack, input: { context, event } }) =
         if (!propertyData) {
             throw new Error(`No metadata row to save ${propertyName} to`);
         }
-        const localStorageDir = propertyRecordSchema.localStorageDir || propertyData.localStorageDir;
-        const fileName = propertyData.refResolvedValue ||
-            `${propertyData.seedUid || propertyData.seedLocalId}${propertyRecordSchema.filenameSuffix}`;
-        if (!localStorageDir || !fileName) {
-            throw new Error(`Missing localStorageDir: ${localStorageDir} or fileName: ${fileName}`);
-        }
-        const dir = localStorageDir.replace(/^\//, '');
-        await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath(dir));
-        const filePath = BaseFileManager.getFilesPath(dir, fileName);
-        try {
-            await BaseFileManager.saveFile(filePath, newValue);
-        }
-        catch (error) {
-            const fs = await BaseFileManager.getFs();
-            fs.writeFileSync(filePath, newValue);
-        }
-        await appDb
-            .update(metadata)
-            .set({
-            refResolvedValue: fileName,
-        })
-            .where(eq(metadata.localId, propertyData.localId));
+        // No storage.path: the `files` directory, as resolveItemStorageChildFile and download assume.
+        const localStorageDirOf = (row) => propertyRecordSchema.localStorageDir || row.localStorageDir || '/files';
+        const fileNameOf = (row) => {
+            if (row.refResolvedValue)
+                return row.refResolvedValue;
+            const seedId = row.seedUid || row.seedLocalId;
+            return seedId ? getItemStorageLocalFileName(seedId, propertyRecordSchema.filenameSuffix) : undefined;
+        };
+        if (!fileNameOf(propertyData)) {
+            throw new Error(`Missing a seed id to name the ${propertyName} file after`);
+        }
+        // Read the row, write the file and update the row under the file's lock, so a conversion of a
+        // legacy row (migration, publish) or another save of this file, in this tab or another, can't
+        // land in between and leave the file with older content than the row says.
+        const saved = await withLockedItemStorageRow(propertyData.localId, (row) => {
+            const fileName = fileNameOf(row);
+            return fileName && BaseFileManager.getFilesPath(getItemStorageSubdir(localStorageDirOf(row)), fileName);
+        }, async (row, filePath) => {
+            const localStorageDir = localStorageDirOf(row);
+            const fileName = fileNameOf(row);
+            try {
+                await writeItemStorageFile({ seedId: row.seedUid || row.seedLocalId || '', localStorageDir, fileName }, newValue);
+            }
+            catch (error) {
+                const fs = await BaseFileManager.getFs();
+                fs.writeFileSync(filePath, newValue);
+            }
+            // 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 = !row.refResolvedValue &&
+                row.propertyValue != null &&
+                row.propertyValue !== '' &&
+                row.propertyValue !== fileName;
+            // The row says where the file is (read back by hydration, the browser's metadata live query
+            // and publish); without localStorageDir the live query would clear it from the context.
+            await appDb
+                .update(metadata)
+                .set({
+                refResolvedValue: fileName,
+                localStorageDir,
+                // Same shape as a row the migration or publish converted (convertVerbatimItemStorageRow).
+                ...(clearsVerbatimValue && { propertyValue: null, refValueType: 'file' }),
+            })
+                .where(eq(metadata.localId, row.localId));
+            return { fileName, localStorageDir };
+        });
+        // The row went away (or lost its seed ids) before the lock was granted.
+        if (!saved)
+            throw new Error(`No metadata row to save ${propertyName} to`);
+        const { fileName, localStorageDir } = saved;
         sendBack({
             type: 'updateContext',
             renderValue: newValue,
+            // Where the file is, right away: localStoragePath (and so publish uploads) must not wait for
+            // the browser's metadata live query, which Node does not have at all.
+            refResolvedValue: fileName,
+            localStorageDir,
             // Point the property at the draft row when the edit moved off a published row.
             ...(propertyData.localId !== localId && { localId: propertyData.localId }),
         });
@@ -4834,10 +4981,10 @@ const getPropertyData = async ({ propertyName, seedLocalId, seedUid, modelName,
     let names = [...getMetadataPropertyNamesForQuery(propertyName)];
     if (modelName) {
         try {
-            const _mod_14 = await import('./index-Xl1_4Lmb.js');
+            const _mod_14 = await import('./index-s15q14rm.js');
             const _ns_14 = _mod_14.f;
             const { Model } = _ns_14;
-            const _mod_15 = await import('./db-CQt-gcAl.js');
+            const _mod_15 = await import('./db-D9K_f5cF.js');
             const _ns_15 = _mod_15.Y;
             const { resolveItemModelFileId } = _ns_15;
             // Model names are only unique per schema: use the seed's own model when it is recorded.
@@ -5028,8 +5175,8 @@ const HTML_PROP_SEED_UID_RE = /^0x[a-fA-F0-9]{64}$/;
  */
 const resolvePropertyRecordSchemaFromSchemaData = async (modelName, propertyName, modelType, schemaName) => {
     try {
-        const _mod_16 = await import('./ClientManager-DDA9956Y.js');
-        const _ns_16 = _mod_16.G;
+        const _mod_16 = await import('./ClientManager-C-QXqUK9.js');
+        const _ns_16 = _mod_16.I;
         const { loadAllSchemasFromDb } = _ns_16;
         const allSchemas = await loadAllSchemasFromDb();
         const modelNameAlt = modelType ? upperFirst(camelCase(modelType)) : '';
@@ -5082,11 +5229,11 @@ hints = {}) => {
         return undefined;
     }
     try {
-        const _mod_17 = await import('./index-Xl1_4Lmb.js');
+        const _mod_17 = await import('./index-s15q14rm.js');
         const _ns_17 = _mod_17.f;
         const { Model } = _ns_17;
         const { modelPropertiesToObject } = await import('./model-DGMe-TTm.js');
-        const _mod_18 = await import('./db-CQt-gcAl.js');
+        const _mod_18 = await import('./db-D9K_f5cF.js');
         const _ns_18 = _mod_18.Y;
         const { resolveItemModelFileId } = _ns_18;
         const modelFileId = await resolveItemModelFileId(hints);
@@ -5246,7 +5393,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await import('./index-BGt4_oPO.js');
+            const schemaMod = await import('./index-CiMEoGu3.js');
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -5417,7 +5564,7 @@ class ItemProperty {
                 const normalizedRefValueType = normalizeDataType(propertyRecordSchema?.refValueType);
                 const propertyNames = getMetadataPropertyNamesForQuery(propertyName, normalizedDataType, normalizedRefValueType);
                 const propertyNameVariant = propertyNames.length > 1 ? propertyNames[1] : undefined;
-                const _mod_19 = await import('./index-CSOQFAOn.js');
+                const _mod_19 = await import('./index-DglvthOk.js');
                 const _ns_19 = _mod_19.s;
                 const seedSchemaMod = _ns_19;
                 const { metadata } = seedSchemaMod;
@@ -5633,7 +5780,7 @@ class ItemProperty {
             const ctx = this._service.getSnapshot().context;
             let modelFileId;
             try {
-                const _mod_20 = await import('./db-CQt-gcAl.js');
+                const _mod_20 = await import('./db-D9K_f5cF.js');
                 const _ns_20 = _mod_20.Y;
                 const { resolveItemModelFileId } = _ns_20;
                 modelFileId = await resolveItemModelFileId({
@@ -5996,7 +6143,7 @@ class ItemProperty {
         const propertiesData = await getItemProperties({ seedLocalId, seedUid });
         const instances = [];
         const seenNormalized = new Set();
-        const _mod_21 = await import('./db-CQt-gcAl.js');
+        const _mod_21 = await import('./db-D9K_f5cF.js');
         const _ns_21 = _mod_21.Y;
         const { resolveItemModelFileId } = _ns_21;
         const itemModelFileId = await resolveItemModelFileId({ seedLocalId, seedUid });
@@ -6014,7 +6161,7 @@ class ItemProperty {
             }
             else if (baseName) {
                 try {
-                    const _mod_22 = await import('./index-Xl1_4Lmb.js');
+                    const _mod_22 = await import('./index-s15q14rm.js');
                     const _ns_22 = _mod_22.f;
                     const { Model } = _ns_22;
                     const { modelPropertiesToObject } = await import('./model-DGMe-TTm.js');
@@ -6031,7 +6178,7 @@ class ItemProperty {
             }
             if (modelName && propertyName) {
                 try {
-                    const _mod_23 = await import('./index-Xl1_4Lmb.js');
+                    const _mod_23 = await import('./index-s15q14rm.js');
                     const _ns_23 = _mod_23.f;
                     const { Model } = _ns_23;
                     const { modelPropertiesToObject } = await import('./model-DGMe-TTm.js');
@@ -6353,7 +6500,7 @@ class ItemProperty {
                 if (!propertyName || (!seedLocalId && !seedUid))
                     return;
                 if (db) {
-                    const _mod_24 = await import('./index-CSOQFAOn.js');
+                    const _mod_24 = await import('./index-DglvthOk.js');
                     const _ns_24 = _mod_24.s;
                     const seedSchemaMod = _ns_24;
                     const { metadata } = seedSchemaMod;
@@ -6399,7 +6546,7 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
     }
     const seedType = toSnakeCase(modelName);
     // Dynamic import to break circular dependency
-    const _mod_25 = await import('./index-Xl1_4Lmb.js');
+    const _mod_25 = await import('./index-s15q14rm.js');
     const _ns_25 = _mod_25.f;
     const modelMod = _ns_25;
     const { Model } = modelMod;
@@ -6420,13 +6567,38 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
     for (const propertyName of allPropertyNames) {
         const propertyValue = propertyData[propertyName];
         const propertyRecordSchema = propertySchemas?.[propertyName];
-        await createMetadata({
+        // ItemStorage content lives in the property's file (`<seedLocalId><extension>`), as a save puts
+        // it; the row records where. Stored verbatim in the row, publish would never upload it.
+        const isItemStorageValue = propertyRecordSchema?.storageType === 'ItemStorage' &&
+            propertyValue != null &&
+            propertyValue !== '';
+        const insertRow = (storageFields) => createMetadata({
             seedLocalId: newSeedId,
             versionLocalId: newVersionId,
             propertyName,
-            propertyValue,
+            propertyValue: storageFields ? undefined : propertyValue,
+            ...storageFields,
             modelName,
         }, propertyRecordSchema, { skipValidation: true, modelFileId });
+        if (!isItemStorageValue) {
+            await insertRow();
+            continue;
+        }
+        // File and row under the file's lock, like every writer of a local draft's file (see
+        // withItemStorageFileLock). The seed is new, so nothing else should be writing it yet.
+        const target = {
+            seedId: newSeedId,
+            localStorageDir: propertyRecordSchema.localStorageDir,
+            filenameSuffix: propertyRecordSchema.filenameSuffix,
+        };
+        await withItemStorageFileLock(getItemStorageFilePath(target), async () => {
+            const written = await writeItemStorageFile(target, propertyValue);
+            await insertRow({
+                refResolvedValue: written.fileName,
+                localStorageDir: written.localStorageDir,
+                refValueType: 'file',
+            });
+        });
     }
     return {
         modelName,
@@ -6557,7 +6729,7 @@ const getModel = () => {
         // the fragile `import(...).then(n => n.X)` chunk-namespace pattern.
         if (!modelImportPromise) {
             modelImportPromise = (async () => {
-                const _mod_26 = await import('./index-Xl1_4Lmb.js');
+                const _mod_26 = await import('./index-s15q14rm.js');
                 const _ns_26 = _mod_26.f;
                 const mod = _ns_26;
                 ModelClass = mod.Model;
@@ -6590,10 +6762,16 @@ const getModel = () => {
 };
 // Define tracked properties for the Proxy
 // These properties will be read from/written to the actor context
-/** Raw File/Image/Html content (not already a storage seed reference) needs ItemProperty.save(). */
-function needsStorageSavePipeline(dataType, value) {
+/**
+ * Initial values that need ItemProperty.save() rather than a verbatim metadata row: raw File/Image/Html
+ * content (not already a storage seed reference) becomes a storage seed, and an ItemStorage property's
+ * content goes into its file (`<seedLocalId><extension>`), where publish and reads look for it.
+ */
+function needsStorageSavePipeline(dataType, value, storageType) {
     if (value == null || value === '')
         return false;
+    if (storageType === 'ItemStorage')
+        return true;
     const isStorageType = isDataType(dataType, ModelPropertyDataTypes.File) ||
         isDataType(dataType, ModelPropertyDataTypes.Image) ||
         isDataType(dataType, ModelPropertyDataTypes.Html);
@@ -6706,12 +6884,12 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const getPublishUploadsMod = await import('./getPublishUploads-DHP01KgU.js');
+            const getPublishUploadsMod = await import('./getPublishUploads-BEqRiKIS.js');
             const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this, [], undefined, options);
         };
         this.getPublishPayload = async (uploadedTransactions, options) => {
-            const _mod_27 = await import('./getPublishPayload-Xl3sRkR-.js');
+            const _mod_27 = await import('./getPublishPayload-BHrxVtzY.js');
             const _ns_27 = _mod_27.g;
             const getPublishPayloadMod = _ns_27;
             const { getPublishPayload } = getPublishPayloadMod;
@@ -7243,10 +7421,11 @@ class Item {
         // Get property names directly from database to make Item independent from Model
         let propertyNames = [];
         const dataTypeByPropertyName = new Map();
+        const storageTypeByPropertyName = new Map();
         const db = BaseDb.getAppDb();
         if (db && props.modelName) {
             // Model names are only unique per schema: resolve the exact models row from the most specific scope.
-            const _mod_28 = await import('./db-CQt-gcAl.js');
+            const _mod_28 = await import('./db-D9K_f5cF.js');
             const _ns_28 = _mod_28.Y;
             const { resolveModelRecord } = _ns_28;
             const modelRecord = await resolveModelRecord(props.modelName, {
@@ -7260,10 +7439,10 @@ class Item {
             // Scope the constructor's Model lookup to this model's schema (as getItemData does on reload),
             // so a same-named model cached from another schema can't supply the property set.
             if (modelRecord && !props.schemaName) {
-                const _mod_29 = await import('./BasePathResolver-BdxCSIzn.js');
+                const _mod_29 = await import('./BasePathResolver-CfSfMW5_.js');
                 const _ns_29 = _mod_29.R;
                 const { modelSchemas } = _ns_29;
-                const _mod_30 = await import('./BasePathResolver-BdxCSIzn.js');
+                const _mod_30 = await import('./BasePathResolver-CfSfMW5_.js');
                 const _ns_30 = _mod_30.Q;
                 const { schemas: schemasTable } = _ns_30;
                 const schemaRows = await db
@@ -7278,13 +7457,19 @@ class Item {
             }
             if (modelRecords.length > 0 && modelRecords[0].id) {
                 const propertyRecords = await db
-                    .select({ name: properties.name, dataType: properties.dataType })
+                    .select({
+                    name: properties.name,
+                    dataType: properties.dataType,
+                    storageType: properties.storageType,
+                })
                     .from(properties)
                     .where(eq(properties.modelId, modelRecords[0].id));
                 propertyNames = propertyRecords.map((r) => r.name).filter((name) => Boolean(name));
                 for (const r of propertyRecords) {
                     if (r.name && r.dataType)
                         dataTypeByPropertyName.set(r.name, r.dataType);
+                    if (r.name && r.storageType)
+                        storageTypeByPropertyName.set(r.name, r.storageType);
                 }
             }
         }
@@ -7293,7 +7478,8 @@ class Item {
             modelFileId: props.modelFileId,
         };
         // File/Image/Html values that are raw content (html string, data URI, URL, File) must go through
-        // the property's save pipeline to become storage seeds; createNewItem would store them verbatim.
+        // the property's save pipeline to become storage seeds, and ItemStorage values to be written to
+        // their file with the property context pointing at it (as `prop.value = v; await prop.save()`).
         const pipelineValues = [];
         // Only include properties that are in the model schema
         // Exclude modelInstance, modelName, and schemaName as they're metadata, not item properties
@@ -7303,7 +7489,7 @@ class Item {
                 continue;
             }
             if (propertyNames.length === 0 || propertyNames.includes(key)) {
-                if (needsStorageSavePipeline(dataTypeByPropertyName.get(key), value)) {
+                if (needsStorageSavePipeline(dataTypeByPropertyName.get(key), value, storageTypeByPropertyName.get(key))) {
                     pipelineValues.push([key, value]);
                     continue;
                 }
@@ -7435,7 +7621,7 @@ class Item {
         return proxiedInstance;
     }
     /**
-     * Run each File/Image/Html initial value through its ItemProperty save pipeline (sequentially, to
+     * Run each File/Image/Html/ItemStorage initial value through its ItemProperty save pipeline (sequentially, to
      * avoid SQLite write contention). Rejects on the first failure; the item itself has been created.
      */
     static async savePipelineValues(item, pipelineValues, timeout) {
@@ -7609,7 +7795,7 @@ class Item {
         if (!appDb || Item.instanceCache.size === 0) {
             return;
         }
-        const _mod_31 = await import('./index-CSOQFAOn.js');
+        const _mod_31 = await import('./index-DglvthOk.js');
         const _ns_31 = _mod_31.s;
         const { metadata } = _ns_31;
         const { eq, and } = await import('drizzle-orm');
@@ -8068,7 +8254,7 @@ class Item {
                 itemActor.send(event);
             };
             try {
-                const _mod_32 = await import('./index-CSOQFAOn.js');
+                const _mod_32 = await import('./index-DglvthOk.js');
                 const _ns_32 = _mod_32.s;
                 const seedSchemaMod = _ns_32;
                 const { seeds, versions, metadata } = seedSchemaMod;
@@ -8421,5 +8607,5 @@ var Item$1 = /*#__PURE__*/Object.freeze({
     Item: Item
 });
 
-export { getRevokeExecutor as A, getUploadExecutor as B, ClientManagerState as C, getVersionData$1 as D, isItemOwned as E, isLocalUnsealedDraft as F, isSeedRowOwned as G, ownedPublisherSql as H, Item as I, pickLatestMetadataRowPerProperty as J, propertyMachine as K, publisherInAddressListSql as L, METADATA_LATEST_FIRST_ORDER_SQL as M, publisherIsInOwnedSet as N, setAdditionalSyncAddresses as O, setGetPublisherForNewSeeds as P, setRevokeExecutor as Q, setUploadExecutor as R, getInvariantSafePropertyDescriptor as S, clearDestroySubscriptions as T, unloadEntity as U, ClientManagerEvents as V, resolvePublisherFromSeedRow as W, getPropertyData$1 as X, Item$1 as Y, getEasSchemaUidForModel as a, getLatestPublishedVersionRow as b, chunkValues as c, rowsPerInsert as d, getGetAdditionalSyncAddresses as e, ItemProperty as f, getItemData as g, ItemPropertySaveValidationError as h, isVersionRevoked as i, waitForEntityIdle as j, createReactiveProxy as k, listRelationEasPropertyName as l, findEntity as m, forceRemoveFromCaches as n, runDestroyLifecycle as o, parseListPropertyValueFromStorage as p, compareMetadataRowsLatestFirst as q, resolveStorageNameToSchemaName as r, selectInBatches as s, isPublishedMetadataRow as t, MachineIds as u, createNewItem as v, writeInBatches as w, getEasSchemaForItemProperty as x, getGetPublisherForNewSeeds as y, getMetadataLatest as z };
-//# sourceMappingURL=Item-D4FigtYS.js.map
+export { writeItemStorageFile as $, getRevokeExecutor as A, getUploadExecutor as B, ClientManagerState as C, getVersionData$1 as D, isItemOwned as E, isLocalUnsealedDraft as F, isSeedRowOwned as G, localUnsealedDraftSql as H, Item as I, ownedPublisherSql as J, ownedSeedsSql as K, pickLatestMetadataRowPerProperty as L, METADATA_LATEST_FIRST_ORDER_SQL as M, placeholderUidSql as N, propertyMachine as O, publisherInAddressListSql as P, publisherIsInOwnedSet as Q, setAdditionalSyncAddresses as R, setGetPublisherForNewSeeds as S, setRevokeExecutor as T, setUploadExecutor as U, getInvariantSafePropertyDescriptor as V, clearDestroySubscriptions as W, unloadEntity as X, ClientManagerEvents as Y, withLockedItemStorageRow as Z, getItemStorageFilePath as _, getEasSchemaUidForModel as a, resolvePublisherFromSeedRow as a0, getPropertyData$1 as a1, Item$1 as a2, getLatestPublishedVersionRow as b, compareMetadataRowsLatestFirst as c, chunkValues as d, rowsPerInsert as e, getGetAdditionalSyncAddresses as f, getItemData as g, ItemProperty as h, ItemPropertySaveValidationError as i, isVersionRevoked as j, waitForEntityIdle as k, listRelationEasPropertyName as l, createReactiveProxy as m, findEntity as n, forceRemoveFromCaches as o, parseListPropertyValueFromStorage as p, runDestroyLifecycle as q, resolveStorageNameToSchemaName as r, selectInBatches as s, isPublishedMetadataRow as t, MachineIds as u, createNewItem as v, writeInBatches as w, getEasSchemaForItemProperty as x, getGetPublisherForNewSeeds as y, getMetadataLatest as z };
+//# sourceMappingURL=Item-C7sUUu2B.js.map