@seedprotocol/sdk 0.7.5-next.850.g9ab585b → 0.7.5

package/dist/{Item-TMrVEPeX.js → Item-DTJPMjFk.js}

@@ -1,5 +1,5 @@
 import { waitFor, fromCallback, setup, assign, stateIn, createActor, isMachineSnapshot } from 'xstate';
-import { E as BaseDb, C as versions, m as metadata, A as seeds, F as resolveStorageNameToSchemaName, a_ as toSchemaPropertyName, z as schemas, s as models, q as modelSchemas, aY as getOwnedAddressesFromDb, a3 as ZERO_BYTES32, aG as normalizeAddressList, ak as normalizeHexAddress, aD as getAddressesForItemsFilter, a7 as INTERNAL_PROPERTY_NAMES, K as BaseFileManager, a$ as getStorageTransactionIdForSeedUid, b0 as convertTxIdToImage, i as isDataType, af as normalizePublisher, n as normalizeDataType, b1 as getMetadataPropertyNamesForQuery, aC as ensureImageLocal, au as ImageSize, b2 as downloadTransactionIdWithDedupe, b3 as resolveMetadataRecord, u as properties, M as ModelPropertyDataTypes, aj as generateId, aa as INTERNAL_DATA_TYPES, r as modelUids, ab as listRelationEasPropertyName, ac as easPropertyNameForPublish, N as resolveItemModelFileId, b4 as getPropertyIdForSchemaFileId, L as getPropertyIdForModelAndName, al as toMetadataPropertyName, b5 as getDataTypeFromString, b6 as getMimeType, ar as INTERNAL_STORAGE_MODEL_FILE_IDS, W as getItemStorageSubdir, X as getItemStorageLocalFileName, g as normalizePropertyRecordSchema, b7 as listRelationStoragePropertyName, b8 as PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, $ as getCorrectId, H as eventEmitter, b9 as getAlternatePropertyNameForInstanceLookup, a8 as isStorageSeedRef } from './BasePathResolver-CsZHPrk9.js';
+import { B as BaseDb, F as versions, m as metadata, C as seeds, G as resolveStorageNameToSchemaName, a_ as toSchemaPropertyName, A as schemas, t as models, r as modelSchemas, aY as getOwnedAddressesFromDb, a5 as ZERO_BYTES32, aG as normalizeAddressList, am as normalizeHexAddress, aD as getAddressesForItemsFilter, a9 as INTERNAL_PROPERTY_NAMES, h as BaseFileManager, a$ as getStorageTransactionIdForSeedUid, b0 as convertTxIdToImage, i as isDataType, ah as normalizePublisher, n as normalizeDataType, b1 as getMetadataPropertyNamesForQuery, aC as ensureImageLocal, au as ImageSize, b2 as downloadTransactionIdWithDedupe, b3 as resolveMetadataRecord, v as properties, M as ModelPropertyDataTypes, al as generateId, ac as INTERNAL_DATA_TYPES, s as modelUids, ad as listRelationEasPropertyName, ae as easPropertyNameForPublish, N as resolveItemModelFileId, b4 as getPropertyIdForSchemaFileId, L as getPropertyIdForModelAndName, an as toMetadataPropertyName, b5 as getDataTypeFromString, b6 as getMimeType, _ as INTERNAL_STORAGE_MODEL_FILE_IDS, a2 as getItemStorageSubdir, a3 as getItemStorageLocalFileName, g as normalizePropertyRecordSchema, b7 as listRelationStoragePropertyName, b8 as PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, R as getCorrectId, I as eventEmitter, b9 as getAlternatePropertyNameForInstanceLookup, aa as isStorageSeedRef } from './BasePathResolver-CBTXCMFL.js';
 import { or, isNull, eq, max, count, and, getTableColumns, sql, desc, inArray, isNotNull, gt } from 'drizzle-orm';
 import debug from 'debug';
 import { BehaviorSubject } from 'rxjs';
@@ -7,7 +7,7 @@ import pluralize from 'pluralize';
 import { startCase, upperFirst, camelCase, orderBy } from 'lodash-es';
 import { isValidEasAttestationUid, easName, isPlaceholderUid, BaseQueryClient, BaseEasClient, GET_SCHEMAS, getEasSchemaUidForSchemaDefinition, getSchemaUidForModelFromCache, setSchemaUidForModel, cachedSchemaLookup, getEasSchemaUidForExactDefinition } from '@seedprotocol/eas';
 import { fetchArweaveRawTextAcrossGateways } from '@seedprotocol/arweave';
-import { d as notifyFileSaved, f as withTabLock } from './tabEvents-BEAmMncP.js';
+import { d as notifyFileSaved, f as withTabLock } from './tabEvents-BGBYV65P.js';
 import { modelPropertiesToObject } from './model-oHA3YhOd.js';
 
 /**
@@ -580,7 +580,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-oHA3YhOd.js');
-        const _mod_0 = await import('./errors-CWKup8tw.js');
+        const _mod_0 = await import('./errors-CIrbsN_i.js');
         const _ns_0 = _mod_0.h;
         const { Model } = _ns_0;
         // Resolve Model and build property schemas (use getByNameAsync for models not yet in cache)
@@ -598,7 +598,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             const schemaNameToTry = schemaName ?? model?.schemaName;
             if (schemaNameToTry) {
                 try {
-                    const _mod_1 = await import('./Schema-VLenyJDy.js');
+                    const _mod_1 = await import('./Schema-8DxGcORY.js');
                     const _ns_1 = _mod_1.b;
                     const { Schema } = _ns_1;
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false });
@@ -614,8 +614,8 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             }
             if (Object.keys(propertySchemas).length === 0) {
                 try {
-                    const _mod_2 = await import('./ClientManager-DETTj0_z.js');
-                    const _ns_2 = _mod_2.L;
+                    const _mod_2 = await import('./ClientManager-DRf4uuei.js');
+                    const _ns_2 = _mod_2.M;
                     const { loadAllSchemasFromDb } = _ns_2;
                     const allSchemas = await loadAllSchemasFromDb();
                     for (const { schema: schemaFile } of allSchemas) {
@@ -635,10 +635,10 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             }
             if (Object.keys(propertySchemas).length === 0) {
                 try {
-                    const _mod_3 = await import('./ClientManager-DETTj0_z.js');
-                    const _ns_3 = _mod_3.L;
+                    const _mod_3 = await import('./ClientManager-DRf4uuei.js');
+                    const _ns_3 = _mod_3.M;
                     const { listCompleteSchemaFiles } = _ns_3;
-                    const _mod_4 = await import('./BasePathResolver-CsZHPrk9.js');
+                    const _mod_4 = await import('./BasePathResolver-CBTXCMFL.js');
                     const _ns_4 = _mod_4.bc;
                     const { BaseFileManager } = _ns_4;
                     const schemaFiles = await listCompleteSchemaFiles();
@@ -659,7 +659,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await import('./index-CXkcz4hT.js');
+                const schemaMod = await import('./index-CMxEil8T.js');
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
@@ -676,7 +676,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-tgPI5hMu.js');
+        const { normalizePropertyRecordSchema } = await import('./property-lz9yIpyA.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
@@ -709,7 +709,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-CXkcz4hT.js');
+                    const schemaMod = await import('./index-CMxEil8T.js');
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -1595,14 +1595,14 @@ function publisherIsInOwnedSet(publisher, ownedAddresses) {
 }
 /**
  * Shared ownership predicate.
- * - Session has owned addresses: only a publisher in that set is owned (null is never owned).
- * - Session has no owned addresses: local unsealed drafts are owned so pre-connect authoring works.
+ * - A local unsealed draft (never given a publisher) is owned whatever the owned addresses are:
+ *   it belongs to no wallet yet, and the next wallet to connect claims it (claimUnpublishedDrafts).
+ * - Any other row is owned when its publisher (or attester) is in the owned addresses.
  */
 function isSeedRowOwned(row, ownedAddresses) {
     const publisher = resolvePublisherFromSeedRow(row);
-    if (ownedAddresses.length === 0) {
-        return isLocalUnsealedDraft({ ...row, publisher: publisher ?? row.publisher });
-    }
+    if (isLocalUnsealedDraft({ ...row, publisher: publisher ?? row.publisher }))
+        return true;
     return publisherIsInOwnedSet(publisher, ownedAddresses);
 }
 /**
@@ -1635,8 +1635,8 @@ function localUnsealedDraftSql() {
 }
 /**
  * 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
+ * - Local unsealed drafts always pass.
+ * - Otherwise `lower(trim(publisher))` is in the owned set, or, when publisher is blank, the
  *   `attestationRaw.attester` ({@link resolvePublisherFromSeedRow}). `json_valid` guards
  *   `json_extract`, which throws on malformed JSON.
  */
@@ -1646,17 +1646,13 @@ function ownedSeedsSql(ownedAddresses) {
         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)));
+    return or(localUnsealedDraftSql(), 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).
- *
- * When the session has owned addresses, only a matching publisher is owned —
- * `publisher IS NULL` is not treated as owned. Call `claimUnpublishedDrafts`
- * after connect to stamp local drafts.
- *
- * When owned is empty, local unsealed drafts (no publisher, no real uid, no
- * attestationRaw) are still owned so create/edit works before a wallet is connected.
+ * Checks if the current user owns the item: its publisher is in the persisted owned addresses,
+ * or it's a local unsealed draft (no publisher, no real uid, no attestationRaw). Such a draft
+ * was made with no wallet connected and is editable until `claimUnpublishedDrafts`, which
+ * connecting a wallet calls, gives it that wallet as publisher.
  *
  * Does not include `getAdditionalSyncAddresses` (those are extra EAS indexers,
  * not wallets the user controls).
@@ -1715,7 +1711,7 @@ const getItemsData = async ({ modelName, modelFileId, schemaName, deleted, inclu
         conditions.push(eq(seeds.type, easName(modelName)));
     }
     if (!modelFileId && schemaName && modelName) {
-        const _mod_5 = await import('./BasePathResolver-CsZHPrk9.js');
+        const _mod_5 = await import('./BasePathResolver-CBTXCMFL.js');
         const _ns_5 = _mod_5.bf;
         const { resolveModelRecord } = _ns_5;
         modelFileId = (await resolveModelRecord(modelName, { schemaName }))?.schemaFileId ?? undefined;
@@ -1998,7 +1994,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-CXkcz4hT.js');
+        const schemaMod = await import('./index-CMxEil8T.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -2433,7 +2429,7 @@ async function readHtmlBodyFromChildStorageArweave(seedLocalId) {
         /* offline / bad tx id */
     }
     try {
-        const _mod_6 = await import('./BasePathResolver-CsZHPrk9.js');
+        const _mod_6 = await import('./BasePathResolver-CBTXCMFL.js');
         const _ns_6 = _mod_6.bh;
         const { downloadTransactionIdWithDedupe } = _ns_6;
         await downloadTransactionIdWithDedupe(txId);
@@ -2494,7 +2490,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-CXkcz4hT.js');
+        const schemaMod = await import('./index-CMxEil8T.js');
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -2775,11 +2771,11 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
             const modelNameForNew = context.modelName;
             if (modelNameForNew) {
                 try {
-                    const _mod_7 = await import('./errors-CWKup8tw.js');
+                    const _mod_7 = await import('./errors-CIrbsN_i.js');
                     const _ns_7 = _mod_7.h;
                     const { Model } = _ns_7;
                     const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
-                    const _mod_8 = await import('./BasePathResolver-CsZHPrk9.js');
+                    const _mod_8 = await import('./BasePathResolver-CBTXCMFL.js');
                     const _ns_8 = _mod_8.bf;
                     const { resolveItemModelFileId } = _ns_8;
                     const normalizedModelName = upperFirst(camelCase(modelNameForNew));
@@ -2833,7 +2829,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_9 = await import('./BasePathResolver-CsZHPrk9.js');
+        const _mod_9 = await import('./BasePathResolver-CBTXCMFL.js');
         const _ns_9 = _mod_9.bf;
         const { resolveItemModelFileId, resolveModelRecord } = _ns_9;
         const modelFileId = await resolveItemModelFileId({
@@ -2878,7 +2874,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                             required: propRecord.required ?? undefined,
                         };
                         // Validation rules (enum, pattern, ...) aren't in the properties table
-                        const { resolvePropertyValidationRules } = await import('./propertyValidationRules-BLVxTejW.js');
+                        const { resolvePropertyValidationRules } = await import('./propertyValidationRules-LuIwoQoJ.js');
                         const validation = await resolvePropertyValidationRules(normalizedModelName, propertyName, {
                             modelFileId: modelRecord?.schemaFileId ?? modelFileId,
                         });
@@ -2895,7 +2891,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
         }
         if (!propertyRecordSchema && modelName) {
             try {
-                const _mod_10 = await import('./errors-CWKup8tw.js');
+                const _mod_10 = await import('./errors-CIrbsN_i.js');
                 const _ns_10 = _mod_10.h;
                 const { Model } = _ns_10;
                 const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
@@ -3117,6 +3113,27 @@ const getVersionData = async ({ localId, seedLocalId, uid, }) => {
     return queryRows[0];
 };
 
+/**
+ * The publisher a seed's version and property rows take: the seed's own (its `publisher`, else the
+ * attester of its stored attestation). Undefined for a draft that belongs to no wallet yet; those
+ * rows are then claimed together with their seed (claimUnpublishedDrafts).
+ */
+async function getSeedPublisher(seedLocalId) {
+    if (!seedLocalId)
+        return undefined;
+    const appDb = BaseDb.getAppDb();
+    if (!appDb)
+        return undefined;
+    const [row] = await appDb
+        .select({ publisher: seeds.publisher, attestationRaw: seeds.attestationRaw, uid: seeds.uid })
+        .from(seeds)
+        .where(eq(seeds.localId, seedLocalId))
+        .limit(1);
+    if (!row)
+        return undefined;
+    return normalizePublisher(resolvePublisherFromSeedRow(row));
+}
+
 const logger$2 = debug('seedSdk:write:updateItemPropertyValue');
 const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, newValue, seedUid, seedLocalId, modelName, refSeedType, refResolvedValue, refResolvedDisplayValue, versionLocalId, versionUid, schemaUid, localStorageDir, dataType, refValueType, }) => {
     if (!localIdParam && !seedLocalId) {
@@ -3168,10 +3185,13 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
     }
     if (rows && rows.length > 0) {
         const { localId, uid, propertyName: propertyNameFromDb, propertyValue: propertyValueFromDb, modelType, seedUid, seedLocalId: seedLocalIdFromDb, versionLocalId, versionUid, schemaUid, easDataType, localStorageDir: localStorageDirFromDb, refSeedType: refSeedTypeFromDb, refResolvedValue: refResolvedValueFromDb, refResolvedDisplayValue: refResolvedDisplayValueFromDb, } = rows[0];
+        // Stored model types are the model's EAS name (ADR 0008): `blog_post` for BlogPost.
+        const modelTypeForName = modelName ? easName(modelName) : undefined;
         if (propertyValueFromDb === newValue &&
-            modelType === modelName?.toLowerCase() &&
-            refSeedTypeFromDb === refSeedType &&
-            refResolvedValueFromDb === refResolvedValue) {
+            modelType === modelTypeForName &&
+            // The DB holds null where callers leave a field out (plain values pass no ref fields).
+            (refSeedTypeFromDb ?? null) === (refSeedType ?? null) &&
+            (refResolvedValueFromDb ?? null) === (refResolvedValue ?? null)) {
             logger$2(`[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`);
             return;
         }
@@ -3204,11 +3224,14 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
         const versionDataFromDb = versionLocalId ? await getVersionData({ localId: versionLocalId }) : null;
         // Here we don't have a local-only record so we need to create a new one
         const newLocalId = generateId();
+        // The row belongs to its seed's wallet, like createMetadata's.
+        const publisher = await getSeedPublisher(seedLocalIdFromDb ?? seedLocalId);
         await appDb.insert(metadata).values({
             localId: newLocalId,
+            ...(publisher && { publisher }),
             propertyName: propertyNameFromDb,
             propertyValue: safeNewValue ?? null,
-            modelType: modelType || modelName?.toLowerCase() || null,
+            modelType: modelType || modelTypeForName || null,
             seedUid: seedDataFromDb?.uid || null,
             seedLocalId: seedLocalIdFromDb,
             versionLocalId,
@@ -3240,11 +3263,13 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
             versionUid = versionData.uid;
         }
     }
+    const publisher = await getSeedPublisher(seedLocalId);
     await appDb.insert(metadata).values({
         localId: newLocalId,
+        ...(publisher && { publisher }),
         propertyName,
         propertyValue: safeNewValue ?? null,
-        modelType: modelName?.toLowerCase() || '',
+        modelType: modelName ? easName(modelName) : '',
         seedUid: seedUid || null,
         seedLocalId: seedLocalId || '',
         versionLocalId: versionLocalId || '',
@@ -3329,9 +3354,9 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
             return false;
         }
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-CXkcz4hT.js');
+        const schemaMod = await import('./index-CMxEil8T.js');
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await import('./SchemaValidationService-CLGadxgf.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-CE92y1TT.js');
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -3522,21 +3547,22 @@ const getEasSchemaUidForModel = async (modelName) => {
             return uid;
         }
     }
-    const modeType = modelName.toLowerCase();
+    // The name publish registers the model's schema under (ADR 0008): `blog_post` for BlogPost.
+    const modelType = easName(modelName);
     let easSchemaUid;
     try {
         // Misses are cached too (most local models have no EAS schema).
-        easSchemaUid = await cachedSchemaLookup(`model:${modeType}`, async () => {
+        easSchemaUid = await cachedSchemaLookup(`model:${modelType}`, async () => {
             const queryClient = BaseQueryClient.getQueryClient();
             const easClient = BaseEasClient.getEasClient();
             const modelSchemaQuery = await queryClient.fetchQuery({
-                queryKey: [`getEasSchemaUidForModel`, modeType],
+                queryKey: [`getEasSchemaUidForModel`, modelType],
                 queryFn: async () => easClient.request(GET_SCHEMAS, {
                     where: {
                         schemaNames: {
                             some: {
                                 name: {
-                                    equals: modeType,
+                                    equals: modelType,
                                 },
                             },
                         },
@@ -3563,7 +3589,15 @@ const createSeed = async ({ type, seedUid, modelFileId }) => {
     // if the EAS schema hasn't been published yet
     const appDb = BaseDb.getAppDb();
     const newSeedLocalId = generateId();
-    const publisher = normalizePublisher(await getPublisherForNewSeedsWithTimeout());
+    // When nothing supplies a publisher (no getter, as in Node scripts, or no wallet connected yet)
+    // and exactly one owned address is set, the draft is that address's. With several, which one would
+    // publish isn't known: the draft gets none, stays editable, and the next wallet to connect claims it.
+    let publisher = normalizePublisher(await getPublisherForNewSeedsWithTimeout());
+    if (!publisher) {
+        const owned = await getOwnedAddressesFromDb();
+        if (owned.length === 1)
+            publisher = normalizePublisher(owned[0]);
+    }
     await appDb.insert(seeds).values({
         localId: newSeedLocalId,
         type,
@@ -3579,7 +3613,8 @@ const createSeed = async ({ type, seedUid, modelFileId }) => {
 const createVersion = async ({ seedLocalId, seedUid, seedType, uid, }) => {
     const appDb = BaseDb.getAppDb();
     const newVersionLocalId = generateId();
-    const publisher = normalizePublisher(await getPublisherForNewSeedsWithTimeout());
+    // A version belongs to its seed's wallet (none yet for a draft made with no wallet connected).
+    const publisher = await getSeedPublisher(seedLocalId);
     await appDb.insert(versions).values({
         localId: newVersionLocalId,
         createdAt: Date.now(),
@@ -3603,7 +3638,8 @@ class MetadataValidationError extends Error {
 const createMetadata = async (metadataValues, propertyRecordSchema, options) => {
     const appDb = BaseDb.getAppDb();
     metadataValues.localId = generateId();
-    const publisher = normalizePublisher(await getPublisherForNewSeedsWithTimeout());
+    // A property row belongs to its seed's wallet (none yet for a draft made with no wallet connected).
+    const publisher = await getSeedPublisher(metadataValues.seedLocalId);
     if (publisher) {
         metadataValues.publisher = publisher;
     }
@@ -3643,7 +3679,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await import('./SchemaValidationService-CLGadxgf.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-CE92y1TT.js');
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
             ? normalizeDataType(String(propertyRecordSchema.refValueType))
@@ -4256,7 +4292,7 @@ const saveRelation = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-CXkcz4hT.js');
+        const schemaMod = await import('./index-CMxEil8T.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -4490,7 +4526,7 @@ const saveItemStorage = fromCallback(({ sendBack, input: { context, event } }) =
                     return createMetadata({
                         propertyName,
                         propertyValue: filename,
-                        modelType: (modelName ?? knownRow?.modelType ?? '').toLowerCase() || undefined,
+                        modelType: (modelName ? easName(modelName) : knownRow?.modelType) || undefined,
                         seedLocalId: draftSeedLocalId,
                         seedUid: draftSeedUid,
                         versionLocalId,
@@ -4975,10 +5011,10 @@ const getPropertyData = async ({ propertyName, seedLocalId, seedUid, modelName,
     let names = [...getMetadataPropertyNamesForQuery(propertyName)];
     if (modelName) {
         try {
-            const _mod_11 = await import('./errors-CWKup8tw.js');
+            const _mod_11 = await import('./errors-CIrbsN_i.js');
             const _ns_11 = _mod_11.h;
             const { Model } = _ns_11;
-            const _mod_12 = await import('./BasePathResolver-CsZHPrk9.js');
+            const _mod_12 = await import('./BasePathResolver-CBTXCMFL.js');
             const _ns_12 = _mod_12.bf;
             const { resolveItemModelFileId } = _ns_12;
             // Model names are only unique per schema: use the seed's own model when it is recorded.
@@ -5179,8 +5215,8 @@ const HTML_PROP_SEED_UID_RE = /^0x[a-fA-F0-9]{64}$/;
  */
 const resolvePropertyRecordSchemaFromSchemaData = async (modelName, propertyName, modelType, schemaName) => {
     try {
-        const _mod_13 = await import('./ClientManager-DETTj0_z.js');
-        const _ns_13 = _mod_13.L;
+        const _mod_13 = await import('./ClientManager-DRf4uuei.js');
+        const _ns_13 = _mod_13.M;
         const { loadAllSchemasFromDb } = _ns_13;
         const allSchemas = await loadAllSchemasFromDb();
         const modelNameAlt = modelType ? upperFirst(camelCase(modelType)) : '';
@@ -5233,11 +5269,11 @@ hints = {}) => {
         return undefined;
     }
     try {
-        const _mod_14 = await import('./errors-CWKup8tw.js');
+        const _mod_14 = await import('./errors-CIrbsN_i.js');
         const _ns_14 = _mod_14.h;
         const { Model } = _ns_14;
         const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
-        const _mod_15 = await import('./BasePathResolver-CsZHPrk9.js');
+        const _mod_15 = await import('./BasePathResolver-CBTXCMFL.js');
         const _ns_15 = _mod_15.bf;
         const { resolveItemModelFileId } = _ns_15;
         const modelFileId = await resolveItemModelFileId(hints);
@@ -5397,7 +5433,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await import('./index-CXkcz4hT.js');
+            const schemaMod = await import('./index-CMxEil8T.js');
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -5474,7 +5510,11 @@ class ItemProperty {
                         }
                     }
                     if (exists && isFile) {
-                        renderValue = await BaseFileManager.readFileAsString(filePath);
+                        // A File's value is its content URL (a blob URL in browsers, file:// in Node), as saveFile
+                        // and hydrateFromDb set it. Reading the text here made the value change from the URL to
+                        // the file's contents a moment after every save or load.
+                        renderValue =
+                            context.refResolvedDisplayValue ?? (await BaseFileManager.getContentUrlFromPath(filePath));
                     }
                     if (!exists) {
                         // Keep filename for display when File object is present but not yet saved to disk
@@ -5568,7 +5608,7 @@ class ItemProperty {
                 const normalizedRefValueType = normalizeDataType(propertyRecordSchema?.refValueType);
                 const propertyNames = getMetadataPropertyNamesForQuery(propertyName, normalizedDataType, normalizedRefValueType);
                 const propertyNameVariant = propertyNames.length > 1 ? propertyNames[1] : undefined;
-                const _mod_16 = await import('./index-CURf9L4d.js');
+                const _mod_16 = await import('./index-DWK-LOUY.js');
                 const _ns_16 = _mod_16.s;
                 const seedSchemaMod = _ns_16;
                 const { metadata } = seedSchemaMod;
@@ -5792,7 +5832,7 @@ class ItemProperty {
             const ctx = this._service.getSnapshot().context;
             let modelFileId;
             try {
-                const _mod_17 = await import('./BasePathResolver-CsZHPrk9.js');
+                const _mod_17 = await import('./BasePathResolver-CBTXCMFL.js');
                 const _ns_17 = _mod_17.bf;
                 const { resolveItemModelFileId } = _ns_17;
                 modelFileId = await resolveItemModelFileId({
@@ -6155,7 +6195,7 @@ class ItemProperty {
         const propertiesData = await getItemProperties({ seedLocalId, seedUid });
         const instances = [];
         const seenNormalized = new Set();
-        const _mod_18 = await import('./BasePathResolver-CsZHPrk9.js');
+        const _mod_18 = await import('./BasePathResolver-CBTXCMFL.js');
         const _ns_18 = _mod_18.bf;
         const { resolveItemModelFileId } = _ns_18;
         const itemModelFileId = await resolveItemModelFileId({ seedLocalId, seedUid });
@@ -6173,7 +6213,7 @@ class ItemProperty {
             }
             else if (baseName) {
                 try {
-                    const _mod_19 = await import('./errors-CWKup8tw.js');
+                    const _mod_19 = await import('./errors-CIrbsN_i.js');
                     const _ns_19 = _mod_19.h;
                     const { Model } = _ns_19;
                     const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
@@ -6190,7 +6230,7 @@ class ItemProperty {
             }
             if (modelName && propertyName) {
                 try {
-                    const _mod_20 = await import('./errors-CWKup8tw.js');
+                    const _mod_20 = await import('./errors-CIrbsN_i.js');
                     const _ns_20 = _mod_20.h;
                     const { Model } = _ns_20;
                     const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
@@ -6522,7 +6562,7 @@ class ItemProperty {
                 if (!propertyName || (!seedLocalId && !seedUid))
                     return;
                 if (db) {
-                    const _mod_21 = await import('./index-CURf9L4d.js');
+                    const _mod_21 = await import('./index-DWK-LOUY.js');
                     const _ns_21 = _mod_21.s;
                     const seedSchemaMod = _ns_21;
                     const { metadata } = seedSchemaMod;
@@ -6567,7 +6607,7 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
     }
     const seedType = easName(modelName);
     // Dynamic import to break circular dependency
-    const _mod_22 = await import('./errors-CWKup8tw.js');
+    const _mod_22 = await import('./errors-CIrbsN_i.js');
     const _ns_22 = _mod_22.h;
     const modelMod = _ns_22;
     const { Model } = modelMod;
@@ -6575,57 +6615,69 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
     const propertySchemas = model?.properties ? modelPropertiesToObject(model.properties) : undefined;
     modelFileId ?? (modelFileId = model?.id);
     const newSeedId = await createSeed({ type: seedType, modelFileId });
-    const newVersionId = await createVersion({ seedLocalId: newSeedId, seedType: easName(modelName) });
-    // Build set of all properties to create metadata for: union of model schema + propertyData
-    // This ensures we create metadata for ALL model properties even when creating with no initial values
-    // (fixes first-item persistence: loadOrCreateItem needs metadata rows to run createItemPropertyInstances)
-    const allPropertyNames = new Set(Object.keys(propertyData));
-    if (propertySchemas) {
-        for (const name of Object.keys(propertySchemas)) {
-            allPropertyNames.add(name);
-        }
-    }
-    for (const propertyName of allPropertyNames) {
-        const propertyValue = propertyData[propertyName];
-        const propertyRecordSchema = propertySchemas?.[propertyName];
-        // 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({
+    try {
+        return await writeVersionAndRows(newSeedId);
+    }
+    catch (error) {
+        // The rows are separate inserts (no transaction): remove what was written so a failure leaves
+        // no half-made draft.
+        const { discardNewDraft } = await import('./discardNewDraft-CEOouygG.js');
+        await discardNewDraft(newSeedId).catch(() => undefined);
+        throw error;
+    }
+    async function writeVersionAndRows(newSeedId) {
+        const newVersionId = await createVersion({ seedLocalId: newSeedId, seedType: easName(modelName) });
+        // Build set of all properties to create metadata for: union of model schema + propertyData
+        // This ensures we create metadata for ALL model properties even when creating with no initial values
+        // (fixes first-item persistence: loadOrCreateItem needs metadata rows to run createItemPropertyInstances)
+        const allPropertyNames = new Set(Object.keys(propertyData));
+        if (propertySchemas) {
+            for (const name of Object.keys(propertySchemas)) {
+                allPropertyNames.add(name);
+            }
+        }
+        for (const propertyName of allPropertyNames) {
+            const propertyValue = propertyData[propertyName];
+            const propertyRecordSchema = propertySchemas?.[propertyName];
+            // 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: 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,
             seedLocalId: newSeedId,
             versionLocalId: newVersionId,
-            propertyName,
-            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,
-        seedLocalId: newSeedId,
-        versionLocalId: newVersionId,
-    };
 };
 
 /**
@@ -6750,7 +6802,7 @@ const getModel = () => {
         // the fragile `import(...).then(n => n.X)` chunk-namespace pattern.
         if (!modelImportPromise) {
             modelImportPromise = (async () => {
-                const _mod_23 = await import('./errors-CWKup8tw.js');
+                const _mod_23 = await import('./errors-CIrbsN_i.js');
                 const _ns_23 = _mod_23.h;
                 const mod = _ns_23;
                 ModelClass = mod.Model;
@@ -6918,14 +6970,16 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const getPublishUploadsMod = await import('./getPublishUploads-cLbSEXLk.js');
+            const _mod_24 = await import('./getPublishUploads-CVTBo_OV.js');
+            const _ns_24 = _mod_24.o;
+            const getPublishUploadsMod = _ns_24;
             const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this, [], undefined, options);
         };
         this.getPublishPayload = async (uploadedTransactions, options) => {
-            const _mod_24 = await import('./getPublishPayload-CWfjl8PM.js');
-            const _ns_24 = _mod_24.g;
-            const getPublishPayloadMod = _ns_24;
+            const _mod_25 = await import('./getPublishPayload-DTjOKd3y.js');
+            const _ns_25 = _mod_25.g;
+            const getPublishPayloadMod = _ns_25;
             const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions, options);
         };
@@ -7185,17 +7239,20 @@ class Item {
             }
         }
     }
+    /** Drops one holder's reference. Returns true while other holders still have the instance. */
     static releaseItemInstanceCacheHold(instance) {
         const keys = this.collectInstanceCacheKeysForInstance(instance);
         if (keys.length === 0)
-            return;
+            return false;
         const entry = this.instanceCache.get(keys[0]);
         entry.refCount -= 1;
         if (entry.refCount <= 0) {
             for (const k of keys) {
                 this.instanceCache.delete(k);
             }
+            return false;
         }
+        return true;
     }
     /**
      * Idle, and not the shell the item machine can be in when it reaches `idle` before
@@ -7459,18 +7516,18 @@ class Item {
         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_25 = await import('./BasePathResolver-CsZHPrk9.js');
-            const _ns_25 = _mod_25.bf;
-            const { resolveModelRecord } = _ns_25;
+            const _mod_26 = await import('./BasePathResolver-CBTXCMFL.js');
+            const _ns_26 = _mod_26.bf;
+            const { resolveModelRecord } = _ns_26;
             const modelRecord = await resolveModelRecord(props.modelName, {
                 modelFileId: props.modelFileId ?? modelInstance?.id,
                 schemaName: schemaName ?? modelInstance?.schemaName,
             });
             const modelRecords = modelRecord ? [modelRecord] : [];
             if (!modelRecord) {
-                const _mod_26 = await import('./errors-CWKup8tw.js');
-                const _ns_26 = _mod_26.j;
-                const { UnknownModelError } = _ns_26;
+                const _mod_27 = await import('./errors-CIrbsN_i.js');
+                const _ns_27 = _mod_27.j;
+                const { UnknownModelError } = _ns_27;
                 throw new UnknownModelError(props.modelName, schemaName ?? modelInstance?.schemaName);
             }
             if (modelRecord?.schemaFileId) {
@@ -7479,12 +7536,12 @@ 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_27 = await import('./BasePathResolver-CsZHPrk9.js');
-                const _ns_27 = _mod_27.be;
-                const { modelSchemas } = _ns_27;
-                const _mod_28 = await import('./BasePathResolver-CsZHPrk9.js');
-                const _ns_28 = _mod_28.bd;
-                const { schemas: schemasTable } = _ns_28;
+                const _mod_28 = await import('./BasePathResolver-CBTXCMFL.js');
+                const _ns_28 = _mod_28.be;
+                const { modelSchemas } = _ns_28;
+                const _mod_29 = await import('./BasePathResolver-CBTXCMFL.js');
+                const _ns_29 = _mod_29.bd;
+                const { schemas: schemasTable } = _ns_29;
                 const schemaRows = await db
                     .select({ schemaName: schemasTable.name })
                     .from(modelSchemas)
@@ -7653,22 +7710,35 @@ class Item {
             return proxiedInstance;
         try {
             await this.waitForItemInstanceReadyForRead(proxiedInstance, readyTimeout);
+            await this.savePipelineValues(proxiedInstance, pipelineValues, readyTimeout);
         }
         catch (err) {
-            try {
-                proxiedInstance.unload();
-            }
-            catch {
-                /* best-effort cache cleanup */
-            }
+            // A rejected create leaves nothing behind, so a retry doesn't make a second draft.
+            await this.discardCreatedItem(proxiedInstance, seedLocalId);
             throw err;
         }
-        await this.savePipelineValues(proxiedInstance, pipelineValues, readyTimeout);
         return proxiedInstance;
     }
+    /** Stops a just-created item and deletes what create wrote (see discardNewDraft). */
+    static async discardCreatedItem(item, seedLocalId) {
+        try {
+            this.dropCachedInstancesForSeedIds([seedLocalId]);
+        }
+        catch {
+            /* best-effort cache cleanup */
+        }
+        try {
+            const { discardNewDraft } = await import('./discardNewDraft-CEOouygG.js');
+            await discardNewDraft(seedLocalId);
+        }
+        catch (error) {
+            itemLogger(`Item.create: could not remove the draft ${seedLocalId} after a failure:`, error);
+        }
+    }
     /**
      * 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.
+     * avoid SQLite write contention). Rejects on the first failure, with ItemCreateValidationError when the
+     * value breaks its property's rules; Item.create then removes the item.
      */
     static async savePipelineValues(item, pipelineValues, timeout) {
         for (const [propertyName, value] of pipelineValues) {
@@ -7681,6 +7751,14 @@ class Item {
                 await property.save();
             }
             catch (error) {
+                if (error instanceof ItemPropertySaveValidationError) {
+                    const _mod_30 = await import('./errors-CIrbsN_i.js');
+                    const _ns_30 = _mod_30.j;
+                    const { ItemCreateValidationError } = _ns_30;
+                    const created = new ItemCreateValidationError(item.modelName, error.validationErrors.map((e) => ({ property: propertyName, code: e.code, message: e.message })));
+                    created.cause = error;
+                    throw created;
+                }
                 throw new Error(`Item.create: failed to save ${item.modelName}.${propertyName} for item ${item.seedLocalId}: ` +
                     (error instanceof Error ? error.message : String(error)), { cause: error });
             }
@@ -7841,9 +7919,9 @@ class Item {
         if (!appDb || Item.instanceCache.size === 0) {
             return;
         }
-        const _mod_29 = await import('./index-CURf9L4d.js');
-        const _ns_29 = _mod_29.s;
-        const { metadata } = _ns_29;
+        const _mod_31 = await import('./index-DWK-LOUY.js');
+        const _ns_31 = _mod_31.s;
+        const { metadata } = _ns_31;
         const { eq, and } = await import('drizzle-orm');
         const dedupedInstances = new Map();
         for (const entry of Item.instanceCache.values()) {
@@ -8004,11 +8082,11 @@ class Item {
     }
     /** Throws ItemCreateValidationError for unknown keys and values that break their property's rules. */
     static async assertValidCreateValues(props, propertyNames, dataTypeByPropertyName, skipKeys) {
-        const _mod_30 = await import('./errors-CWKup8tw.js');
-        const _ns_30 = _mod_30.j;
-        const { ItemCreateValidationError } = _ns_30;
-        const { getPropertySchema } = await import('./property-tgPI5hMu.js');
-        const { SchemaValidationService } = await import('./SchemaValidationService-CLGadxgf.js');
+        const _mod_32 = await import('./errors-CIrbsN_i.js');
+        const _ns_32 = _mod_32.j;
+        const { ItemCreateValidationError } = _ns_32;
+        const { getPropertySchema } = await import('./property-lz9yIpyA.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-CE92y1TT.js');
         const validationService = new SchemaValidationService();
         const modelName = props.modelName;
         const known = new Set(propertyNames);
@@ -8045,7 +8123,7 @@ class Item {
                     // Not JSON: validated as given, and rejected as a non-array
                 }
             }
-            const { resolvePropertyValidationRules } = await import('./propertyValidationRules-BLVxTejW.js');
+            const { resolvePropertyValidationRules } = await import('./propertyValidationRules-LuIwoQoJ.js');
             const rules = propertySchema?.validation ??
                 (await resolvePropertyValidationRules(modelName, key, {
                     modelFileId: props.modelFileId,
@@ -8376,9 +8454,9 @@ class Item {
                 itemActor.send(event);
             };
             try {
-                const _mod_31 = await import('./index-CURf9L4d.js');
-                const _ns_31 = _mod_31.s;
-                const seedSchemaMod = _ns_31;
+                const _mod_33 = await import('./index-DWK-LOUY.js');
+                const _ns_33 = _mod_33.s;
+                const seedSchemaMod = _ns_33;
                 const { seeds, versions, metadata } = seedSchemaMod;
                 const drizzleMod = await import('drizzle-orm');
                 const { eq, and } = drizzleMod;
@@ -8667,9 +8745,15 @@ class Item {
             });
         }
     }
+    /**
+     * Releases this holder's reference. Item.create, Item.find and createById return the same cached
+     * instance to every caller, so the instance is stopped only when the last holder unloads it.
+     */
     unload() {
         try {
-            Item.releaseItemInstanceCacheHold(this);
+            // Others (e.g. another hook showing the same item) still use it: keep it running.
+            if (Item.releaseItemInstanceCacheHold(this))
+                return;
             unloadEntity(this, {
                 getCacheKeys: () => [],
                 caches: [],
@@ -8740,5 +8824,5 @@ var Item$1 = /*#__PURE__*/Object.freeze({
     Item: Item
 });
 
-export { unloadEntity as $, getPublishExecutor as A, getRevokeExecutor as B, ClientManagerState as C, DEFAULT_READY_TIMEOUT_MS as D, getUploadExecutor as E, getVersionData$1 as F, isLocalUnsealedDraft as G, isSeedRowOwned as H, Item as I, localUnsealedDraftSql as J, ownedPublisherSql as K, ownedSeedsSql as L, METADATA_LATEST_FIRST_ORDER_SQL as M, pickLatestMetadataRowPerProperty as N, OwnershipError as O, PUBLISH_NOT_CONFIGURED_MESSAGE as P, placeholderUidSql as Q, propertyMachine as R, publisherInAddressListSql as S, publisherIsInOwnedSet as T, setAdditionalSyncAddresses as U, setGetPublisherForNewSeeds as V, setPublishExecutor as W, setRevokeExecutor as X, setUploadExecutor as Y, getInvariantSafePropertyDescriptor as Z, clearDestroySubscriptions as _, ItemProperty as a, ClientManagerEvents as a0, withLockedItemStorageRow as a1, getItemStorageFilePath as a2, writeItemStorageFile as a3, resolvePublisherFromSeedRow as a4, getPropertyData$1 as a5, Item$1 as a6, ItemPropertySaveValidationError as b, compareMetadataRowsLatestFirst as c, assertItemOwned as d, getEasSchemaUidForModel as e, getLatestPublishedVersionRow as f, getItemData as g, isVersionRevoked as h, isItemOwned as i, chunkValues as j, getGetAdditionalSyncAddresses as k, waitForEntityIdle as l, createReactiveProxy as m, findEntity as n, forceRemoveFromCaches as o, parseListPropertyValueFromStorage as p, runDestroyLifecycle as q, rowsPerInsert 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-TMrVEPeX.js.map
+export { unloadEntity as $, getPublishExecutor as A, getRevokeExecutor as B, ClientManagerState as C, DEFAULT_READY_TIMEOUT_MS as D, getUploadExecutor as E, getVersionData$1 as F, isLocalUnsealedDraft as G, isSeedRowOwned as H, Item as I, localUnsealedDraftSql as J, ownedPublisherSql as K, ownedSeedsSql as L, METADATA_LATEST_FIRST_ORDER_SQL as M, pickLatestMetadataRowPerProperty as N, OwnershipError as O, PUBLISH_NOT_CONFIGURED_MESSAGE as P, placeholderUidSql as Q, propertyMachine as R, publisherInAddressListSql as S, publisherIsInOwnedSet as T, setAdditionalSyncAddresses as U, setGetPublisherForNewSeeds as V, setPublishExecutor as W, setRevokeExecutor as X, setUploadExecutor as Y, getInvariantSafePropertyDescriptor as Z, clearDestroySubscriptions as _, ItemProperty as a, ClientManagerEvents as a0, withLockedItemStorageRow as a1, getItemStorageFilePath as a2, writeItemStorageFile as a3, resolvePublisherFromSeedRow as a4, getPropertyData$1 as a5, Item$1 as a6, ItemPropertySaveValidationError as b, assertItemOwned as c, waitForEntityIdle as d, compareMetadataRowsLatestFirst as e, getEasSchemaUidForModel as f, getItemData as g, getLatestPublishedVersionRow as h, isItemOwned as i, isVersionRevoked as j, chunkValues as k, getGetAdditionalSyncAddresses as l, createReactiveProxy as m, findEntity as n, forceRemoveFromCaches as o, parseListPropertyValueFromStorage as p, runDestroyLifecycle as q, rowsPerInsert 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-DTJPMjFk.js.map