@seedprotocol/sdk 0.7.10 → 0.7.11-next.1396.g883ef47

package/dist/{errors-CnT0fSMK.js → publishErrors-DZXDX3B6.js}

@@ -1,19 +1,21 @@
 import { fromCallback, setup, assign, createActor, waitFor, fromPromise } from 'xstate';
-import { ak as isActorStopped, T as applyContextUpdate, U as isInternalUpdate, al as differsFromOriginals, X as isEntityTornDown, am as onEntityTeardown, V as evictionLog, Y as sameEntity, Z as DEFAULT_READY_TIMEOUT_MS, _ as createReactiveProxy, $ as runEntityLoad, a0 as waitForEntityReady, a2 as EntityUnloadedError, a3 as entityStatus, I as Item, a1 as evictEntities, a4 as releaseEntity, a5 as destroyEntity, a8 as modelPropertiesToObject, a6 as EntityCache, aa as easPropertyNameForPublish, af as matchMetadataProperty, aT as getSeedPublisher, ag as metadataRowsOfProperty, ah as METADATA_LATEST_FIRST_ORDER_SQL, aU as deleteStagedFile, aV as storageFileName, aW as STORAGE_SUBDIR, aX as resolveNewSeedFields, aY as lookupPropertySchemaUid, aZ as stageStorageContent, a_ as requireStagedFile, a$ as createSeed, b0 as createMetadata, H as compareMetadataRowsLatestFirst, b1 as storageValueRowOf, t as registerOutboxApplier, r as outboxOpValue, b2 as findSetConflict, b3 as recordPropertyEdit, h as OutboxOpDeferredError, u as startOutbox, i as OutboxOpFailedError, y as OwnershipError, B as isItemOwned, R as getLatestVersionRow, S as parseListPropertyValueFromStorage, au as resolvePublisherFromSeedRow, aE as isLocalUnsealedDraft, b4 as setEntityUnloadGraceMs, b5 as stopOutbox, b6 as evictAllEntities } from './Item-oPnmIehk.js';
+import { as as isActorStopped, N as applyContextUpdate, P as isInternalUpdate, at as differsFromOriginals, bd as writeModelToDb, be as writePropertyToDb, U as isEntityTornDown, ax as onEntityTeardown, Q as evictionLog, V as sameEntity, W as DEFAULT_READY_TIMEOUT_MS, X as createReactiveProxy, Y as runEntityLoad, Z as waitForEntityReady, A as AmbiguousModelError, E as EntityUnloadedError, $ as entityStatus, I as Item, _ as evictEntities, a1 as releaseEntity, a2 as destroyEntity, bf as currentNameMatchLevels, bg as renameModelInDb, ag as modelPropertiesToObject, a6 as EntityCache, a3 as isClientReady, aM as MachineIds, a$ as normalizeAddressConfig, af as nameMatchLevels, aa as loadNameMatchLevels, a0 as inDefinitionsTransaction, bh as insertModelStubs, b0 as normalizeAddressList, bi as warnOnInvalidNameMatch, a4 as upsertSchemaRow, bj as refreshCachedProperties, ai as easPropertyNameForPublish, aJ as findSeedRow, a7 as normalizePublisher, aK as resolvePublisherFromSeedRow, an as matchMetadataProperty, ao as metadataRowsOfProperty, ap as METADATA_LATEST_FIRST_ORDER_SQL, bk as resolveMetadataProperty, aj as metadataStorageName, bl as lookupPropertySchemaUid, K as getItemStorageSubdir, bm as getItemStorageLocalFileName, bn as deleteStagedFile, bo as storageFileName, bp as STORAGE_SUBDIR, bq as resolveNewSeedFields, br as stageStorageContent, bs as requireStagedFile, r as registerOutboxApplier, k as outboxOpValue, bt as findSetConflict, bu as recordPropertyEdit, d as OutboxOpDeferredError, bv as startOutbox, e as OutboxOpFailedError, q as OwnershipError, u as isItemOwned, D as compareMetadataRowsLatestFirst, bw as createSeed, bx as storageValueRowOf, by as getLatestVersionRow, aI as parseListPropertyValueFromStorage, aL as ClientManagerState, bz as ClientManagerEvents, aY as isLocalUnsealedDraft, J as writeInBatches, ae as selectInBatches, bA as getWatchedAddressesFromDb, bB as getOwnedAddressesFromDb, bC as setEntityUnloadGraceMs, bD as stopOutbox, bE as evictAllEntities, bF as registerClientActor, aF as isVersionRevoked, bG as getPropertyDefinitions, aH as readModelMetadataProperties, bH as metadataPropertyNameForms, bI as currentPropertyRow, H as getLatestPublishedVersionRow, au as resolveModelRecord, bJ as resolveModelRecordByNameOrType, v as isPublishedSeedRef, bK as storageSeedTransactionId, bL as storageUploadPath, bM as storedValueKind, bN as resolveStorageDisplay } from './Item-BU9wIT7l.js';
 import debug from 'debug';
-import { B as BaseDb, l as properties, d as models$1, j as modelSchemas, t as schemas, f as easSyncProcesses, a as appState, w as BaseFileManager, b as modelUids, s as seeds, v as versions, m as metadata$1, p as pendingWrites, h as htmlEmbeddedImageCoPublish, e as arweaveL1FinalizeJobs, r as publishProcesses } from './BaseFileManager-DLou1TZS.js';
-import { aI as writeModelToDb, aJ as writePropertyToDb, m as generateId, p as isInternalSchema, A as AmbiguousModelError, aK as currentNameMatchLevels, aL as renameModelInDb, s as isClientReady, a as TProperty, ay as withDbTabLock, af as MachineIds, ap as isLeaderTab, aM as postTabMessage, aN as onTabMessage, ax as whenLeaderTab, aO as listenForOtherTabsEvents, F as isBrowser, $ as isNode, aP as startTabCoordination, aq as normalizeAddressConfig, aQ as isTestOrSeedDev, L as nameMatchLevels, C as loadNameMatchLevels, aD as withSeedDbLock, q as inDefinitionsTransaction, aR as insertModelStubs, G as emitAcrossTabs, a8 as ADDRESSES_PERSISTED_EVENT, ar as normalizeAddressList, aS as warnOnInvalidNameMatch, u as upsertSchemaRow, aT as refreshCachedProperties, g as normalizePropertyRecordSchema, M as ModelPropertyDataTypes, j as findSeedRow, aU as tryWithTabLock, Y as getItemStorageSubdir, _ as getItemStorageLocalFileName, aV as notifyFileSaved, ad as ImageSize, n as normalizeDataType, ab as ClientManagerState, aW as ClientManagerEvents, at as parseAddressesPersistedPayload, x as normalizePublisher, w as writeInBatches, K as selectInBatches, ae as LOCAL_COPIES_REMOVED_EVENT, aX as getWatchedAddressesFromDb, aY as getOwnedAddressesFromDb, aZ as CLIENT_NOT_INITIALIZED, a_ as stopTabCoordination, a$ as registerClientActor } from './tabEvents-DT5ez6io.js';
-import { seedGatewayConfigFromSeedConfig, setPreferredArweaveReadBaseUrls, resolveSeedGatewayEndpoints, setResolvedSeedGatewayEndpoints, BaseArweaveClient, ensureReadGatewaySelected, DEFAULT_ARWEAVE_HOST } from '@seedprotocol/arweave';
+import { B as BaseDb, l as properties, d as models$1, j as modelSchemas, q as schemas, f as easSyncProcesses, a as appState, r as BaseFileManager, b as modelUids, s as seeds, v as versions, m as metadata$1, p as pendingWrites, h as htmlEmbeddedImageCoPublish, e as arweaveL1FinalizeJobs, o as publishProcesses } from './BaseFileManager-D-pLXQAp.js';
+import { seedGatewayConfigFromSeedConfig, setPreferredArweaveReadBaseUrls, resolveSeedGatewayEndpoints, setResolvedSeedGatewayEndpoints, BaseArweaveClient, ensureReadGatewaySelected, DEFAULT_ARWEAVE_HOST, normalizeRelationPropertyValue, resolveSeedIdsFromRefString, getPublicArweaveRawUrl } from '@seedprotocol/arweave';
 import 'pluralize';
-import { localNamesInBestMatchTier, configureEasReadChain, matchEasModelSchemas, whenEasReadChainSettled, getEasReadChainId, DEFAULT_EAS_CHAIN_ID, isEasReadChainConfigured, easName, isValidEasAttestationUid } from '@seedprotocol/eas';
+import { localNamesInBestMatchTier, configureEasReadChain, matchEasModelSchemas, whenEasReadChainSettled, getEasReadChainId, DEFAULT_EAS_CHAIN_ID, isEasReadChainConfigured, easName, isValidEasAttestationUid, getEasChainDeployment, getEasAttestationExplorerUrl } from '@seedprotocol/eas';
+import { k as generateId, l as isInternalSchema, a as TProperty, Q as withDbTabLock, H as isLeaderTab, a2 as postTabMessage, a3 as onTabMessage, O as whenLeaderTab, a4 as listenForOtherTabsEvents, o as isBrowser, q as isNode, a5 as startTabCoordination, Y as withSeedDbLock, p as emitAcrossTabs, A as ADDRESSES_PERSISTED_EVENT, g as normalizePropertyRecordSchema, M as ModelPropertyDataTypes, n as normalizeDataType, a6 as tryWithTabLock, a7 as notifyFileSaved, I as ImageSize, J as parseAddressesPersistedPayload, L as LOCAL_COPIES_REMOVED_EVENT, a8 as CLIENT_NOT_INITIALIZED, a9 as stopTabCoordination, Z as ZERO_BYTES32, aa as getExtensionForMimeType, ab as INTERNAL_STORAGE_MODEL_FILE_IDS, i as isDataType, ac as resolveUploadMimeType, B as getContentSha256, y as buildArweaveContentTags } from './arweaveContentTags-iW_HcWJA.js';
 import { eq, and, isNull, or, inArray, isNotNull, ne, desc, count, sql, like } from 'drizzle-orm';
 import { Type } from '@sinclair/typebox';
 import { isEqual } from 'lodash-es';
+import { getSeed, registerLocalQuerySource, clearLocalQuerySource } from '@seedprotocol/query';
+import { rewriteHtmlUrls, parseArchiveDocument, dublinCoreXml, premisXml, digestHex, createBag } from '@seedprotocol/archive';
+import { parseFragment } from 'parse5';
 import { sha3_256 } from '@noble/hashes/sha3';
 import { bytesToHex, utf8ToBytes } from '@noble/hashes/utils';
-import { getSeed, registerLocalQuerySource, clearLocalQuerySource } from '@seedprotocol/query';
 
-const logger$g = debug('seedSdk:model:actors:validateModel');
+const logger$h = debug('seedSdk:model:actors:validateModel');
 // Validation timeout in milliseconds (10 seconds)
 const VALIDATION_TIMEOUT_MS = 10000;
 const validateModel = fromCallback(({ sendBack, input: { context }, self }) => {
@@ -36,10 +38,10 @@ const validateModel = fromCallback(({ sendBack, input: { context }, self }) => {
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await import('./SchemaValidationService-CieGrj5c.js');
+            const validationServiceMod = await import('./SchemaValidationService-Dc-lpFQX.js');
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const _mod_0 = await import('./Schema-BMXRF4j9.js');
+            const _mod_0 = await import('./Schema-C_4wv0RP.js');
             const _ns_0 = _mod_0.a;
             const schemaMod = _ns_0;
             const { Schema } = schemaMod;
@@ -85,12 +87,12 @@ const validateModel = fromCallback(({ sendBack, input: { context }, self }) => {
                         }
                     }
                     else {
-                        logger$g(`Schema is in ${schemaStatus} state, skipping schema validation`);
+                        logger$h(`Schema is in ${schemaStatus} state, skipping schema validation`);
                         // Continue with structure validation only
                     }
                 }
                 catch (error) {
-                    logger$g('Error validating model against schema:', error);
+                    logger$h('Error validating model against schema:', error);
                     // Continue with structure validation only
                 }
             }
@@ -105,7 +107,7 @@ const validateModel = fromCallback(({ sendBack, input: { context }, self }) => {
             if (!hasResponded) {
                 hasResponded = true;
                 clearTimeout(timeoutId);
-                logger$g('Error in validateModel:', error);
+                logger$h('Error in validateModel:', error);
                 sendBack({
                     type: 'validationError',
                     errors: [{
@@ -122,7 +124,7 @@ const validateModel = fromCallback(({ sendBack, input: { context }, self }) => {
         if (!hasResponded) {
             hasResponded = true;
             clearTimeout(timeoutId);
-            logger$g('Error in validateModel:', error);
+            logger$h('Error in validateModel:', error);
             sendBack({
                 type: 'validationError',
                 errors: [{
@@ -306,7 +308,7 @@ const modelMachine = setup({
     },
 });
 
-const logger$f = debug('seedSdk:model:createModelProperties');
+const logger$g = debug('seedSdk:model:createModelProperties');
 /**
  * Creates and caches the ModelProperty instances for the properties passed to Model.create, from
  * the rows the model's write stored. Stops early when the model is stopped (unloaded, or evicted
@@ -319,8 +321,8 @@ async function createModelProperties(model, propertyDefinitions) {
     if (!id || !_dbId || !modelName) {
         throw new Error('Model ID, file ID, and name are required to create properties');
     }
-    logger$f(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-    const { ModelProperty } = await import('./ModelProperty-D2vJozmW.js');
+    logger$g(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
+    const { ModelProperty } = await import('./ModelProperty-Bv7KzP97.js');
     const { and, eq } = await import('drizzle-orm');
     const db = BaseDb.getAppDb();
     for (const [propName, propData] of Object.entries(propertyDefinitions)) {
@@ -338,11 +340,11 @@ async function createModelProperties(model, propertyDefinitions) {
             : undefined;
         // Otherwise use provided ID or generate a random one
         // IDs should be generated in the import process before creating properties
-        const _mod_1 = await import('./tabEvents-DT5ez6io.js');
-        const _ns_1 = _mod_1.bl;
+        const _mod_1 = await import('./arweaveContentTags-iW_HcWJA.js');
+        const _ns_1 = _mod_1.ap;
         const { generateId } = _ns_1;
         const propertyFileId = propData.id || propertyRecord?.schemaFileId || generateId();
-        logger$f(`Creating property "${propName}" with fileId "${propertyFileId}"`);
+        logger$g(`Creating property "${propName}" with fileId "${propertyFileId}"`);
         // Query database to get refModelId if the property has ref/refModelName
         // The property should already be in DB from addModelsToDb
         let refModelId = propData.refModelId;
@@ -352,27 +354,27 @@ async function createModelProperties(model, propertyDefinitions) {
                 // First try to get refModelId from the property record in the database
                 if (propertyRecord?.refModelId) {
                     refModelId = propertyRecord.refModelId;
-                    logger$f(`Found refModelId ${refModelId} from database for property "${propName}"`);
+                    logger$g(`Found refModelId ${refModelId} from database for property "${propName}"`);
                 }
                 else if (refModelName) {
                     // Fallback: resolve the ref by name within this model's schema
-                    const _mod_2 = await import('./tabEvents-DT5ez6io.js');
-                    const _ns_2 = _mod_2.bh;
+                    const _mod_2 = await import('./Item-BU9wIT7l.js');
+                    const _ns_2 = _mod_2.bP;
                     const { resolveModelRecord } = _ns_2;
                     const refModelRecord = await resolveModelRecord(refModelName, { schemaName }, db);
                     if (refModelRecord?.id) {
                         refModelId = refModelRecord.id;
-                        logger$f(`Resolved refModelId ${refModelId} from model name "${refModelName}" for property "${propName}"`);
+                        logger$g(`Resolved refModelId ${refModelId} from model name "${refModelName}" for property "${propName}"`);
                     }
                 }
             }
             catch (error) {
-                logger$f(`Error fetching refModelId for property "${propName}":`, error);
+                logger$g(`Error fetching refModelId for property "${propName}":`, error);
                 // Continue without refModelId - it will be resolved later in _initializeOriginalValues
             }
         }
         if (stopped()) {
-            logger$f(`Model "${modelName}" was stopped while creating its properties; not creating the rest`);
+            logger$g(`Model "${modelName}" was stopped while creating its properties; not creating the rest`);
             return;
         }
         // Create ModelProperty instance
@@ -409,10 +411,10 @@ async function createModelProperties(model, propertyDefinitions) {
         // The model holds its properties (a child hold), released when the model is destroyed or evicted
         ModelProperty.holdForModel(property, model);
     }
-    logger$f(`Created all properties for model "${modelName}"`);
+    logger$g(`Created all properties for model "${modelName}"`);
 }
 
-const logger$e = debug('seedSdk:db:write:saveDefinition');
+const logger$f = debug('seedSdk:db:write:saveDefinition');
 // Writes that have started. Evicting an instance can't cancel its write, so code that deletes rows
 // under live instances (Schema.destroy, test cleanup) waits for these after evicting the instances.
 const inFlightWrites = new Set();
@@ -444,7 +446,7 @@ function saveDefinition(input) {
 }
 const write = async (input) => {
     if (input.type === 'model') {
-        logger$e(`Writing model "${input.modelName}" (${input.modelFileId}) to schema ${input.schemaId}`);
+        logger$f(`Writing model "${input.modelName}" (${input.modelFileId}) to schema ${input.schemaId}`);
         return writeModelToDb(input.modelFileId, {
             modelName: input.modelName,
             schemaId: input.schemaId,
@@ -452,13 +454,13 @@ const write = async (input) => {
         });
     }
     // Imported here: the validation service imports the Schema barrel, which imports this module's callers
-    const { SchemaValidationService } = await import('./SchemaValidationService-CieGrj5c.js');
+    const { SchemaValidationService } = await import('./SchemaValidationService-Dc-lpFQX.js');
     const data = input.data();
     const { errors } = new SchemaValidationService().validatePropertyStructure(data);
     if (errors.length > 0) {
         throw new Error(`Property "${data.name}" is invalid: ${errors.map((error) => error.message).join(', ')}`);
     }
-    logger$e(`Writing property "${data.name}" (${input.propertyFileId})`);
+    logger$f(`Writing property "${data.name}" (${input.propertyFileId})`);
     await writePropertyToDb(input.propertyFileId, data);
 };
 
@@ -601,7 +603,7 @@ function setupEntityLiveQuery(instance, config) {
 }
 
 // Model and Schema are imported dynamically: Model.ts -> loadModel -> Schema.ts -> Model.ts
-const logger$d = debug('seedSdk:model:loadModel');
+const logger$e = debug('seedSdk:model:loadModel');
 /**
  * Create ModelProperty instances for all property IDs to ensure they're cached
  * This ensures that ModelProperty.getById() in Model.properties getter will find the instances
@@ -613,10 +615,10 @@ const createPropertyInstances = async (propertyFileIds, since) => {
         return;
     }
     try {
-        const mod = await import('./ModelProperty-D2vJozmW.js');
+        const mod = await import('./ModelProperty-Bv7KzP97.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
-            logger$d('createPropertyInstances: ModelProperty not available from dynamic import');
+            logger$e('createPropertyInstances: ModelProperty not available from dynamic import');
             return;
         }
         // Create instances for all property IDs in parallel
@@ -625,22 +627,22 @@ const createPropertyInstances = async (propertyFileIds, since) => {
             try {
                 const property = await ModelProperty.createById(propertyFileId, { since });
                 if (property) {
-                    logger$d(`Created/cached ModelProperty instance for propertyFileId "${propertyFileId}"`);
+                    logger$e(`Created/cached ModelProperty instance for propertyFileId "${propertyFileId}"`);
                 }
                 else {
-                    logger$d(`ModelProperty.createById returned undefined for propertyFileId "${propertyFileId}" (may not exist in DB yet)`);
+                    logger$e(`ModelProperty.createById returned undefined for propertyFileId "${propertyFileId}" (may not exist in DB yet)`);
                 }
             }
             catch (error) {
-                logger$d(`Error creating ModelProperty instance for propertyFileId "${propertyFileId}": ${error}`);
+                logger$e(`Error creating ModelProperty instance for propertyFileId "${propertyFileId}": ${error}`);
                 // Don't throw - continue with other properties
             }
         });
         await Promise.all(createPromises);
-        logger$d(`Finished creating/caching ${propertyFileIds.length} ModelProperty instances`);
+        logger$e(`Finished creating/caching ${propertyFileIds.length} ModelProperty instances`);
     }
     catch (error) {
-        logger$d(`Error in createPropertyInstances: ${error}`);
+        logger$e(`Error in createPropertyInstances: ${error}`);
         // Don't throw - this is best-effort to pre-populate cache
     }
 };
@@ -675,7 +677,7 @@ async function loadModel(context, isStopped) {
                 if (dbModels.length > 0) {
                     modelRecord = dbModels[0];
                     foundBySchemaFileId = true;
-                    logger$d(`Found model "${modelName}" in database by schemaFileId "${schemaFileId}"`);
+                    logger$e(`Found model "${modelName}" in database by schemaFileId "${schemaFileId}"`);
                 }
             }
             // If not found by ID, try by name
@@ -684,11 +686,11 @@ async function loadModel(context, isStopped) {
             if (!modelRecord) {
                 // Model names are only unique per schema: prefer this schema's row, and otherwise only
                 // consider same-name rows that no schema claims yet (never another schema's model).
-                const _mod_3 = await import('./BaseFileManager-DLou1TZS.js');
+                const _mod_3 = await import('./BaseFileManager-D-pLXQAp.js');
                 const _ns_3 = _mod_3.M;
                 const { modelSchemas } = _ns_3;
-                const _mod_4 = await import('./BaseFileManager-DLou1TZS.js');
-                const _ns_4 = _mod_4.z;
+                const _mod_4 = await import('./BaseFileManager-D-pLXQAp.js');
+                const _ns_4 = _mod_4.x;
                 const { schemas: schemasTable } = _ns_4;
                 let dbModels = await db
                     .select({
@@ -730,16 +732,16 @@ async function loadModel(context, isStopped) {
                         try {
                             const { Model } = await Promise.resolve().then(function () { return Model$1; });
                             if (Model.peek(dbSchemaFileId)) {
-                                logger$d(`Model "${modelName}" found in database by name with schemaFileId "${dbSchemaFileId}", and a cached instance already exists. Updating current instance to use the same schemaFileId.`);
+                                logger$e(`Model "${modelName}" found in database by name with schemaFileId "${dbSchemaFileId}", and a cached instance already exists. Updating current instance to use the same schemaFileId.`);
                                 // Update the current instance's schemaFileId to match the database
                                 // This ensures both instances point to the same cached instance
                                 modelRecord = foundModel;
                                 schemaFileId = dbSchemaFileId;
-                                logger$d(`Using existing cached instance with schemaFileId "${schemaFileId}" for model "${modelName}"`);
+                                logger$e(`Using existing cached instance with schemaFileId "${schemaFileId}" for model "${modelName}"`);
                             }
                         }
                         catch (error) {
-                            logger$d(`Error checking Model cache for schemaFileId "${dbSchemaFileId}": ${error}`);
+                            logger$e(`Error checking Model cache for schemaFileId "${dbSchemaFileId}": ${error}`);
                             // Fall through to normal processing
                         }
                     }
@@ -747,31 +749,31 @@ async function loadModel(context, isStopped) {
                     // this is a new model - don't use the existing model (will be renamed if duplicate)
                     // UNLESS we found a cached instance above (in which case modelRecord is already set)
                     if (!modelRecord && schemaFileId && dbSchemaFileId && schemaFileId !== dbSchemaFileId) {
-                        logger$d(`Model "${modelName}" found by name but has different schemaFileId (provided: "${schemaFileId}", db: "${dbSchemaFileId}"). Creating new model (will check for duplicates).`);
+                        logger$e(`Model "${modelName}" found by name but has different schemaFileId (provided: "${schemaFileId}", db: "${dbSchemaFileId}"). Creating new model (will check for duplicates).`);
                         // Don't set modelRecord - we'll create a new model with potentially renamed name
                     }
                     else if (!modelRecord && schemaFileId && !dbSchemaFileId) {
                         // We have a schemaFileId but the found model doesn't have one - this is a new model
                         // Don't reuse the existing model, create a new one (will be renamed if duplicate)
-                        logger$d(`Model "${modelName}" found by name but found model has no schemaFileId. Creating new model with schemaFileId "${schemaFileId}" (will check for duplicates).`);
+                        logger$e(`Model "${modelName}" found by name but found model has no schemaFileId. Creating new model with schemaFileId "${schemaFileId}" (will check for duplicates).`);
                         // Don't set modelRecord - we'll create a new model
                     }
                     else if (!modelRecord) {
                         // Only reuse existing model if:
                         // 1. No schemaFileId was provided (loading existing model), OR
                         // 2. schemaFileId matches (same model)
-                        logger$d(`Model "${modelName}" found by name, reusing existing model (schemaFileId: provided="${schemaFileId}", db="${dbSchemaFileId}")`);
+                        logger$e(`Model "${modelName}" found by name, reusing existing model (schemaFileId: provided="${schemaFileId}", db="${dbSchemaFileId}")`);
                         modelRecord = foundModel;
                         // Only use database schemaFileId if no id was explicitly provided
                         // If an id was provided, we should use it (it might be creating a new model with a specific ID)
                         if (!id && dbSchemaFileId) {
                             schemaFileId = dbSchemaFileId;
-                            logger$d(`Using database schemaFileId "${schemaFileId}" for model "${modelName}" (no ID was provided)`);
+                            logger$e(`Using database schemaFileId "${schemaFileId}" for model "${modelName}" (no ID was provided)`);
                         }
                         else if (id) {
-                            logger$d(`Preserving provided id (schemaFileId) "${schemaFileId}" for model "${modelName}" (ignoring database schemaFileId "${dbSchemaFileId}")`);
+                            logger$e(`Preserving provided id (schemaFileId) "${schemaFileId}" for model "${modelName}" (ignoring database schemaFileId "${dbSchemaFileId}")`);
                         }
-                        logger$d(`Found model "${modelName}" in database by name, schemaFileId: "${schemaFileId}"`);
+                        logger$e(`Found model "${modelName}" in database by name, schemaFileId: "${schemaFileId}"`);
                     }
                 }
             }
@@ -796,7 +798,7 @@ async function loadModel(context, isStopped) {
                 // Generate schemaFileId if not set
                 if (!schemaFileId) {
                     schemaFileId = generateId();
-                    logger$d(`Generated id (schemaFileId) "${schemaFileId}" for model "${modelName}"`);
+                    logger$e(`Generated id (schemaFileId) "${schemaFileId}" for model "${modelName}"`);
                 }
                 // Include _dbId from database record so properties can be created if needed
                 // Even if we found an existing model, we may still need to create properties
@@ -820,14 +822,14 @@ async function loadModel(context, isStopped) {
             }
         }
         catch (error) {
-            logger$d(`Error loading model from database: ${error}`);
+            logger$e(`Error loading model from database: ${error}`);
             // Fall through to create new model
         }
     }
     // Step 2: Fallback to Schema context (only if database doesn't have the model)
     // This handles the case where model exists in schema file but not yet in database
     try {
-        const _mod_5 = await import('./Schema-BMXRF4j9.js');
+        const _mod_5 = await import('./Schema-C_4wv0RP.js');
         const _ns_5 = _mod_5.a;
         const { Schema } = _ns_5;
         // Stopped meanwhile (unloaded, or evicted with its schema): don't load the schema again
@@ -842,10 +844,10 @@ async function loadModel(context, isStopped) {
             const byName = schemaContext.models[modelName];
             const schemaModelId = byName?.id ?? null;
             if (schemaFileId === schemaModelId) {
-                logger$d(`Found model "${modelName}" in Schema context (database fallback)`);
+                logger$e(`Found model "${modelName}" in Schema context (database fallback)`);
                 if (!schemaFileId) {
                     schemaFileId = generateId();
-                    logger$d(`Generated id (schemaFileId) "${schemaFileId}" for model "${modelName}"`);
+                    logger$e(`Generated id (schemaFileId) "${schemaFileId}" for model "${modelName}"`);
                 }
                 return { id: schemaFileId };
             }
@@ -857,7 +859,7 @@ async function loadModel(context, isStopped) {
                 // Schema context may not have model by name yet (e.g. still loading). If our id appears in any schema model, we're the schema model.
                 for (const def of Object.values(schemaContext.models)) {
                     if (def?.id === schemaFileId) {
-                        logger$d(`Found model in Schema context by id "${schemaFileId}" (database fallback)`);
+                        logger$e(`Found model in Schema context by id "${schemaFileId}" (database fallback)`);
                         return { id: schemaFileId };
                     }
                 }
@@ -865,7 +867,7 @@ async function loadModel(context, isStopped) {
         }
     }
     catch (error) {
-        logger$d(`Error loading model from Schema context: ${error}`);
+        logger$e(`Error loading model from Schema context: ${error}`);
         // Fall through to create new model
     }
     // Step 3: Check for duplicate names in database before creating new model
@@ -885,7 +887,7 @@ async function loadModel(context, isStopped) {
         // 3. This is an internal schema (internal schemas should preserve original names from schema files), OR
         // 4. This instance was created with modelFileId from schema (_idFromSchema) - schema models keep their name
         const shouldSkipDuplicateCheck = modelRecord !== null || foundBySchemaFileId || isInternal || !!_idFromSchema;
-        logger$d(`Duplicate check: modelRecord=${modelRecord !== null}, foundBySchemaFileId=${foundBySchemaFileId}, isInternal=${isInternal}, _idFromSchema=${!!_idFromSchema}, schemaFileId=${schemaFileId}, shouldSkip=${shouldSkipDuplicateCheck}`);
+        logger$e(`Duplicate check: modelRecord=${modelRecord !== null}, foundBySchemaFileId=${foundBySchemaFileId}, isInternal=${isInternal}, _idFromSchema=${!!_idFromSchema}, schemaFileId=${schemaFileId}, shouldSkip=${shouldSkipDuplicateCheck}`);
         if (!shouldSkipDuplicateCheck) {
             try {
                 const lowerModelName = modelName.toLowerCase();
@@ -908,20 +910,20 @@ async function loadModel(context, isStopped) {
                     }
                 }
                 catch (error) {
-                    logger$d(`Error checking Model cache for duplicates: ${error}`);
+                    logger$e(`Error checking Model cache for duplicates: ${error}`);
                 }
                 // Also check database for models (in case they're persisted but not in Schema context)
                 if (db) {
-                    const _mod_6 = await import('./BaseFileManager-DLou1TZS.js');
+                    const _mod_6 = await import('./BaseFileManager-D-pLXQAp.js');
                     const _ns_6 = _mod_6.M;
                     const modelSchemaSchemaMod = _ns_6;
                     const { modelSchemas } = modelSchemaSchemaMod;
-                    const _mod_7 = await import('./BaseFileManager-DLou1TZS.js');
-                    const _ns_7 = _mod_7.z;
+                    const _mod_7 = await import('./BaseFileManager-D-pLXQAp.js');
+                    const _ns_7 = _mod_7.x;
                     const schemaSchemaMod = _ns_7;
                     const { schemas: schemasTable } = schemaSchemaMod;
                     // Query all models for this schema to check for duplicates (case-insensitive)
-                    logger$d(`Checking database for duplicate model names in schema "${schemaName}"`);
+                    logger$e(`Checking database for duplicate model names in schema "${schemaName}"`);
                     const allModelsForSchema = await db
                         .select({
                         name: models$1.name,
@@ -930,16 +932,16 @@ async function loadModel(context, isStopped) {
                         .innerJoin(modelSchemas, eq(models$1.id, modelSchemas.modelId))
                         .innerJoin(schemasTable, eq(modelSchemas.schemaId, schemasTable.id))
                         .where(eq(schemasTable.name, schemaName));
-                    logger$d(`Found ${allModelsForSchema.length} models in database for schema "${schemaName}": ${allModelsForSchema.map((m) => m.name).join(', ')}`);
+                    logger$e(`Found ${allModelsForSchema.length} models in database for schema "${schemaName}": ${allModelsForSchema.map((m) => m.name).join(', ')}`);
                     if (allModelsForSchema.length === 0 && modelName.includes('Shared')) {
-                        logger$d(`[DEBUG] No models found in database for schema "${schemaName}" when checking for duplicate "${modelName}"`);
+                        logger$e(`[DEBUG] No models found in database for schema "${schemaName}" when checking for duplicate "${modelName}"`);
                     }
                     // Check for exact match (case-insensitive) or matches with number suffix
                     for (const dbModel of allModelsForSchema) {
                         const lowerDbName = dbModel.name.toLowerCase();
                         if (lowerDbName === lowerModelName) {
                             existingNumbers.add(0); // Base name exists
-                            logger$d(`Found duplicate in database: "${dbModel.name}" matches "${modelName}"`);
+                            logger$e(`Found duplicate in database: "${dbModel.name}" matches "${modelName}"`);
                         }
                         else if (lowerDbName.startsWith(lowerModelName + ' ')) {
                             // Check if it's the base name followed by a space and a number
@@ -947,55 +949,55 @@ async function loadModel(context, isStopped) {
                             const number = parseInt(suffix, 10);
                             if (!isNaN(number) && suffix === number.toString()) {
                                 existingNumbers.add(number);
-                                logger$d(`Found numbered variant in database: "${dbModel.name}" (number: ${number})`);
+                                logger$e(`Found numbered variant in database: "${dbModel.name}" (number: ${number})`);
                             }
                         }
                     }
                 }
                 // If duplicates found, generate unique name
-                logger$d(`Duplicate check results: existingNumbers=${Array.from(existingNumbers).join(', ')}, hasBaseName=${existingNumbers.has(0)}`);
+                logger$e(`Duplicate check results: existingNumbers=${Array.from(existingNumbers).join(', ')}, hasBaseName=${existingNumbers.has(0)}`);
                 if (existingNumbers.has(0)) {
                     let nextNumber = 1;
                     while (existingNumbers.has(nextNumber)) {
                         nextNumber++;
                     }
                     finalModelName = `${modelName} ${nextNumber}`;
-                    logger$d(`Found duplicate model name "${modelName}" in schema "${schemaName}", using unique name "${finalModelName}"`);
+                    logger$e(`Found duplicate model name "${modelName}" in schema "${schemaName}", using unique name "${finalModelName}"`);
                 }
                 else {
-                    logger$d(`No duplicate found for model name "${modelName}" in schema "${schemaName}"`);
+                    logger$e(`No duplicate found for model name "${modelName}" in schema "${schemaName}"`);
                 }
             }
             catch (error) {
-                logger$d(`Error checking for duplicate model names: ${error}`);
+                logger$e(`Error checking for duplicate model names: ${error}`);
                 // Continue with original name if check fails
             }
         }
         else {
             if (foundBySchemaFileId) {
-                logger$d(`Preserving original model name "${modelName}" for model found by schemaFileId (schemaFileId: ${schemaFileId})`);
+                logger$e(`Preserving original model name "${modelName}" for model found by schemaFileId (schemaFileId: ${schemaFileId})`);
             }
             else if (modelRecord) {
-                logger$d(`Using existing model name "${modelName}" from database (modelRecord found)`);
+                logger$e(`Using existing model name "${modelName}" from database (modelRecord found)`);
             }
             else if (isInternal) {
-                logger$d(`Preserving original model name "${modelName}" for internal schema "${schemaName}" (skipping duplicate check)`);
+                logger$e(`Preserving original model name "${modelName}" for internal schema "${schemaName}" (skipping duplicate check)`);
             }
         }
     }
     // Step 4: Create new empty model (not found in database or Schema context)
-    logger$d(`Creating new model "${finalModelName}" in schema "${schemaName}"`);
+    logger$e(`Creating new model "${finalModelName}" in schema "${schemaName}"`);
     // Generate schemaFileId for new model
     if (!schemaFileId) {
         schemaFileId = generateId();
-        logger$d(`Generated id (schemaFileId) "${schemaFileId}" for new model "${finalModelName}"`);
+        logger$e(`Generated id (schemaFileId) "${schemaFileId}" for new model "${finalModelName}"`);
     }
     if (finalModelName !== modelName) {
-        logger$d(`Model name "${modelName}" is taken in schema "${schemaName}"; using "${finalModelName}"`);
+        logger$e(`Model name "${modelName}" is taken in schema "${schemaName}"; using "${finalModelName}"`);
     }
     // Mark schema as draft when a new model is created so saveNewVersion() can persist it
     try {
-        const _mod_8 = await import('./Schema-BMXRF4j9.js');
+        const _mod_8 = await import('./Schema-C_4wv0RP.js');
         const _ns_8 = _mod_8.a;
         const { Schema } = _ns_8;
         if (!isStopped()) {
@@ -1004,7 +1006,7 @@ async function loadModel(context, isStopped) {
         }
     }
     catch (err) {
-        logger$d(`Failed to mark schema as draft after creating model: ${err}`);
+        logger$e(`Failed to mark schema as draft after creating model: ${err}`);
     }
     return {
         id: schemaFileId,
@@ -1084,12 +1086,12 @@ function queueDraftSave(key, save) {
     return current;
 }
 
-const logger$c = debug('seedSdk:model:Model');
+const logger$d = debug('seedSdk:model:Model');
 const saveDraftLogger = debug('seedSdk:model:saveDraftToDb');
 // Lazy import cache for ModelProperty to avoid circular dependency
 // Eagerly start loading to minimize delay on first access
 let ModelPropertyClass = null;
-const modelPropertyImportPromise = import('./ModelProperty-D2vJozmW.js')
+const modelPropertyImportPromise = import('./ModelProperty-Bv7KzP97.js')
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -1240,7 +1242,7 @@ class Model {
             });
         }
         else {
-            logger$c(`Model "${context.modelName}" adopts model row ${dbId} written by its schema import`);
+            logger$d(`Model "${context.modelName}" adopts model row ${dbId} written by its schema import`);
         }
         ensureRunning();
         service.send({ type: 'updateContext', _dbId: dbId });
@@ -1341,7 +1343,7 @@ class Model {
         if (cachedById) {
             if (holds)
                 this.cache.holdInstance(cachedById);
-            logger$c(`Model.create: Found instance in ID cache for "${modelName}" (ID: ${id})`);
+            logger$d(`Model.create: Found instance in ID cache for "${modelName}" (ID: ${id})`);
             if (!waitForReady)
                 return cachedById;
             return Model.readyOrRelease(cachedById, readyTimeout, holds);
@@ -1350,7 +1352,7 @@ class Model {
         // a schema model (with id) keeps its name.
         const uniqueModelName = this.findUniqueModelName(modelName, schemaName, !!id);
         if (uniqueModelName !== modelName) {
-            logger$c(`Model.create: Found duplicate name "${modelName}" in schema "${schemaName}", using unique name "${uniqueModelName}"`);
+            logger$d(`Model.create: Found duplicate name "${modelName}" in schema "${schemaName}", using unique name "${uniqueModelName}"`);
         }
         const resolvedId = id ?? generateId();
         // The id and the properties to create go in the initial context, so the load sees them
@@ -1360,7 +1362,7 @@ class Model {
         // Use the unique model name for the instance (idFromSchema: true when id was provided, so schema model is not renamed)
         const newInstance = new this(uniqueModelName, schemaName, resolvedId, initialContext, !!id);
         if (options?.properties) {
-            logger$c(`[Model.create] Created instance with _pendingPropertyDefinitions in initial context (${Object.keys(options.properties).length} properties) for model "${uniqueModelName}"`);
+            logger$d(`[Model.create] Created instance with _pendingPropertyDefinitions in initial context (${Object.keys(options.properties).length} properties) for model "${uniqueModelName}"`);
         }
         // Wrap instance in Proxy for reactive property access. `name` is an alias for `modelName`.
         const sendUpdate = (target, prop, value) => {
@@ -1371,10 +1373,10 @@ class Model {
                 const oldName = context.modelName;
                 const newName = value;
                 if (oldName === newName) {
-                    logger$c(`Model name unchanged: "${oldName}"`);
+                    logger$d(`Model name unchanged: "${oldName}"`);
                     return;
                 }
-                logger$c(`Updating model name from "${oldName}" to "${newName}"`);
+                logger$d(`Updating model name from "${oldName}" to "${newName}"`);
                 Model.cache.setKeys(target, [context.id, modelKey(context.schemaName, newName)]);
                 // Update Model context
                 target._service.send({
@@ -1430,7 +1432,7 @@ class Model {
         this.cache.add(proxiedInstance, [resolvedId, id ? modelKey(schemaName, uniqueModelName) : undefined], {
             hold: holds,
         });
-        logger$c(`Model.create: Created new instance for "${uniqueModelName}" (ID: ${id})`);
+        logger$d(`Model.create: Created new instance for "${uniqueModelName}" (ID: ${id})`);
         // Step 11: Register with schema if requested, OR trigger write if properties are provided
         // If properties are provided, we need to write the model to get modelId for property creation
         // If schema provided, trigger write process instead of registration
@@ -1455,7 +1457,7 @@ class Model {
                 adoptExistingRow,
             });
             if (!hasProperties) {
-                persisted.catch((error) => logger$c(`Model "${uniqueModelName}" was not written: ${error}`));
+                persisted.catch((error) => logger$d(`Model "${uniqueModelName}" was not written: ${error}`));
                 return;
             }
             await persisted.catch((error) => {
@@ -1598,8 +1600,8 @@ class Model {
             if (db) {
                 const since = evictionLog.now();
                 try {
-                    const _mod_9 = await import('./tabEvents-DT5ez6io.js');
-                    const _ns_9 = _mod_9.bh;
+                    const _mod_9 = await import('./Item-BU9wIT7l.js');
+                    const _ns_9 = _mod_9.bP;
                     const { resolveModelRecord, getModelSchemaName } = _ns_9;
                     const resolved = scope.modelFileId
                         ? await resolveModelRecord(undefined, { modelFileId: scope.modelFileId }, db)
@@ -1617,7 +1619,7 @@ class Model {
                     }
                 }
                 catch (error) {
-                    logger$c(`Model.resolveAsync: scoped lookup failed for "${modelName}": ${error instanceof Error ? error.message : String(error)}`);
+                    logger$d(`Model.resolveAsync: scoped lookup failed for "${modelName}": ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
         }
@@ -1645,8 +1647,8 @@ class Model {
         }
         const since = options?.since ?? evictionLog.now();
         try {
-            const _mod_10 = await import('./tabEvents-DT5ez6io.js');
-            const _ns_10 = _mod_10.bh;
+            const _mod_10 = await import('./Item-BU9wIT7l.js');
+            const _ns_10 = _mod_10.bP;
             const { resolveModelRecord, getModelSchemaName } = _ns_10;
             const resolved = await resolveModelRecord(modelName, schemaName ? { schemaName, strict: true } : {}, db);
             if (!resolved?.schemaFileId) {
@@ -1669,7 +1671,7 @@ class Model {
         catch (error) {
             if (error instanceof AmbiguousModelError)
                 throw error;
-            logger$c(`Model.getByNameAsync: Error looking up model by name "${modelName}": ${error instanceof Error ? error.message : String(error)}`);
+            logger$d(`Model.getByNameAsync: Error looking up model by name "${modelName}": ${error instanceof Error ? error.message : String(error)}`);
             return undefined;
         }
     }
@@ -1687,13 +1689,13 @@ class Model {
         // Step 1: Check cache first (fast path)
         const cached = this.getById(modelFileId, options);
         if (cached) {
-            logger$c(`Model.createById: Found instance in cache for ID "${modelFileId}"`);
+            logger$d(`Model.createById: Found instance in cache for ID "${modelFileId}"`);
             return cached;
         }
         // Step 2: Query database to get modelName and schemaName
         const db = BaseDb.getAppDb();
         if (!db) {
-            logger$c(`Model.createById: Database not available for ID "${modelFileId}"`);
+            logger$d(`Model.createById: Database not available for ID "${modelFileId}"`);
             return undefined;
         }
         const since = options?.since ?? evictionLog.now();
@@ -1711,30 +1713,30 @@ class Model {
                 .where(eq(models$1.schemaFileId, modelFileId))
                 .limit(1);
             if (modelRecords.length === 0) {
-                logger$c(`Model.createById: Model not found in database for ID "${modelFileId}"`);
+                logger$d(`Model.createById: Model not found in database for ID "${modelFileId}"`);
                 return undefined;
             }
             const { modelName, schemaName } = modelRecords[0];
             if (!modelName || !schemaName) {
-                logger$c(`Model.createById: Missing modelName or schemaName for ID "${modelFileId}"`);
+                logger$d(`Model.createById: Missing modelName or schemaName for ID "${modelFileId}"`);
                 return undefined;
             }
             // Its schema was evicted while we read the row (e.g. a Schema live query in flight during
             // Schema.destroy or test cleanup): don't bring the model back.
             // or the model was destroyed (destroy() leaves the cache before it deletes the rows)
             if (evictionLog.evictedSince([`schema:${schemaName}`, `model:${modelFileId}`], since)) {
-                logger$c(`Model.createById: "${modelFileId}" or its schema "${schemaName}" was evicted during the lookup`);
+                logger$d(`Model.createById: "${modelFileId}" or its schema "${schemaName}" was evicted during the lookup`);
                 return undefined;
             }
             // Step 3: Create model using existing create method (which will handle caching)
-            logger$c(`Model.createById: Creating model "${modelName}" in schema "${schemaName}" from ID "${modelFileId}"`);
+            logger$d(`Model.createById: Creating model "${modelName}" in schema "${schemaName}" from ID "${modelFileId}"`);
             return this.create(modelName, schemaName, {
                 id: modelFileId, // id is now the schemaFileId (string)
                 hold: options?.hold,
             });
         }
         catch (error) {
-            logger$c(`Model.createById: Error looking up model by ID "${modelFileId}": ${error instanceof Error ? error.message : String(error)}`);
+            logger$d(`Model.createById: Error looking up model by ID "${modelFileId}": ${error instanceof Error ? error.message : String(error)}`);
             return undefined;
         }
     }
@@ -1776,7 +1778,7 @@ class Model {
         }
         const db = BaseDb.getAppDb();
         if (!db) {
-            logger$c(`Model.createBySchemaId: Database not available for schema "${schemaIdentifier}"`);
+            logger$d(`Model.createBySchemaId: Database not available for schema "${schemaIdentifier}"`);
             return [];
         }
         const since = evictionLog.now();
@@ -1793,7 +1795,7 @@ class Model {
                 .innerJoin(models$1, eq(modelSchemas.modelId, models$1.id))
                 .where(or(eq(schemas.schemaFileId, schemaIdentifier), eq(schemas.name, schemaIdentifier)));
             if (modelRecords.length === 0) {
-                logger$c(`Model.createBySchemaId: No models found in database for schema "${schemaIdentifier}"`);
+                logger$d(`Model.createBySchemaId: No models found in database for schema "${schemaIdentifier}"`);
                 return [];
             }
             // Create Model instances for each model (create() handles caching)
@@ -1821,11 +1823,11 @@ class Model {
                     modelInstances.push(model);
                 }
             }
-            logger$c(`Model.createBySchemaId: Found ${modelInstances.length} models for schema "${schemaIdentifier}"`);
+            logger$d(`Model.createBySchemaId: Found ${modelInstances.length} models for schema "${schemaIdentifier}"`);
             return modelInstances;
         }
         catch (error) {
-            logger$c(`Model.createBySchemaId: Error looking up models for schema "${schemaIdentifier}": ${error instanceof Error ? error.message : String(error)}`);
+            logger$d(`Model.createBySchemaId: Error looking up models for schema "${schemaIdentifier}": ${error instanceof Error ? error.message : String(error)}`);
             return [];
         }
     }
@@ -1874,7 +1876,7 @@ class Model {
             // Leave out models that errored or didn't get ready in time. Don't re-read their state afterwards:
             // a ready model can already be validating again, and it still belongs in the result.
             const ready = await Promise.all(instances.map((m) => waitForEntityReady(m, { timeout: readyTimeout }).then(() => true, (error) => {
-                logger$c(`Model.all: leaving out a model that isn't ready: ${error instanceof Error ? error.message : String(error)}`);
+                logger$d(`Model.all: leaving out a model that isn't ready: ${error instanceof Error ? error.message : String(error)}`);
                 return false;
             })));
             return held(instances.filter((_, i) => ready[i]));
@@ -1929,7 +1931,7 @@ class Model {
             return { hasConflict: false };
         }
         catch (error) {
-            logger$c(`Error checking for conflicts: ${error instanceof Error ? error.message : String(error)}`);
+            logger$d(`Error checking for conflicts: ${error instanceof Error ? error.message : String(error)}`);
             return { hasConflict: false }; // On error, assume no conflict to allow save
         }
     }
@@ -2093,7 +2095,7 @@ class Model {
      */
     async reload() {
         this._assertLoaded('reload');
-        logger$c(`Reloading model ${this.modelName} from database`);
+        logger$d(`Reloading model ${this.modelName} from database`);
         await runEntityLoad(this, () => Model.load(this));
         if (this.status === 'error')
             throw new Error('Failed to reload model from database');
@@ -2146,9 +2148,9 @@ class Model {
                         .limit(1);
                     if (modelRecord) {
                         const modelId = modelRecord.id;
-                        const { detachModelRows } = await import('./detachRowsBeforeDelete-BZr_0iZU.js');
-                        const _mod_11 = await import('./tabEvents-DT5ez6io.js');
-                        const _ns_11 = _mod_11.bj;
+                        const { detachModelRows } = await import('./detachRowsBeforeDelete-Cie55SoG.js');
+                        const _mod_11 = await import('./Item-BU9wIT7l.js');
+                        const _ns_11 = _mod_11.bR;
                         const { inDefinitionsTransaction } = _ns_11;
                         // The model's rows go together or not at all
                         await inDefinitionsTransaction(async (tx) => {
@@ -2164,7 +2166,7 @@ class Model {
                 getModelProperty()?.evictForModel({ modelName, schemaName, modelId: dbId });
                 if (schemaName && modelName) {
                     // Imported here, not at module load: Model and Schema import each other.
-                    const _mod_12 = await import('./Schema-BMXRF4j9.js');
+                    const _mod_12 = await import('./Schema-C_4wv0RP.js');
                     const _ns_12 = _mod_12.a;
                     const { Schema } = _ns_12;
                     const schema = await Schema.find({ schemaName, waitForReady: false });
@@ -2203,8 +2205,8 @@ class Model {
                             return undefined;
                         }
                         // Model names are only unique per schema: find this model's row by its id (schemaFileId).
-                        const _mod_13 = await import('./tabEvents-DT5ez6io.js');
-                        const _ns_13 = _mod_13.bh;
+                        const _mod_13 = await import('./Item-BU9wIT7l.js');
+                        const _ns_13 = _mod_13.bP;
                         const { resolveModelRecord } = _ns_13;
                         const modelRecord = await resolveModelRecord(modelName, { modelFileId: context.id, schemaName: context.schemaName }, db);
                         if (!modelRecord?.id) {
@@ -2226,7 +2228,7 @@ class Model {
                         });
                     }
                     catch (error) {
-                        logger$c(`[Model._setupLiveQuerySubscription] Error finding model: ${error}`);
+                        logger$d(`[Model._setupLiveQuerySubscription] Error finding model: ${error}`);
                         return undefined;
                     }
                 }
@@ -2253,7 +2255,7 @@ class Model {
                 await modelPropertyImportPromise;
                 const ModelProperty = getModelProperty();
                 if (!ModelProperty) {
-                    logger$c('[Model._setupLiveQuerySubscription] ModelProperty not yet loaded');
+                    logger$d('[Model._setupLiveQuerySubscription] ModelProperty not yet loaded');
                     return;
                 }
                 const createPromises = ids.map(async (propertyFileId) => {
@@ -2261,7 +2263,7 @@ class Model {
                         await ModelProperty.createById(propertyFileId);
                     }
                     catch (error) {
-                        logger$c(`[Model._setupLiveQuerySubscription] Error creating ModelProperty instance for propertyFileId "${propertyFileId}": ${error}`);
+                        logger$d(`[Model._setupLiveQuerySubscription] Error creating ModelProperty instance for propertyFileId "${propertyFileId}": ${error}`);
                     }
                 });
                 await Promise.all(createPromises);
@@ -2314,28 +2316,28 @@ class Model {
                     await modelPropertyImportPromise;
                     const ModelProperty = getModelProperty();
                     if (!ModelProperty) {
-                        logger$c('[Model._refreshPropertiesFromDb] ModelProperty not yet loaded');
+                        logger$d('[Model._refreshPropertiesFromDb] ModelProperty not yet loaded');
                     }
                     else {
                         const createPromises = propertyIds.map(async (propertyFileId) => {
                             try {
                                 const property = await ModelProperty.createById(propertyFileId);
                                 if (property) {
-                                    logger$c(`[Model._refreshPropertiesFromDb] Created/cached ModelProperty instance for propertyFileId "${propertyFileId}"`);
+                                    logger$d(`[Model._refreshPropertiesFromDb] Created/cached ModelProperty instance for propertyFileId "${propertyFileId}"`);
                                 }
                                 else {
-                                    logger$c(`[Model._refreshPropertiesFromDb] ModelProperty.createById returned undefined for propertyFileId "${propertyFileId}"`);
+                                    logger$d(`[Model._refreshPropertiesFromDb] ModelProperty.createById returned undefined for propertyFileId "${propertyFileId}"`);
                                 }
                             }
                             catch (error) {
-                                logger$c(`[Model._refreshPropertiesFromDb] Error creating ModelProperty instance for propertyFileId "${propertyFileId}": ${error}`);
+                                logger$d(`[Model._refreshPropertiesFromDb] Error creating ModelProperty instance for propertyFileId "${propertyFileId}": ${error}`);
                             }
                         });
                         await Promise.all(createPromises);
                     }
                 }
                 catch (error) {
-                    logger$c(`[Model._refreshPropertiesFromDb] Error importing ModelProperty or creating instances: ${error}`);
+                    logger$d(`[Model._refreshPropertiesFromDb] Error importing ModelProperty or creating instances: ${error}`);
                 }
             }
             // Update context with refreshed property IDs AFTER creating instances (the awaits above can
@@ -2349,7 +2351,7 @@ class Model {
             });
         }
         catch (error) {
-            logger$c(`[Model._refreshPropertiesFromDb] Error refreshing properties: ${error}`);
+            logger$d(`[Model._refreshPropertiesFromDb] Error refreshing properties: ${error}`);
         }
     }
     /**
@@ -2382,7 +2384,6 @@ var Model$1 = /*#__PURE__*/Object.freeze({
 });
 
 // Export the Model class
-const TModelValues = Type.Record(Type.String(), Type.Any());
 const TModelSchema = Type.Record(Type.String(), TProperty);
 
 let writeTail = Promise.resolve();
@@ -2585,7 +2586,7 @@ function toRunSyncArg(options) {
     return undefined;
 }
 const runEasSync = fromPromise(async ({ input, }) => {
-    const { runSyncFromEas } = await import('./syncDbWithEas-FuyqoEKk.js');
+    const { runSyncFromEas } = await import('./syncDbWithEas-V_9gIyHp.js');
     // Sync checks for rows and then inserts the rest (no unique index on uids), so syncs in
     // different tabs take turns. A sync can run for minutes, so wait without a timeout.
     await withDbTabLock('eas-sync', async () => {
@@ -2901,14 +2902,14 @@ function applySeedConfigDefaults(config) {
     return { ...config, filesDir, endpoints: next };
 }
 
-const logger$b = debug('seedSdk:ClientManager:initialize');
+const logger$c = debug('seedSdk:ClientManager:initialize');
 /**
  * The first init step: configures the platform services, EAS reads and the Arweave gateway from
  * the init options, starts tab coordination and the item event handlers, and returns the context
  * the following steps read.
  */
 async function platformClassesInit({ event }) {
-    logger$b('initialize from ClientManager');
+    logger$c('initialize from ClientManager');
     if (!event || !('options' in event)) {
         throw new Error('Initialize event must include options');
     }
@@ -2918,7 +2919,7 @@ async function platformClassesInit({ event }) {
     if (!config) {
         throw new Error('client.init requires a config');
     }
-    const { configurePlatform } = await import('./configurePlatform-WkmvqeTO.js');
+    const { configurePlatform } = await import('./configurePlatform-BH1YOZpg.js');
     if (isBrowser()) {
         const { createPlatformServices } = await import('./platform.browser.js');
         configurePlatform(createPlatformServices());
@@ -2994,17 +2995,12 @@ async function platformClassesInit({ event }) {
     };
 }
 
-const logger$a = debug('seedSdk:client:writeToDb');
+const logger$b = debug('seedSdk:client:writeToDb');
 const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
     const _saveAppState = async () => {
         try {
             const appDb = BaseDb.getAppDb();
             if (!appDb) {
-                // In test environments, continue anyway
-                if (isTestOrSeedDev()) {
-                    logger$a('[client/actors] [saveAppState] App DB not found, but continuing in test environment');
-                    return;
-                }
                 throw new Error('App DB not found');
             }
             const result = await appDb.insert(appState)
@@ -3018,15 +3014,10 @@ const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
                     value: JSON.stringify(value),
                 },
             });
-            logger$a('result', result);
+            logger$b('result', result);
         }
         catch (error) {
-            logger$a('[client/actors] [saveAppState] Error saving app state:', error);
-            // In test environments, continue anyway
-            if (isTestOrSeedDev()) {
-                logger$a('[client/actors] [saveAppState] Continuing despite error in test environment');
-                return;
-            }
+            logger$b('[client/actors] [saveAppState] Error saving app state:', error);
             throw error;
         }
     };
@@ -3039,24 +3030,13 @@ const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
         });
     })
         .catch((error) => {
-        logger$a('[client/actors] [saveAppState] Error in promise chain:', error);
-        // In test environments, still send success to allow state machine to progress
-        if (isTestOrSeedDev()) {
-            logger$a('[client/actors] [saveAppState] Sending success despite error in test environment');
-            sendBack({
-                type: 'saveAppStateSuccess',
-                key,
-                value,
-            });
-        }
-        else {
-            sendBack({
-                type: 'saveAppStateError',
-                error: error instanceof Error ? error : new Error(String(error)),
-                key,
-                value,
-            });
-        }
+        logger$b('[client/actors] [saveAppState] Error in promise chain:', error);
+        sendBack({
+            type: 'saveAppStateError',
+            error: error instanceof Error ? error : new Error(String(error)),
+            key,
+            value,
+        });
     });
 });
 
@@ -3068,7 +3048,7 @@ async function fileSystemInit({ filesDir }) {
     await BaseFileManager.initializeFileSystem(filesDir);
 }
 
-const logger$9 = debug('seedSdk:client:actors:dbInit');
+const logger$a = debug('seedSdk:client:actors:dbInit');
 /** Init step: opens and migrates the app database (BaseDb.prepareDb). */
 async function dbInit({ filesDir, dbConfig }) {
     if (!filesDir) {
@@ -3078,7 +3058,7 @@ async function dbInit({ filesDir, dbConfig }) {
     if (!BaseDb.getAppDb()) {
         throw new Error('Database not available after preparation');
     }
-    logger$9('Database prepared and ready');
+    logger$a('Database prepared and ready');
 }
 
 /**
@@ -3136,7 +3116,7 @@ const localModelSchemaLookups = async (modelNames) => {
     return names.filter((name) => name !== 'Seed').map((name) => ({ name, level: levels.model(name) }));
 };
 
-const logger$8 = debug('seedSdk:client:actors:addModelsToDb');
+const logger$9 = debug('seedSdk:client:actors:addModelsToDb');
 /**
  * Returns every `models` row named in `modelNames`, inserting a null-schemaFileId stub for each name
  * with no row yet (the schema import adopts stubs via findOrCreateModelRow). Check-then-insert:
@@ -3185,7 +3165,7 @@ async function addModelsToDb(context) {
         for (const modelName of modelNames) {
             const foundModel = rowFor(modelName);
             if (!foundModel) {
-                logger$8('[client/actors] [addModelsToDb] Warning: Could not find or create model:', modelName);
+                logger$9('[client/actors] [addModelsToDb] Warning: Could not find or create model:', modelName);
                 hasModelsInDb = false;
                 continue;
             }
@@ -3193,7 +3173,7 @@ async function addModelsToDb(context) {
         }
         // If we have no models to process, still send success (empty models is valid)
         if (modelNamesWithRows.size === 0) {
-            logger$8('[client/actors] [addModelsToDb] No models to process, but continuing');
+            logger$9('[client/actors] [addModelsToDb] No models to process, but continuing');
             return;
         }
         // Fetch schemas from EAS in background - do not block init. EAS can be slow (10s+);
@@ -3205,7 +3185,7 @@ async function addModelsToDb(context) {
                     timeout = setTimeout(() => reject(new Error('EAS query timeout after 10 seconds')), 10000);
                 });
                 // The lookup and the model_uids rule sync uses too (each name at its nameMatch level).
-                const { getModelSchemasFromEas } = await import('./eas-FZPPqxqe.js');
+                const { getModelSchemasFromEas } = await import('./eas-MXEdKKVc.js');
                 const lookups = await localModelSchemaLookups([...modelNamesWithRows]);
                 // Cleared, so a finished lookup doesn't keep a Node process alive for 10 s.
                 const schemas = await Promise.race([getModelSchemasFromEas(lookups), timeoutPromise]).finally(() => clearTimeout(timeout));
@@ -3217,16 +3197,11 @@ async function addModelsToDb(context) {
                     requestEasSyncFromModelsInit();
                 }
                 else {
-                    logger$8('[client/actors] [addModelsToDb] No schemas found from EAS, but continuing');
+                    logger$9('[client/actors] [addModelsToDb] No schemas found from EAS, but continuing');
                 }
             }
             catch (error) {
-                if (isTestOrSeedDev()) {
-                    logger$8('[client/actors] [addModelsToDb] Warning: Could not fetch schemas from EAS (background):', error.message);
-                }
-                else {
-                    logger$8('[client/actors] [addModelsToDb] Error fetching schemas (background):', error.message);
-                }
+                logger$9('[client/actors] [addModelsToDb] Error fetching schemas (background):', error.message);
                 // Probably offline: the startup sync waits for this lookup, so try again.
                 modelUidsRetry.schedule();
             }
@@ -3240,18 +3215,16 @@ async function addModelsToDb(context) {
         await _addModelsToDb();
         // Model.findByModelType reads the nameMatch levels synchronously: have them before init is ready.
         await loadNameMatchLevels().catch((error) => {
-            logger$8('[client/actors] [addModelsToDb] Could not load nameMatch levels:', error);
+            logger$9('[client/actors] [addModelsToDb] Could not load nameMatch levels:', error);
         });
     }
     catch (error) {
-        logger$8('[client/actors] [addModelsToDb] Error:', error);
-        // In test environments, initialization completes anyway
-        if (!isTestOrSeedDev())
-            throw error;
+        logger$9('[client/actors] [addModelsToDb] Error:', error);
+        throw error;
     }
 }
 
-const logger$7 = debug('seedSdk:helpers:localDbChain');
+const logger$8 = debug('seedSdk:helpers:localDbChain');
 /** appState key recording which EAS chain the local database holds attestations from. */
 const EAS_CHAIN_ID_APP_STATE_KEY = 'easChainId';
 /**
@@ -3321,7 +3294,7 @@ async function loadLocalDbChain() {
     const localChainId = await resolveLocalDbChainId(appDb);
     if (localChainId !== undefined) {
         configureEasReadChain('localDb', { chainId: localChainId });
-        logger$7('local DB holds chain %d', localChainId);
+        logger$8('local DB holds chain %d', localChainId);
         return;
     }
     if (isEasReadChainConfigured()) {
@@ -3370,7 +3343,7 @@ function resetAddressesPersistedAnnouncement() {
     lastAnnounced = undefined;
 }
 
-const logger$6 = debug('seedSdk:client:actors:saveConfig');
+const logger$7 = debug('seedSdk:client:actors:saveConfig');
 let warnedKeptStoredAddresses = false;
 /**
  * Saves the addresses passed to init.
@@ -3415,22 +3388,17 @@ async function persistInitAddresses(appDb, { addresses, addressesProvided, owned
  * checks the database's chain against the configured one.
  */
 async function saveConfig(context) {
-    logger$6('saveConfig starting');
+    logger$7('saveConfig starting');
     const { endpoints, addresses, addressesProvided, ownedAddresses, watchedAddresses, arweaveDomain, uploadApiBaseUrl, gatewayTransport, gatewayHyperKey, gatewaySidecarHost, gatewaySidecarPort, gatewayProxyBaseUrl, } = context;
     // Validate endpoints - required for proper initialization
     if (!endpoints || !endpoints.filePaths || !endpoints.files) {
-        logger$6('[internal/actors] [saveConfig] Invalid endpoints:', { endpoints });
+        logger$7('[internal/actors] [saveConfig] Invalid endpoints:', { endpoints });
         throw new Error('saveConfig called with invalid endpoints: endpoints must include both filePaths and files');
     }
     const _saveConfig = async () => {
         try {
             const appDb = BaseDb.getAppDb();
             if (!appDb) {
-                // In test environments, continue anyway
-                if (isTestOrSeedDev()) {
-                    logger$6('[internal/actors] [saveConfig] App DB not found, but continuing in test environment');
-                    return;
-                }
                 throw new Error('App DB not found');
             }
             const endpointsValueString = JSON.stringify(endpoints);
@@ -3483,21 +3451,16 @@ async function saveConfig(context) {
             await loadLocalDbChain();
         }
         catch (error) {
-            logger$6('[internal/actors] [saveConfig] Error saving config:', error);
-            // In test environments, continue anyway
-            if (isTestOrSeedDev()) {
-                logger$6('[internal/actors] [saveConfig] Continuing despite error in test environment');
-                return;
-            }
+            logger$7('[internal/actors] [saveConfig] Error saving config:', error);
             throw error;
         }
     };
     // Init writes run one tab at a time (docs/MULTI_TAB.md).
     await withSeedDbLock('init', context.filesDir, _saveConfig);
-    logger$6('[internal/actors] [saveConfig] saveConfig success');
+    logger$7('[internal/actors] [saveConfig] saveConfig success');
 }
 
-const logger$5 = debug('seedSdk:helpers:schema');
+const logger$6 = debug('seedSdk:helpers:schema');
 /** Filesystem-safe schema name: other characters become `_`, runs of `_` collapse, ends trimmed. */
 const sanitizeSchemaName = (name) => name
     .replace(/[^a-zA-Z0-9\s_-]/g, '_')
@@ -3551,7 +3514,7 @@ async function readSchemaFile(filePath) {
         return schema;
     }
     catch (error) {
-        logger$5(`Could not read schema file ${filePath}:`, error);
+        logger$6(`Could not read schema file ${filePath}:`, error);
         return undefined;
     }
 }
@@ -3565,7 +3528,7 @@ async function listCompleteSchemaFiles() {
     const workingDir = BaseFileManager.getWorkingDir();
     try {
         if (!(await BaseFileManager.pathExists(workingDir))) {
-            logger$5(`Working directory does not exist yet: ${workingDir}, returning empty schema list`);
+            logger$6(`Working directory does not exist yet: ${workingDir}, returning empty schema list`);
             return [];
         }
         const files = await fs.promises.readdir(workingDir);
@@ -3636,7 +3599,7 @@ async function loadAllSchemasFromDb() {
             });
         }
         catch (error) {
-            logger$5(`Error resolving schema row ${row.name}:`, error);
+            logger$6(`Error resolving schema row ${row.name}:`, error);
         }
     }
     return result;
@@ -3668,7 +3631,7 @@ var schema = /*#__PURE__*/Object.freeze({
     readSchemaFile: readSchemaFile
 });
 
-function toBytes(data) {
+function toBytes$1(data) {
     if (typeof data === 'string')
         return utf8ToBytes(data);
     if (data instanceof Uint8Array)
@@ -3676,7 +3639,7 @@ function toBytes(data) {
     return new Uint8Array(data);
 }
 const getContentHash = async (data) => {
-    return bytesToHex(sha3_256(toBytes(data)));
+    return bytesToHex(sha3_256(toBytes$1(data)));
 };
 /**
  * Generate a deterministic ID from a seed string.
@@ -3700,7 +3663,7 @@ const getDeterministicId = (seed) => {
  * Schema identity is the file id. Missing ids are assigned once, at first apply, and written into
  * the stored file.
  */
-const logger$4 = debug('seedSdk:helpers:schemaApply');
+const logger$5 = debug('seedSdk:helpers:schemaApply');
 const SCHEMA_FILE_FORMAT = 'https://seedprotocol.org/schemas/data-model/v1';
 /**
  * A complete schema file from any accepted shape: models and properties as objects, `version`
@@ -3920,8 +3883,8 @@ async function applySchemaFile(source, options = {}) {
     if (!schemaRecord) {
         warnOnEasNameCollisions(file);
         warnOnInvalidNameMatch(file);
-        const _mod_14 = await import('./tabEvents-DT5ez6io.js');
-        const _ns_14 = _mod_14.bk;
+        const _mod_14 = await import('./Item-BU9wIT7l.js');
+        const _ns_14 = _mod_14.bS;
         const { addModelsToDb, broadcastSchemasInvalidate } = _ns_14;
         const modelFileIds = new Map(Object.entries(file.models).map(([name, model]) => [name, model.id]));
         const propertyDefinitions = schemaFilePropertyDefinitions(file);
@@ -3959,10 +3922,10 @@ async function applySchemaFile(source, options = {}) {
             broadcastSchemasInvalidate();
         // A cached instance is otherwise never re-read from its row (createById returns it as is)
         await refreshCachedProperties(updatedPropertyFileIds);
-        logger$4(`Applied schema ${file.metadata.name} v${file.version} (${file.id})`);
+        logger$5(`Applied schema ${file.metadata.name} v${file.version} (${file.id})`);
     }
     else {
-        logger$4(`Schema ${file.metadata.name} v${file.version} (${file.id}) already applied`);
+        logger$5(`Schema ${file.metadata.name} v${file.version} (${file.id}) already applied`);
     }
     const models = await createModelsForSchemaFile(file);
     // Callers use the models next (an item create reads their properties): wait until each has them.
@@ -3993,7 +3956,7 @@ async function storeSchemaFile(file, onChangedContent) {
     }
     if (onChangedContent === 'bump') {
         file.version = Math.max(...versions.map((info) => info.version)) + 1;
-        logger$4(`Schema ${file.metadata.name} content changed, storing it as v${file.version}`);
+        logger$5(`Schema ${file.metadata.name} content changed, storing it as v${file.version}`);
         return writeSchemaFile(file);
     }
     console.warn(`[seed] schema ${file.metadata.name} v${file.version}: content changed but id ` +
@@ -4015,7 +3978,7 @@ async function unlinkModelsFromSchema(db, schemaId, modelNames) {
     if (links.length === 0)
         return;
     await db.delete(modelSchemas).where(inArray(modelSchemas.id, links.map((link) => link.id)));
-    logger$4(`Unlinked models dropped from the schema (schema id ${schemaId}): ${modelNames.join(', ')}`);
+    logger$5(`Unlinked models dropped from the schema (schema id ${schemaId}): ${modelNames.join(', ')}`);
 }
 /**
  * A schema row's definition. A draft row's is its `schema_data`; a published row's is its
@@ -4034,7 +3997,7 @@ async function resolveSchemaRow(row, db = BaseDb.getAppDb()) {
             return { ...data, models: normalizeSchemaModels(data.models) };
         }
         catch (error) {
-            logger$4(`Could not parse schema_data of ${row.name}:`, error);
+            logger$5(`Could not parse schema_data of ${row.name}:`, error);
             return undefined;
         }
     };
@@ -4072,8 +4035,8 @@ async function resolveSchemaRow(row, db = BaseDb.getAppDb()) {
         metadata: { ...schema.metadata, name: row.name },
     };
     if (row.id && db) {
-        const _mod_15 = await import('./tabEvents-DT5ez6io.js');
-        const _ns_15 = _mod_15.bk;
+        const _mod_15 = await import('./Item-BU9wIT7l.js');
+        const _ns_15 = _mod_15.bS;
         const { loadModelsFromDbForSchema, mergeDbModelsIntoSchemaModels } = _ns_15;
         const dbModels = await loadModelsFromDbForSchema(row.id, db);
         if (Object.keys(dbModels).length > 0) {
@@ -4140,7 +4103,7 @@ async function writeNextSchemaVersion(schemaNameOrId, patch, change) {
         ],
     };
     const filePath = await writeSchemaFile(schemaFile);
-    logger$4(`Wrote schema ${schemaFile.metadata.name} v${version} at ${filePath}`);
+    logger$5(`Wrote schema ${schemaFile.metadata.name} v${version} at ${filePath}`);
     if (change.apply !== false) {
         await applySchemaFile(schemaFile, { store: false, modelRenames: change.modelRenames });
     }
@@ -4443,7 +4406,7 @@ var SEEDPROTOCOL_Seed_Protocol_v1 = /*#__PURE__*/Object.freeze({
     version: version
 });
 
-const logger$3 = debug('seedSdk:client:actors:processSchemaFiles');
+const logger$4 = debug('seedSdk:client:actors:processSchemaFiles');
 let processSchemaFilesChain = Promise.resolve();
 function resolveSchemaFilePath(schemaFile) {
     const path = BaseFileManager.getPathModule();
@@ -4475,7 +4438,7 @@ async function processSchemaFilesOnce(context) {
         appliedNames.add(applied.schemaFile.metadata.name);
     }
     catch (error) {
-        logger$3('Error loading internal seed-protocol schema:', error);
+        logger$4('Error loading internal seed-protocol schema:', error);
     }
     // The app's schema (canonical) takes precedence over schemaFile
     if (context.schema) {
@@ -4514,14 +4477,14 @@ async function processSchemaFilesOnce(context) {
         loaded = await loadAllSchemasFromDb();
     }
     catch (error) {
-        logger$3('Error loading schemas from database (continuing anyway):', error);
+        logger$4('Error loading schemas from database (continuing anyway):', error);
     }
     for (const { schema } of loaded) {
         try {
             Object.assign(allModels, await createModelsForSchemaFile(schema));
         }
         catch (error) {
-            logger$3(`Error creating models for schema ${schema.metadata?.name}:`, error);
+            logger$4(`Error creating models for schema ${schema.metadata?.name}:`, error);
         }
     }
     return allModels;
@@ -4532,7 +4495,7 @@ async function processSchemaFilesOnce(context) {
  * (docs/MULTI_TAB.md), and so do overlapping inits in this tab.
  */
 function processSchemaFiles(context) {
-    logger$3('processSchemaFiles started');
+    logger$4('processSchemaFiles started');
     const run = processSchemaFilesChain.then(() => withSeedDbLock('init', context.filesDir, () => processSchemaFilesOnce(context)));
     // The chain only orders runs; a failed run must not fail the next init too.
     processSchemaFilesChain = run.then(() => { }, () => { });
@@ -4552,7 +4515,7 @@ async function applyPendingSchemaFiles(appliedNames) {
         files = await listLatestSchemaFiles();
     }
     catch (error) {
-        logger$3('Error listing schema files (continuing anyway):', error);
+        logger$4('Error listing schema files (continuing anyway):', error);
         return;
     }
     const rows = await db
@@ -4571,12 +4534,12 @@ async function applyPendingSchemaFiles(appliedNames) {
                 await applySchemaFile({ ...file, id: file.id ?? info.schemaFileId }, { store: false });
         }
         catch (error) {
-            logger$3(`Error applying schema file ${info.filePath}:`, error);
+            logger$4(`Error applying schema file ${info.filePath}:`, error);
         }
     }
 }
 
-const logger$2 = debug('seedSdk:db:canonicalizeModelTypes');
+const logger$3 = debug('seedSdk:db:canonicalizeModelTypes');
 /**
  * Model types in the local DB (`seeds.type`, `versions.seed_type`, `metadata.model_type`) are the
  * EAS name of the model (ADR 0008): `html_page` for HTMLPage. Rows written before that hold other
@@ -4614,7 +4577,7 @@ async function canonicalizeModelTypes() {
         await appDb.update(seeds).set({ type: next }).where(eq(seeds.type, type));
         await appDb.update(versions).set({ seedType: next }).where(eq(versions.seedType, type));
         await appDb.update(metadata$1).set({ modelType: next }).where(eq(metadata$1.modelType, type));
-        logger$2(`model type ${type} → ${next}`);
+        logger$3(`model type ${type} → ${next}`);
         rewritten++;
     }
     return rewritten;
@@ -4627,7 +4590,7 @@ const runInBackground = () => {
         .then(() => undefined)
         .catch((error) => {
         // Never fails init: readers still match old types by name, only exact type filters miss them.
-        logger$2('canonicalizing model types failed', error);
+        logger$3('canonicalizing model types failed', error);
     })
         .finally(() => {
         running = undefined;
@@ -4679,10 +4642,26 @@ const getVersionData = async ({ localId, seedLocalId, uid, }, db = BaseDb.getApp
     return queryRows[0];
 };
 
-const logger$1 = debug('seedSdk:write:updateItemPropertyValue');
+/**
+ * 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, 
+/** The database or transaction to read; the app database by default. */
+db = BaseDb.getAppDb()) {
+    if (!seedLocalId)
+        return undefined;
+    const row = await findSeedRow({ localId: seedLocalId }, db);
+    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, retract, }, options = {}) => {
     if (!localIdParam && !seedLocalId) {
-        logger$1(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
+        logger$2(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
         return;
     }
     // Every write below binds parameters: store the value as given (no SQL escaping).
@@ -4739,7 +4718,9 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
             rows = newestRows.slice(0, 1);
     }
     if (rows && rows.length > 0) {
-        const { localId, uid, propertyId: propertyIdFromDb, propertyName: propertyNameFromDb, propertyValue: propertyValueFromDb, modelType, seedLocalId: seedLocalIdFromDb, versionLocalId, schemaUid, easDataType, refSeedType: refSeedTypeFromDb, refResolvedValue: refResolvedValueFromDb, retract: retractFromDb, } = rows[0];
+        const { localId, uid, propertyId: propertyIdFromDb, propertyName: propertyNameFromDb, propertyValue: propertyValueFromDb, modelType, seedLocalId: seedLocalIdFromDb, versionLocalId, schemaUid: schemaUidFromDb, easDataType, refSeedType: refSeedTypeFromDb, refResolvedValue: refResolvedValueFromDb, retract: retractFromDb, } = rows[0];
+        // The resolved schema uid fills in a row stored before its schema was known.
+        const rowSchemaUid = schemaUidFromDb || schemaUid;
         // Stored model types are the model's EAS name (ADR 0008): `blog_post` for BlogPost.
         const modelTypeForName = modelName ? easName(modelName) : undefined;
         if (propertyValueFromDb === newValue &&
@@ -4748,8 +4729,8 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
             (refSeedTypeFromDb ?? null) === (refSeedType ?? null) &&
             (refResolvedValueFromDb ?? null) === (refResolvedValue ?? null) &&
             !!retractFromDb === !!retractValue) {
-            logger$1(`[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`);
-            return localId == null ? undefined : { localId, uid: uid ?? null, schemaUid: schemaUid ?? '' };
+            logger$2(`[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`);
+            return localId == null ? undefined : { localId, uid: uid ?? null, schemaUid: schemaUidFromDb ?? '' };
         }
         // This means we already have a local-only record so we should just update that one
         if (!uid) {
@@ -4774,11 +4755,14 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
             if (propertyIdFromDb == null && property.propertyId != null) {
                 updatePayload.propertyId = property.propertyId;
             }
+            if (!schemaUidFromDb && schemaUid) {
+                updatePayload.schemaUid = schemaUid;
+            }
             await appDb
                 .update(metadata$1)
                 .set(updatePayload)
                 .where(eq(metadata$1.localId, localId));
-            return { localId, uid: null, schemaUid: schemaUid ?? '' };
+            return { localId, uid: null, schemaUid: rowSchemaUid ?? '' };
         }
         const seedDataFromDb = seedLocalId ? await findSeedRow({ localId: seedLocalId }, appDb) : null;
         const versionDataFromDb = versionLocalId ? await getVersionData({ localId: versionLocalId }, appDb) : null;
@@ -4798,7 +4782,7 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
             seedLocalId: seedLocalIdFromDb,
             versionLocalId,
             versionUid: versionDataFromDb?.uid || null,
-            schemaUid,
+            schemaUid: rowSchemaUid,
             easDataType: easDataType || null,
             refSeedType: refSeedType || null,
             refResolvedValue: refResolvedValue || null,
@@ -4809,7 +4793,7 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
         return {
             localId: newLocalId,
             uid: null,
-            schemaUid: schemaUid ?? '',
+            schemaUid: rowSchemaUid ?? '',
         };
     }
     // Here there are no records for this property on this seed so we should create one
@@ -4868,6 +4852,116 @@ const createVersion = async ({ seedLocalId, seedUid, seedType, uid, }, options =
     return newVersionLocalId;
 };
 
+/** Error thrown when metadata validation fails (e.g. enum violation). */
+class MetadataValidationError extends Error {
+    constructor(message, validationErrors) {
+        super(message);
+        this.validationErrors = validationErrors;
+        this.name = 'MetadataValidationError';
+    }
+}
+const createMetadata = async (metadataValues, propertyRecordSchema, options) => {
+    const appDb = options?.db ?? BaseDb.getAppDb();
+    metadataValues.localId = generateId();
+    // 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, appDb);
+    if (publisher) {
+        metadataValues.publisher = publisher;
+    }
+    if (!metadataValues.modelType && metadataValues.modelName) {
+        metadataValues.modelType = easName(metadataValues.modelName);
+    }
+    // property_id is the match key (decision D4); the row is written under the property's storage name.
+    const property = await resolveMetadataProperty({
+        propertyId: metadataValues.propertyId,
+        definitionId: propertyRecordSchema?.id,
+        propertyName: metadataValues.propertyName,
+        modelName: metadataValues.modelName ?? metadataValues.modelType,
+        modelFileId: options?.modelFileId,
+        seedLocalId: metadataValues.seedLocalId,
+        seedUid: metadataValues.seedUid,
+    }, appDb, { onAmbiguousModel: 'none' });
+    if (property) {
+        metadataValues.propertyId = property.id;
+        metadataValues.propertyName = property.storageName;
+    }
+    else if (metadataValues.propertyName && propertyRecordSchema) {
+        metadataValues.propertyName = metadataStorageName(metadataValues.propertyName, propertyRecordSchema);
+    }
+    const isItemStorage = propertyRecordSchema && propertyRecordSchema.storageType === 'ItemStorage';
+    // if (
+    //   propertyRecordSchema &&
+    //   propertyRecordSchema.localStorageDir &&
+    //   isItemStorage
+    // ) {
+    //   const filename = `${metadataValues.seedUid || metadataValues.seedLocalId}${propertyRecordSchema.filenameSuffix}`
+    //   const filePath = path.join(propertyRecordSchema.localStorageDir, filename)
+    //   await fs.promises.writeFile(filePath, metadataValues.propertyValue)
+    //   metadataValues.propertyValue = filename
+    //   metadataValues.refValueType = 'file'
+    // }
+    // Convert propertyValue to string if it's not already (metadata table expects text)
+    if (metadataValues.propertyValue !== undefined && metadataValues.propertyValue !== null) {
+        if (Array.isArray(metadataValues.propertyValue)) {
+            // List values: JSON array is the storage format (String() would give legacy comma-separated ids)
+            metadataValues.propertyValue = JSON.stringify(metadataValues.propertyValue);
+        }
+        else if (typeof metadataValues.propertyValue !== 'string') {
+            metadataValues.propertyValue = String(metadataValues.propertyValue);
+        }
+    }
+    // Validate against property validation rules (enum, pattern, minLength, maxLength) unless skipped
+    if (!options?.skipValidation &&
+        propertyRecordSchema?.validation &&
+        metadataValues.propertyValue != null &&
+        metadataValues.propertyValue !== '') {
+        const { SchemaValidationService } = await import('./SchemaValidationService-Dc-lpFQX.js');
+        const validationService = new SchemaValidationService();
+        const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
+            ? normalizeDataType(String(propertyRecordSchema.refValueType))
+            : undefined);
+        if (!validationResult.isValid && validationResult.errors.length > 0) {
+            const validationErrors = validationResult.errors.map((e) => ({
+                field: e.field,
+                message: e.message,
+                code: e.code,
+            }));
+            const message = validationErrors.map((e) => e.message).join('; ');
+            throw new MetadataValidationError(message, validationErrors);
+        }
+    }
+    // With a given db (a transaction), the caller resolves schemaUid first: the lookup may call EAS.
+    // Without one it isn't required for metadata insertion, so a failed lookup leaves it unset.
+    if (!options?.db && !isItemStorage && !metadataValues.schemaUid && metadataValues.propertyName) {
+        const schemaUid = await lookupPropertySchemaUid(metadataValues.propertyName, propertyRecordSchema);
+        if (schemaUid)
+            metadataValues.schemaUid = schemaUid;
+    }
+    let inserted;
+    try {
+        inserted = await appDb
+            .insert(metadata$1)
+            .values({
+            ...metadataValues,
+            // Stamped here: a value carried in metadataValues would otherwise win over the column default.
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        })
+            .returning();
+    }
+    catch (error) {
+        // Drizzle's message is the full SQL; the driver error that explains it is only on `cause`.
+        const cause = error?.cause;
+        const reason = cause instanceof Error ? cause.message : cause != null ? String(cause) : undefined;
+        throw new Error(`Failed to insert metadata for property ${metadataValues.propertyName}` +
+            (reason ? `: ${reason}` : `: ${error instanceof Error ? error.message : String(error)}`), { cause: error });
+    }
+    if (!inserted || inserted.length === 0) {
+        throw new Error(`Failed to insert metadata record for property ${metadataValues.propertyName}`);
+    }
+    return inserted[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));
 /**
@@ -5008,8 +5102,8 @@ async function applyStorageValue(seedLocalId, propertyName, value, db, prepared)
     const row = prepared
         ? { ...stored, refResolvedValue: prepared.fileName, schemaUid: prepared.schemaUid, refModelUid: prepared.refModelUid }
         : stored;
-    const _mod_16 = await import('./Item-oPnmIehk.js');
-    const _ns_16 = _mod_16.b7;
+    const _mod_16 = await import('./Item-BU9wIT7l.js');
+    const _ns_16 = _mod_16.bT;
     const { currentPropertyRow } = _ns_16;
     const existing = await currentPropertyRow({ seedLocalId }, {
         propertyName,
@@ -5322,8 +5416,8 @@ function startItemOutbox() {
                     return {};
                 // Cached, shared with item creation, so a save doesn't wait on the EAS indexer each time.
                 // Not required for the row; publish resolves the schema again.
-                const _mod_17 = await import('./Item-oPnmIehk.js');
-                const _ns_17 = _mod_17.ba;
+                const _mod_17 = await import('./Item-BU9wIT7l.js');
+                const _ns_17 = _mod_17.bU;
                 const { lookupPropertySchemaUid } = _ns_17;
                 return {
                     schemaUid: await lookupPropertySchemaUid(op.propertyName, value.propertyRecordSchema),
@@ -6258,7 +6352,7 @@ async function claimPendingCreates(tx, publisher) {
     return claimed;
 }
 
-const logger = debug('seedSdk:client');
+const logger$1 = debug('seedSdk:client');
 const createClientManager = () => {
     const actor = createActor(clientManagerMachine, {
         input: {
@@ -6269,8 +6363,8 @@ const createClientManager = () => {
         }
     });
     const actorSubscription = actor.subscribe((snapshot) => {
-        logger('ClientManager snapshot.value:', snapshot.value);
-        logger('ClientManager snapshot.context.isInitialized:', snapshot.context.isInitialized);
+        logger$1('ClientManager snapshot.value:', snapshot.value);
+        logger$1('ClientManager snapshot.context.isInitialized:', snapshot.context.isInitialized);
     });
     actor.start();
     return { actor, actorSubscription };
@@ -6286,7 +6380,7 @@ const notifyServiceListeners = () => {
             listener(clientManager);
         }
         catch (error) {
-            logger('subscribeService listener threw:', error);
+            logger$1('subscribeService listener threw:', error);
         }
     }
 };
@@ -6356,14 +6450,14 @@ const coalescedInit = createCoalescedAsync(async (options) => {
     const isStopped = snapshot.status === 'stopped';
     if (isStopped) {
         // stop() (or a failed test) stopped it: start over with a new actor and a clean context.
-        logger('Client manager was stopped, creating a new one');
+        logger$1('Client manager was stopped, creating a new one');
         ({ actor: clientManager, actorSubscription: subscription } = createClientManager());
         notifyServiceListeners();
     }
     // Clear any stale context from previous failed initializations
     // This ensures we start with a clean slate before the new init updates it
     if (!isStopped && currentState !== 'uninitialized') {
-        logger(`Client manager is in state ${currentState}, clearing stale context before re-init...`);
+        logger$1(`Client manager is in state ${currentState}, clearing stale context before re-init...`);
         clientManager.send({
             type: 'updateContext',
             context: {
@@ -6464,14 +6558,14 @@ const clientInstance = {
     },
     setAddresses: async (addresses) => {
         ensureInitialized();
-        logger('setAddresses', addresses);
+        logger$1('setAddresses', addresses);
         clientManager.send({ type: 'setAddresses', addresses });
         await waitFor(clientManager, (snapshot) => !snapshot.context.isSaving, { timeout: 10000 });
         const saveError = clientManager.getSnapshot().context.saveError;
         if (saveError) {
             throw saveError instanceof Error ? saveError : new Error(String(saveError));
         }
-        logger('setAddresses success', addresses);
+        logger$1('setAddresses success', addresses);
     },
     getAddresses: async () => {
         ensureInitialized();
@@ -6585,6 +6679,1457 @@ const getClient = () => {
     return clientInstance;
 };
 
+const getMetadata = async (props) => {
+    const appDb = BaseDb.getAppDb();
+    let storageTransactionId;
+    if (props) {
+        storageTransactionId = props.storageTransactionId;
+    }
+    const whereClauses = [];
+    if (storageTransactionId) {
+        whereClauses.push(eq(metadata$1.propertyName, 'storageTransactionId'));
+        whereClauses.push(eq(metadata$1.propertyValue, storageTransactionId));
+    }
+    const metadataRows = await appDb
+        .select()
+        .from(metadata$1)
+        .where(and(...whereClauses));
+    if (!metadataRows || metadataRows.length === 0) {
+        return;
+    }
+    return metadataRows[0];
+};
+
+/**
+ * The local seed row a relation/list/image ref points at, by local id or uid. A uid resolves as
+ * {@link findSeedRow} resolves it (the order EAS sync matches seeds in): the old uid of a seed
+ * that was unpublished and published again resolves to that seed, through its old version rows.
+ * Null when nothing local matches (e.g. a published uid with no local copy).
+ */
+const findRelatedSeedRow = async ({ seedLocalId, seedUid, }) => {
+    const row = await findSeedRow({ localId: seedLocalId, uid: seedUid });
+    return row ? { seedLocalId: row.localId, seedUid: row.uid, revokedAt: row.revokedAt, type: row.type } : null;
+};
+/** The seed is attested and its attestation is live. */
+const isLivePublishedSeed = (row) => !!row?.seedUid && row.seedUid !== ZERO_BYTES32 && !isVersionRevoked(row.revokedAt);
+/** The seed was attested and that attestation was revoked (unpublished). */
+const isUnpublishedSeed = (row) => !!row?.seedUid && row.seedUid !== ZERO_BYTES32 && isVersionRevoked(row.revokedAt);
+/** Model a relation/list/image property points at, from its definition. */
+function relatedModelNameFromDef(propertyDef) {
+    const def = propertyDef;
+    if (!def)
+        return undefined;
+    const dataType = normalizeDataType(def.dataType);
+    if (dataType === ModelPropertyDataTypes.Image)
+        return 'Image';
+    if (dataType === ModelPropertyDataTypes.File)
+        return 'File';
+    if (dataType === ModelPropertyDataTypes.Html)
+        return 'Html';
+    return def.ref ?? def.refModelName;
+}
+
+const STORAGE_SEED_TYPES = new Set([
+    ModelPropertyDataTypes.Image,
+    ModelPropertyDataTypes.File,
+    ModelPropertyDataTypes.Html,
+    ModelPropertyDataTypes.Json,
+]);
+const isStorageTransactionPropertyName = (name) => name === 'storageTransactionId' || name === 'storage_transaction_id';
+function publishPropertyKind(key, def) {
+    const dataType = normalizeDataType(def.dataType);
+    const refValueType = normalizeDataType(def.refValueType);
+    if (STORAGE_SEED_TYPES.has(dataType))
+        return 'storageSeed';
+    if (dataType === ModelPropertyDataTypes.Relation) {
+        return STORAGE_SEED_TYPES.has(refValueType) ? 'storageSeed' : 'relation';
+    }
+    if (dataType === ModelPropertyDataTypes.List)
+        return def.ref || def.refModelName ? 'list' : 'basic';
+    if (def.storageType === 'ItemStorage')
+        return 'itemStorage';
+    if (isStorageTransactionPropertyName(key))
+        return 'storageTransaction';
+    return 'basic';
+}
+const isEmptyValue = (value) => value == null || value.trim() === '';
+/** The seed refs a property's stored value names: one (Relation, storage seed) or each list member. */
+function refsOf(value, kind) {
+    if (isEmptyValue(value))
+        return [];
+    if (kind === 'list') {
+        return parseListPropertyValueFromStorage(value)
+            .map((member) => normalizeRelationPropertyValue(member))
+            .filter((ref) => !!ref);
+    }
+    const ref = normalizeRelationPropertyValue(value);
+    return ref ? [ref] : [];
+}
+async function modelOfSeed(seed, modelNameHint) {
+    if (seed.modelFileId) {
+        const model = await resolveModelRecord(undefined, { modelFileId: seed.modelFileId });
+        if (model)
+            return model;
+    }
+    return (await resolveModelRecordByNameOrType(seed.type ?? modelNameHint, {})) ?? undefined;
+}
+/** One seed with its model's properties and their current rows. Undefined when the seed or its model isn't local. */
+async function readNode(seedLocalId, kind, modelNameHint) {
+    const db = BaseDb.getAppDb();
+    if (!db)
+        return undefined;
+    const seed = await findSeedRow({ localId: seedLocalId });
+    if (!seed)
+        return undefined;
+    const model = await modelOfSeed(seed, modelNameHint);
+    if (!model)
+        return undefined;
+    const definitions = await getPropertyDefinitions(model.id);
+    const metadataProperties = await readModelMetadataProperties(db, model.id);
+    const seedUid = isValidEasAttestationUid(seed.uid) ? seed.uid : undefined;
+    const seedRef = { seedLocalId: seed.localId, seedUid };
+    const properties = [];
+    for (const [key, definition] of definitions) {
+        const property = metadataProperties.find((p) => p.id === definition._dbId);
+        const match = property
+            ? { property, propertyId: property.id, names: metadataPropertyNameForms(property) }
+            : { property: undefined, propertyId: null, names: [key] };
+        const row = await currentPropertyRow(seedRef, { match, propertyName: key }, { overlay: false });
+        const propertyKind = publishPropertyKind(key, definition);
+        properties.push({
+            key,
+            definition,
+            kind: propertyKind,
+            row,
+            uid: isValidEasAttestationUid(row?.uid) ? row.uid : undefined,
+            walked: false,
+            deferred: false,
+            refs: [],
+        });
+    }
+    const head = await getLatestVersionRow(seed.localId);
+    const published = seedUid ? await getLatestPublishedVersionRow(seed.localId) : null;
+    const isFullNode = kind === 'root' || kind === 'draft';
+    const embeddedImages = isFullNode
+        ? await db.select().from(htmlEmbeddedImageCoPublish).where(eq(htmlEmbeddedImageCoPublish.parentSeedLocalId, seed.localId))
+        : [];
+    return {
+        seedLocalId: seed.localId,
+        kind,
+        seedUid,
+        newSeed: !seedUid || (kind === 'root' && isVersionRevoked(seed.revokedAt)),
+        modelName: model.name,
+        seedSchemaUid: isValidEasAttestationUid(seed.schemaUid) ? seed.schemaUid : undefined,
+        version: {
+            localId: head?.localId ?? undefined,
+            uid: isValidEasAttestationUid(head?.uid) ? head.uid : undefined,
+            publishedUid: published?.uid,
+        },
+        properties,
+        links: [],
+        embeddedImages,
+    };
+}
+/** The Html property of `node` whose value is the Html storage seed `htmlSeedLocalId`. */
+function htmlPropertyForHtmlSeed(node, htmlSeedLocalId) {
+    const want = htmlSeedLocalId.trim();
+    return node.properties.find((p) => normalizeDataType(p.definition.dataType) === ModelPropertyDataTypes.Html && p.row?.propertyValue?.trim() === want);
+}
+/**
+ * The publish graph of the seed `root` (an Item, or any `{ seedLocalId }`). Waits for pending
+ * outbox ops first, so every edit made before publishing is in its row (ADR 0019), then reads rows
+ * only.
+ */
+async function getPublishGraph(root, options = {}) {
+    const { waitForPendingOutboxOps } = await import('./index-BXTyvnKb.js');
+    await waitForPendingOutboxOps();
+    const rootNode = await readNode(root.seedLocalId, 'root', root.modelName);
+    if (!rootNode)
+        throw new Error(`Cannot publish ${root.seedLocalId}: no local seed with a known model`);
+    const republishRevokedSeed = !!rootNode.seedUid && rootNode.newSeed;
+    const forceFullSnapshot = options.publishMode === 'new_version' || republishRevokedSeed;
+    const graph = {
+        root: rootNode,
+        nodes: [],
+        forceFullSnapshot,
+        republishRevokedSeed,
+        unpublishedRelatedItems: [],
+        relatedRefUids: new Map(),
+        brokenRefs: [],
+        missingEmbeddedImages: [],
+    };
+    const nodes = new Map([[rootNode.seedLocalId, rootNode]]);
+    // Items getting a new seed in this publish whose walk hasn't finished: a ref to one is a back edge
+    const inProgress = new Set();
+    const noteUnpublished = (propertyKey, modelName, seed) => {
+        if (graph.unpublishedRelatedItems.some((r) => r.propertyName === propertyKey && r.seedLocalId === seed.seedLocalId))
+            return;
+        graph.unpublishedRelatedItems.push({
+            propertyName: propertyKey,
+            modelName: modelName ?? seed.type ?? 'unknown',
+            seedLocalId: seed.seedLocalId,
+            seedUid: seed.seedUid,
+        });
+    };
+    const link = (target, owner, propertyKey) => {
+        if (!target.links.some((l) => l.seedLocalId === owner.seedLocalId && l.propertyKey === propertyKey)) {
+            target.links.push({ seedLocalId: owner.seedLocalId, propertyKey });
+        }
+    };
+    /**
+     * Follows one ref of `property`: a draft target becomes a node (walked now, or already in the
+     * graph). Returns the ref with its node, or undefined for a back edge.
+     */
+    const follow = async (owner, property, ref) => {
+        const list = property.kind === 'list';
+        const { seedLocalId, seedUid } = resolveSeedIdsFromRefString(ref);
+        if (!seedLocalId && !seedUid) {
+            graph.brokenRefs.push({ seedLocalId: owner.seedLocalId, propertyKey: property.key, ref, reason: 'invalid', list });
+            return { ref };
+        }
+        const row = await findRelatedSeedRow({ seedLocalId, seedUid });
+        const targetLocalId = row?.seedLocalId ?? seedLocalId;
+        if (property.kind !== 'storageSeed' && targetLocalId && inProgress.has(targetLocalId))
+            return 'backEdge';
+        if (isUnpublishedSeed(row)) {
+            const targetNode = nodes.get(row.seedLocalId);
+            noteUnpublished(property.key, targetNode?.modelName ?? relatedModelNameFromDef(property.definition), row);
+            return { ref, seedLocalId: row.seedLocalId };
+        }
+        if (isLivePublishedSeed(row)) {
+            if (ref !== row.seedUid)
+                graph.relatedRefUids.set(ref, row.seedUid);
+            return { ref, seedLocalId: row.seedLocalId };
+        }
+        if (!row) {
+            // An attested uid with no local copy is already published: attested as-is
+            if (!isPublishedSeedRef(ref)) {
+                graph.brokenRefs.push({ seedLocalId: owner.seedLocalId, propertyKey: property.key, ref, reason: 'missing', list });
+            }
+            return { ref, seedLocalId };
+        }
+        let node = nodes.get(row.seedLocalId);
+        if (!node) {
+            const kind = property.kind === 'storageSeed' ? 'storageSeed' : 'draft';
+            node = await readNode(row.seedLocalId, kind, relatedModelNameFromDef(property.definition));
+            if (!node) {
+                graph.brokenRefs.push({ seedLocalId: owner.seedLocalId, propertyKey: property.key, ref, reason: 'missing', list });
+                return { ref, seedLocalId: row.seedLocalId };
+            }
+            nodes.set(node.seedLocalId, node);
+            await visit(node);
+        }
+        return { ref, seedLocalId: node.seedLocalId, node };
+    };
+    const walkProperty = async (owner, property) => {
+        const refs = refsOf(property.row?.propertyValue, property.kind);
+        property.walked = refs.length > 0 && (!property.uid || forceFullSnapshot);
+        if (!property.walked)
+            return;
+        // A list member that is a back edge defers the whole list; its other drafts are still published
+        const followed = [];
+        for (const ref of refs) {
+            const result = await follow(owner, property, ref);
+            if (result === 'backEdge') {
+                property.deferred = true;
+                if (property.kind !== 'list')
+                    return;
+                continue;
+            }
+            followed.push(result);
+        }
+        property.refs = followed;
+        if (property.deferred)
+            return;
+        for (const { node } of followed)
+            if (node)
+                link(node, owner, property.key);
+    };
+    const walkEmbeddedImages = async (owner) => {
+        const done = new Set();
+        for (const row of owner.embeddedImages) {
+            if (done.has(row.imageSeedLocalId))
+                continue;
+            done.add(row.imageSeedLocalId);
+            const seed = await findRelatedSeedRow({ seedLocalId: row.imageSeedLocalId });
+            if (isUnpublishedSeed(seed)) {
+                noteUnpublished(htmlPropertyForHtmlSeed(owner, row.htmlSeedLocalId)?.key ?? 'html', 'Image', seed);
+                continue;
+            }
+            if (isLivePublishedSeed(seed))
+                continue;
+            if (!seed) {
+                graph.missingEmbeddedImages.push({ seedLocalId: owner.seedLocalId, imageSeedLocalId: row.imageSeedLocalId });
+                continue;
+            }
+            if (nodes.has(seed.seedLocalId))
+                continue;
+            const node = await readNode(seed.seedLocalId, 'embeddedImage', 'Image');
+            if (!node) {
+                graph.missingEmbeddedImages.push({ seedLocalId: owner.seedLocalId, imageSeedLocalId: row.imageSeedLocalId });
+                continue;
+            }
+            nodes.set(node.seedLocalId, node);
+            graph.nodes.push(node);
+        }
+    };
+    async function visit(node) {
+        const full = node.kind === 'root' || node.kind === 'draft';
+        if (node.newSeed)
+            inProgress.add(node.seedLocalId);
+        try {
+            if (full) {
+                for (const property of node.properties) {
+                    if (property.kind === 'relation' || property.kind === 'storageSeed')
+                        await walkProperty(node, property);
+                }
+                await walkEmbeddedImages(node);
+                for (const property of node.properties) {
+                    if (property.kind === 'list')
+                        await walkProperty(node, property);
+                }
+            }
+        }
+        finally {
+            inProgress.delete(node.seedLocalId);
+        }
+        graph.nodes.push(node);
+    }
+    await visit(rootNode);
+    return graph;
+}
+/** Nodes of `graph` that are full items (the root and model drafts): the owners of Html properties and embedded images. */
+const publishGraphItemNodes = (graph) => graph.nodes.filter((n) => n.kind === 'root' || n.kind === 'draft');
+
+const HTML_EMBEDDED_MAX_IMAGES_PER_DOC = 50;
+const HTML_EMBEDDED_MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+const HTML_EMBEDDED_MAX_TOTAL_BYTES = 25 * 1024 * 1024;
+const DATA_URI_IMAGE = /^data:(image\/[a-zA-Z0-9.+-]+);base64,([\s\S]*)$/i;
+const MIME_NORMALIZE = {
+    'image/jpg': 'image/jpeg',
+};
+function normalizeMime(m) {
+    const lower = m.toLowerCase().trim();
+    return MIME_NORMALIZE[lower] ?? lower;
+}
+const ALLOWED_MIMES = new Set([
+    'image/png',
+    'image/jpeg',
+    'image/webp',
+    'image/gif',
+    'image/svg+xml',
+]);
+class HtmlEmbeddedDataUriLimitError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'HtmlEmbeddedDataUriLimitError';
+    }
+}
+function resolveEffectiveHtmlEmbeddedDataUriPolicy(propertyDef, publishLevel) {
+    const fromProp = propertyDef?.htmlEmbeddedDataUriPolicy;
+    if (fromProp === 'materialize' || fromProp === 'preserve')
+        return fromProp;
+    if (publishLevel === 'materialize' || publishLevel === 'preserve')
+        return publishLevel;
+    return 'materialize';
+}
+function getAttr(node, name) {
+    const a = node.attrs?.find((x) => x.name === name);
+    return a?.value;
+}
+/**
+ * Walk fragment tree; collect unique data:image base64 URIs with limits.
+ */
+async function extractDataUriImagesFromHtml(html) {
+    const fragment = parseFragment(html);
+    const found = [];
+    const seenUris = new Set();
+    let totalBytes = 0;
+    const walk = async (node) => {
+        if (node.nodeName === '#text' || node.nodeName === '#comment')
+            return;
+        const el = node;
+        if (el.tagName === 'img') {
+            const src = getAttr(el, 'src')?.trim();
+            if (src && src.startsWith('data:image/')) {
+                const m = DATA_URI_IMAGE.exec(src);
+                if (m) {
+                    const mimeRaw = normalizeMime(m[1]);
+                    if (!ALLOWED_MIMES.has(mimeRaw)) {
+                        throw new HtmlEmbeddedDataUriLimitError(`Unsupported embedded image type: ${mimeRaw}. Allowed: ${[...ALLOWED_MIMES].join(', ')}`);
+                    }
+                    let binary;
+                    try {
+                        const b64 = m[2].replace(/\s/g, '');
+                        binary = Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
+                    }
+                    catch {
+                        throw new HtmlEmbeddedDataUriLimitError('Invalid base64 in embedded image data URI');
+                    }
+                    const byteLength = binary.byteLength;
+                    if (byteLength > HTML_EMBEDDED_MAX_IMAGE_BYTES) {
+                        throw new HtmlEmbeddedDataUriLimitError(`Embedded image exceeds max size (${HTML_EMBEDDED_MAX_IMAGE_BYTES} bytes)`);
+                    }
+                    totalBytes += byteLength;
+                    if (totalBytes > HTML_EMBEDDED_MAX_TOTAL_BYTES) {
+                        throw new HtmlEmbeddedDataUriLimitError(`Total embedded image size exceeds max (${HTML_EMBEDDED_MAX_TOTAL_BYTES} bytes)`);
+                    }
+                    if (!seenUris.has(src)) {
+                        if (seenUris.size >= HTML_EMBEDDED_MAX_IMAGES_PER_DOC) {
+                            throw new HtmlEmbeddedDataUriLimitError(`Too many distinct embedded images (max ${HTML_EMBEDDED_MAX_IMAGES_PER_DOC})`);
+                        }
+                        seenUris.add(src);
+                        const stableKey = await getContentHash(binary);
+                        found.push({ dataUri: src, stableKey, byteLength, mimeType: mimeRaw, bytes: binary });
+                    }
+                }
+            }
+        }
+        const parent = el;
+        if (parent.childNodes) {
+            for (const c of parent.childNodes)
+                await walk(c);
+        }
+    };
+    for (const c of fragment.childNodes)
+        await walk(c);
+    return found;
+}
+function escapeAttributeValue(value) {
+    return value.replace(/&/g, '&').replace(/"/g, '"');
+}
+/**
+ * Rewrite attribute values of `html` by splicing each new value into the original string: every
+ * byte other than the rewritten attributes stays as written. Re-serializing the parsed tree would
+ * not round-trip (parse5 drops the newline the parser eats after `<pre>`/`<textarea>`/`<listing>`,
+ * a fragment parse drops doctype/html/head/body, and quoting, case and line endings are normalized),
+ * and sealed Html must not change with the serializer.
+ *
+ * `rewrite` gets each attribute's (entity-decoded) value and returns its new value, or undefined to
+ * leave it. A rewritten attribute is written as `name="value"`.
+ */
+function rewriteHtmlAttributes(html, rewrite) {
+    const fragment = parseFragment(html, { sourceCodeLocationInfo: true });
+    const edits = [];
+    const walk = (node) => {
+        if (node.nodeName === '#text' || node.nodeName === '#comment')
+            return;
+        const el = node;
+        if (el.attrs?.length) {
+            for (const attr of el.attrs) {
+                if (attr.prefix)
+                    continue;
+                const next = rewrite(el, attr.name, attr.value);
+                const location = el.sourceCodeLocation?.attrs?.[attr.name];
+                if (next === undefined || !location)
+                    continue;
+                edits.push({
+                    start: location.startOffset,
+                    end: location.endOffset,
+                    text: `${attr.name}="${escapeAttributeValue(next)}"`,
+                });
+            }
+        }
+        const parent = el;
+        if (parent.childNodes) {
+            for (const c of parent.childNodes)
+                walk(c);
+        }
+    };
+    for (const c of fragment.childNodes)
+        walk(c);
+    let out = html;
+    for (const edit of edits.sort((a, b) => b.start - a.start)) {
+        out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
+    }
+    return out;
+}
+/**
+ * Replace `data:image/...` `<img src>` values with Arweave URLs (keyed by data URI). Only those
+ * `src` attributes change; the rest of the Html is kept byte for byte.
+ */
+function replaceDataUrisInParsedHtml(html, replacements) {
+    if (replacements.size === 0)
+        return html;
+    return rewriteHtmlAttributes(html, (el, attrName, value) => {
+        if (el.tagName !== 'img' || attrName !== 'src')
+            return undefined;
+        return replacements.get(value.trim());
+    });
+}
+/**
+ * `seed:property/<propertyName>` in Html stands for the Arweave URL of the same item's
+ * `<propertyName>` storage property (Image, File or Json). Publish uploads that property first,
+ * then rewrites the placeholder to its gateway URL before the Html is uploaded, so Html can show a
+ * file published alongside it without embedding it (e.g. `<img class="u-featured"
+ * src="seed:property/featureImage">`).
+ */
+const SEED_PROPERTY_REF_PREFIX = 'seed:property/';
+const SEED_PROPERTY_REF = /^seed:property\/([A-Za-z_$][A-Za-z0-9_$]*)$/;
+/** Attributes whose whole (trimmed) value may be a `seed:property/` placeholder. */
+const SEED_PROPERTY_REF_ATTRIBUTES = new Set(['src', 'href', 'poster']);
+const seedPropertyRefName = (attrName, value) => SEED_PROPERTY_REF_ATTRIBUTES.has(attrName) ? SEED_PROPERTY_REF.exec(value.trim())?.[1] : undefined;
+/** A `seed:property/` placeholder that names no usable property, or whose upload is unknown. */
+class HtmlSeedPropertyRefError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'HtmlSeedPropertyRefError';
+    }
+}
+/** Property names referenced by `seed:property/<name>` placeholders in `html`, each once. */
+function findSeedPropertyRefsInHtml(html) {
+    if (!html.includes(SEED_PROPERTY_REF_PREFIX))
+        return [];
+    const names = new Set();
+    rewriteHtmlAttributes(html, (_el, attrName, value) => {
+        const name = seedPropertyRefName(attrName, value);
+        if (name)
+            names.add(name);
+        return undefined;
+    });
+    return [...names];
+}
+/** Replace `seed:property/<name>` placeholders with `urlByPropertyName.get(name)`; other bytes are kept. */
+function replaceSeedPropertyRefsInHtml(html, urlByPropertyName) {
+    if (urlByPropertyName.size === 0)
+        return html;
+    return rewriteHtmlAttributes(html, (_el, attrName, value) => {
+        const name = seedPropertyRefName(attrName, value);
+        return name ? urlByPropertyName.get(name) : undefined;
+    });
+}
+const SEED_PROPERTY_REF_DATA_TYPES = [
+    ModelPropertyDataTypes.Image,
+    ModelPropertyDataTypes.File,
+    ModelPropertyDataTypes.Json,
+];
+/**
+ * The storage property of `node` a `seed:property/<name>` placeholder names, and the seed it holds.
+ * Html properties are refused: an Html seed may itself be deferred to after the rewrite.
+ */
+function resolveSeedPropertyRefTarget(node, propertyName) {
+    const property = node.properties.find((p) => p.key === propertyName);
+    if (!property) {
+        throw new HtmlSeedPropertyRefError(`Html references ${SEED_PROPERTY_REF_PREFIX}${propertyName}, but ${node.modelName} has no property ${propertyName}`);
+    }
+    const def = property.definition;
+    const dataType = normalizeDataType(def.dataType);
+    const storageType = dataType === ModelPropertyDataTypes.Relation ? normalizeDataType(def.refValueType) : dataType;
+    if (!SEED_PROPERTY_REF_DATA_TYPES.includes(storageType)) {
+        throw new HtmlSeedPropertyRefError(`Html references ${SEED_PROPERTY_REF_PREFIX}${propertyName}, but ${propertyName} is ${def.dataType}; ` +
+            `only Image, File and Json properties can be referenced`);
+    }
+    const ids = resolveSeedIdsFromRefString(normalizeRelationPropertyValue(property.row?.propertyValue) ?? '');
+    if (!ids.seedLocalId && !ids.seedUid) {
+        throw new HtmlSeedPropertyRefError(`Html references ${SEED_PROPERTY_REF_PREFIX}${propertyName}, but ${propertyName} has no value`);
+    }
+    return ids;
+}
+const ARWEAVE_TX_ID$1 = /^[a-z0-9_-]{43}$/i;
+/**
+ * The Arweave tx of the storage seed a placeholder names: uploaded in this publish's phase 1, or,
+ * when not uploaded now, the transaction it was published with (its storageTransactionId row).
+ */
+async function resolveSeedPropertyRefTxId(node, propertyName, txBySeedLocalId) {
+    const target = resolveSeedPropertyRefTarget(node, propertyName);
+    const uploaded = target.seedLocalId ? txBySeedLocalId.get(target.seedLocalId) : undefined;
+    if (uploaded)
+        return uploaded;
+    const recorded = await storageSeedTransactionId(target);
+    if (recorded && ARWEAVE_TX_ID$1.test(recorded))
+        return recorded;
+    throw new HtmlSeedPropertyRefError(`Html references ${SEED_PROPERTY_REF_PREFIX}${propertyName}, but ${propertyName} was not uploaded ` +
+        `in this publish and has no published transaction`);
+}
+/**
+ * Name of the file holding an embedded image's bytes in the images folder: `<imageSeedLocalId>.<ext>`,
+ * the extension following the image's MIME type (one of {@link ALLOWED_MIMES}).
+ */
+function embeddedImageFileName(imageSeedLocalId, mimeType) {
+    return `${imageSeedLocalId}.${getExtensionForMimeType(mimeType) ?? 'bin'}`;
+}
+/** Path of the file {@link createImageItemFromBytes} wrote for an Image seed, or undefined if there is none. */
+async function findEmbeddedImageFilePath(imageSeedLocalId) {
+    for (const mimeType of ALLOWED_MIMES) {
+        const filePath = BaseFileManager.getFilesPath('images', embeddedImageFileName(imageSeedLocalId, mimeType));
+        if (await BaseFileManager.pathExists(filePath))
+            return filePath;
+    }
+    return undefined;
+}
+/**
+ * Create an Image item for an embedded image and write its bytes to the images folder, where publish
+ * reads them for upload ({@link findEmbeddedImageFilePath}). Its storageTransactionId stays empty
+ * until the upload writes the transaction id, as for any other storage seed.
+ */
+async function createImageItemFromBytes(bytes, mimeType) {
+    const imageItem = await Item.create({
+        modelName: 'Image',
+        modelFileId: INTERNAL_STORAGE_MODEL_FILE_IDS.image,
+    });
+    await waitForEntityReady(imageItem, { timeout: 60000 });
+    const filePath = BaseFileManager.getFilesPath('images', embeddedImageFileName(imageItem.seedLocalId, mimeType));
+    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('images'));
+    const data = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+    try {
+        await BaseFileManager.saveFile(filePath, data);
+    }
+    catch {
+        const fs = await BaseFileManager.getFs();
+        fs.writeFileSync(filePath, bytes);
+    }
+    const { seedLocalId } = imageItem;
+    // Publish reads the image from its rows when it uploads and attests it
+    imageItem.unload();
+    return { seedLocalId };
+}
+/** The Html properties of a node with a stored Html seed and file name. */
+const htmlValuesOf = (node) => node.properties.flatMap((property) => {
+    if (normalizeDataType(property.definition.dataType) !== ModelPropertyDataTypes.Html)
+        return [];
+    const htmlSeedLocalId = property.row?.propertyValue?.trim();
+    const fileName = property.row?.refResolvedValue;
+    return htmlSeedLocalId && fileName ? [{ property, htmlSeedLocalId, filePath: `${BaseFileManager.getFilesPath('html')}/${fileName}` }] : [];
+});
+/**
+ * Scan Html storage properties, materialize embedded images as Image items, insert co-publish rows.
+ * Call before phase-1 Arweave tx build. Does not rewrite Html files yet.
+ */
+async function prepareHtmlEmbeddedImagesForPublish(item, publishPolicy) {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb) {
+        return { deferredHtmlSeedLocalIds: [] };
+    }
+    const deferred = new Set();
+    // The item's own Html, and the Html of the draft items published with it: each gets its embedded
+    // images materialized and co-published (rows keyed by the item owning the Html property).
+    const graph = await getPublishGraph(item);
+    for (const node of publishGraphItemNodes(graph)) {
+        await prepareHtmlEmbeddedImagesOfNode(appDb, node, publishPolicy, deferred);
+    }
+    return { deferredHtmlSeedLocalIds: [...deferred] };
+}
+/**
+ * An embedded image an earlier attempt materialized for this data URI that can be used again: its
+ * Image seed is still a local draft and its file is there.
+ */
+async function reusableImage(row) {
+    if (!row)
+        return undefined;
+    const seed = await findSeedRow({ localId: row.imageSeedLocalId });
+    if (!seed || isValidEasAttestationUid(seed.uid))
+        return undefined;
+    return (await findEmbeddedImageFilePath(row.imageSeedLocalId)) ? row.imageSeedLocalId : undefined;
+}
+async function prepareHtmlEmbeddedImagesOfNode(appDb, node, publishPolicy, deferred) {
+    // An earlier attempt's rows: their images are reused for the same Html and data URI
+    const earlier = node.embeddedImages;
+    const kept = [];
+    for (const { property, htmlSeedLocalId, filePath } of htmlValuesOf(node)) {
+        if (!(await BaseFileManager.pathExists(filePath)))
+            continue;
+        const html = await BaseFileManager.readFileAsString(filePath);
+        // seed:property/ placeholders are filled in after phase 1 whatever the data URI policy. A
+        // placeholder naming no usable property fails here, before anything is uploaded.
+        const refs = findSeedPropertyRefsInHtml(html);
+        for (const name of refs)
+            resolveSeedPropertyRefTarget(node, name);
+        if (refs.length > 0)
+            deferred.add(htmlSeedLocalId);
+        // The policy is the row's definition (a schema file's htmlEmbeddedDataUriPolicy or a code-defined one)
+        const policy = resolveEffectiveHtmlEmbeddedDataUriPolicy(property.definition, publishPolicy);
+        if (policy !== 'materialize')
+            continue;
+        const extracted = await extractDataUriImagesFromHtml(html);
+        if (extracted.length === 0)
+            continue;
+        deferred.add(htmlSeedLocalId);
+        for (const ent of extracted) {
+            const previous = earlier.find((r) => r.htmlSeedLocalId.trim() === htmlSeedLocalId && r.stableKey === ent.stableKey);
+            const reused = await reusableImage(previous);
+            if (reused) {
+                kept.push(previous);
+                continue;
+            }
+            const { seedLocalId: imageSeedLocalId } = await createImageItemFromBytes(ent.bytes, ent.mimeType);
+            if (previous)
+                await appDb.delete(htmlEmbeddedImageCoPublish).where(eq(htmlEmbeddedImageCoPublish.id, previous.id));
+            await appDb.insert(htmlEmbeddedImageCoPublish).values({
+                parentSeedLocalId: node.seedLocalId,
+                htmlSeedLocalId,
+                imageSeedLocalId,
+                stableKey: ent.stableKey,
+                createdAt: Date.now(),
+            }).onConflictDoNothing();
+        }
+    }
+    // Rows for Html or data URIs no longer there
+    for (const row of earlier) {
+        if (kept.includes(row))
+            continue;
+        await appDb.delete(htmlEmbeddedImageCoPublish).where(eq(htmlEmbeddedImageCoPublish.id, row.id));
+    }
+}
+/**
+ * After phase-1 uploads, rewrite Html files on disk: data URI → Arweave gateway URL, and
+ * `seed:property/<name>` → the gateway URL of that property's upload.
+ *
+ * `deferredHtmlSeedLocalIds` (from {@link prepareHtmlEmbeddedImagesForPublish}) limits the rewrite to
+ * the Html held back from phase 1; without it, every Html of the item and its co-published drafts is
+ * considered.
+ */
+async function rewriteHtmlEmbeddedImagesOnDisk(parentSeedLocalId, uploadedTransactions, deferredHtmlSeedLocalIds) {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb)
+        return;
+    const txBySeedLocalId = new Map();
+    for (const u of uploadedTransactions) {
+        if (u.seedLocalId && u.txId) {
+            txBySeedLocalId.set(u.seedLocalId.trim(), u.txId.trim());
+        }
+    }
+    const deferred = deferredHtmlSeedLocalIds
+        ? new Set(deferredHtmlSeedLocalIds.map((id) => id.trim()))
+        : undefined;
+    // The parent's Html and that of the draft items published with it (see prepareHtmlEmbeddedImagesForPublish).
+    const graph = await getPublishGraph({ seedLocalId: parentSeedLocalId });
+    for (const node of publishGraphItemNodes(graph)) {
+        await rewriteHtmlEmbeddedImagesOfNode(node, txBySeedLocalId, deferred);
+    }
+}
+async function rewriteHtmlEmbeddedImagesOfNode(node, txBySeedLocalId, deferred) {
+    for (const { htmlSeedLocalId, filePath } of htmlValuesOf(node)) {
+        if (deferred && !deferred.has(htmlSeedLocalId))
+            continue;
+        if (!(await BaseFileManager.pathExists(filePath)))
+            continue;
+        const html = await BaseFileManager.readFileAsString(filePath);
+        const replacements = new Map();
+        const entries = await extractDataUriImagesFromHtml(html);
+        for (const r of node.embeddedImages) {
+            if (r.htmlSeedLocalId.trim() !== htmlSeedLocalId)
+                continue;
+            const txId = txBySeedLocalId.get(r.imageSeedLocalId.trim());
+            const dataUri = entries.find((e) => e.stableKey === r.stableKey)?.dataUri;
+            if (txId && dataUri)
+                replacements.set(dataUri, getPublicArweaveRawUrl(txId));
+        }
+        const urlByPropertyName = new Map();
+        for (const name of findSeedPropertyRefsInHtml(html)) {
+            const txId = await resolveSeedPropertyRefTxId(node, name, txBySeedLocalId);
+            urlByPropertyName.set(name, getPublicArweaveRawUrl(txId));
+        }
+        const newHtml = replaceSeedPropertyRefsInHtml(replaceDataUrisInParsedHtml(html, replacements), urlByPropertyName);
+        if (newHtml === html)
+            continue;
+        try {
+            await BaseFileManager.saveFile(filePath, newHtml);
+        }
+        catch {
+            const fs = await BaseFileManager.getFs();
+            fs.writeFileSync(filePath, newHtml);
+        }
+    }
+}
+/**
+ * Remove co-publish rows after a successful publish for this parent seed.
+ */
+async function clearHtmlEmbeddedImageCoPublishRows(parentSeedLocalId) {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb || !parentSeedLocalId)
+        return;
+    await appDb
+        .delete(htmlEmbeddedImageCoPublish)
+        .where(eq(htmlEmbeddedImageCoPublish.parentSeedLocalId, parentSeedLocalId.trim()));
+}
+
+/**
+ * `Promise.all(items.map(fn))` with at most `limit` calls in flight. Results keep the input order.
+ * Rejects with the first error (by time); after that no new calls start, though calls already in
+ * flight run to completion.
+ */
+async function mapWithConcurrency(items, limit, fn) {
+    const results = new Array(items.length);
+    const workerCount = Math.max(1, Math.min(Math.floor(limit) || 1, items.length));
+    let next = 0;
+    let failed = false;
+    const worker = async () => {
+        while (!failed && next < items.length) {
+            const index = next++;
+            try {
+                results[index] = await fn(items[index], index);
+            }
+            catch (error) {
+                failed = true;
+                throw error;
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: workerCount }, worker));
+    return results;
+}
+
+/**
+ * Composite uploads: several ItemStorage files of one item in a single Arweave transaction.
+ *
+ * Producer: `getPublishUploads.ts` (`processUploadPropertyData`), for an item with a
+ * `storageTransactionId` property and ItemStorage properties (e.g. a Post's `html` and `json`).
+ * Consumer: the download worker (`browser/workers/filesDownload.ts`), which keeps its own copy of
+ * {@link decodeCompositeUpload} because it runs from a string; a test keeps the two in step.
+ *
+ * Format (unchanged for text children, so composites already on Arweave still read):
+ *
+ *   ===FILE_SEPARATOR===<name>===FILE_SEPARATOR===<utf-8 text>   (repeated per child)
+ *
+ * A child that is not valid UTF-8 text (or whose text contains the separator) is written as
+ * base64 under the name `<name>;base64`. Composites written before this suffix existed converted
+ * every child to text, which corrupted binary children; those bytes cannot be recovered.
+ */
+const COMPOSITE_SEPARATOR = '===FILE_SEPARATOR===';
+const COMPOSITE_BASE64_SUFFIX = ';base64';
+const bytesToBase64 = (bytes) => {
+    let binary = '';
+    const chunk = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunk) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+    }
+    return btoa(binary);
+};
+/** The child's text when it can travel as text: valid UTF-8, no NUL bytes, no separator. */
+const childAsText = (bytes) => {
+    if (bytes.includes(0))
+        return undefined;
+    let text;
+    try {
+        text = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    }
+    catch {
+        return undefined;
+    }
+    return text.includes(COMPOSITE_SEPARATOR) ? undefined : text;
+};
+const encodeCompositeUpload = (children) => {
+    let composite = '';
+    for (const { name, bytes } of children) {
+        const text = childAsText(bytes);
+        composite +=
+            text !== undefined
+                ? `${COMPOSITE_SEPARATOR}${name}${COMPOSITE_SEPARATOR}${text}`
+                : `${COMPOSITE_SEPARATOR}${name}${COMPOSITE_BASE64_SUFFIX}${COMPOSITE_SEPARATOR}${bytesToBase64(bytes)}`;
+    }
+    return new TextEncoder().encode(composite);
+};
+new TextEncoder().encode(COMPOSITE_SEPARATOR);
+
+const logger = debug('seedSdk:item:getPublishUploads');
+/** L1 transactions {@link getPublishUploads} creates at once (each asks the gateway for price and anchor). */
+const CREATE_TRANSACTION_CONCURRENCY = 4;
+const toUint8Array = async (data) => {
+    if (typeof Blob !== 'undefined' && data instanceof Blob) {
+        return new Uint8Array(await data.arrayBuffer());
+    }
+    return new Uint8Array(data);
+};
+/** A local file's bytes plus its MIME type: the Blob's own type, else the name's extension, else a sniff of the bytes. */
+const readUploadFile = async (filePath, fileName = filePath) => {
+    const data = await BaseFileManager.readFileAsBuffer(filePath);
+    const bytes = await toUint8Array(data);
+    const sourceType = typeof Blob !== 'undefined' && data instanceof Blob ? data.type : undefined;
+    return { bytes, contentType: resolveUploadMimeType({ sourceType, fileName, bytes }) };
+};
+/**
+ * The one place an upload's bytes become a {@link PublishUploadData}: everything after this
+ * (Content-SHA-256, tags, the L1 transaction or the bundler DataItem, signing) works from what it
+ * returns. A future private-publish option that encrypts content belongs here, before the hash and
+ * tags are computed, so both publish paths pick it up.
+ */
+const buildPublishUploadData = (data, contentType, target, options) => {
+    const contentHash = getContentSha256(data);
+    return {
+        data,
+        contentHash,
+        contentType,
+        tags: buildArweaveContentTags(contentHash, contentType, options?.arweaveUploadTags),
+        ...target,
+    };
+};
+const isUsablePath = (filePath) => !!filePath && !filePath.endsWith('undefined') && !filePath.endsWith('null');
+/**
+ * Local file of one ItemStorage property of a node. Tries, in order: its current row's
+ * refResolvedValue + localStorageDir, then (for a local draft, or no row) the name saveItemStorage
+ * gives a new file (`<seedUid or seedLocalId><extension>` in the model's storage directory). A
+ * published or derived row is never swapped for a local file of another name: that file would be
+ * older content.
+ *
+ * `missingLocalEdit` lists the paths tried when nothing exists although the row is a saved local
+ * edit (no attestation uid, not derived from one, refResolvedValue set by saveItemStorage): that
+ * edit's file should be there. A published or derived row without a file (e.g. content not
+ * downloaded, or a property the composite never had) is skipped.
+ */
+const resolveItemStorageChildFile = async (node, property) => {
+    const tried = [];
+    const tryPath = async (filePath) => {
+        if (!isUsablePath(filePath) || tried.includes(filePath))
+            return undefined;
+        tried.push(filePath);
+        return (await BaseFileManager.pathExists(filePath)) ? filePath : undefined;
+    };
+    const { row, definition } = property;
+    const dir = getItemStorageSubdir(definition.localStorageDir || row?.localStorageDir);
+    if (row?.refResolvedValue) {
+        const fromRow = await tryPath(BaseFileManager.getFilesPath(dir, row.refResolvedValue));
+        if (fromRow)
+            return { filePath: fromRow };
+    }
+    const isLocalDraft = !!row && !row.uid && row.derivedFromUid == null;
+    const seedIds = !row || isLocalDraft ? [row?.seedUid, node.seedUid, row?.seedLocalId, node.seedLocalId] : [];
+    for (const seedId of seedIds) {
+        if (!seedId)
+            continue;
+        const derived = await tryPath(BaseFileManager.getFilesPath(dir, getItemStorageLocalFileName(seedId, definition.filenameSuffix)));
+        if (derived)
+            return { filePath: derived };
+    }
+    // saveItemStorage sets refResolvedValue on the draft row once the file is written. A draft row
+    // without one is the empty row createNewItem makes for every model property: nothing to upload.
+    return isLocalDraft && !!row?.refResolvedValue ? { missingLocalEdit: tried } : {};
+};
+const slotOf = (node) => node.properties.find((p) => p.kind === 'storageTransaction');
+/** Where an upload attesting through `node`'s storageTransactionId is recorded. */
+const slotTarget = (node) => {
+    const slot = slotOf(node);
+    return {
+        seedLocalId: node.seedLocalId,
+        itemPropertyName: slot?.key ?? 'storageTransactionId',
+        itemPropertyLocalId: slot?.row?.localId ?? '',
+        versionLocalId: slot?.row?.versionLocalId ?? node.version.localId ?? '',
+    };
+};
+/** A node's own files: the ItemStorage properties beside its storageTransactionId, as one composite. */
+async function compositeSource(node) {
+    if (!slotOf(node))
+        return undefined;
+    const children = [];
+    const missingLocalEdits = [];
+    for (const property of node.properties) {
+        if (property.kind !== 'itemStorage')
+            continue;
+        const { filePath, missingLocalEdit } = await resolveItemStorageChildFile(node, property);
+        if (filePath)
+            children.push({ name: property.key, filePath });
+        else if (missingLocalEdit)
+            missingLocalEdits.push({ name: property.key, tried: missingLocalEdit });
+    }
+    if (children.length === 0 && missingLocalEdits.length === 0)
+        return undefined;
+    return { ...slotTarget(node), children, ...(missingLocalEdits.length ? { missingLocalEdits } : {}) };
+}
+/** The file of a storage seed this publish attests, named by the referring property's row. */
+async function storageSeedSource(owner, property) {
+    const target = property.refs[0]?.node;
+    const refResolvedValue = property.row?.refResolvedValue;
+    if (!target || !refResolvedValue)
+        return undefined;
+    const filePath = storageUploadPath({
+        dataType: property.definition.refValueType ?? property.definition.dataType,
+        refResolvedValue,
+        localStorageDir: property.row?.localStorageDir,
+    });
+    if (!(await BaseFileManager.pathExists(filePath)))
+        return undefined;
+    return {
+        seedLocalId: target.seedLocalId,
+        itemPropertyName: property.key,
+        itemPropertyLocalId: property.row?.localId ?? '',
+        versionLocalId: property.row?.versionLocalId ?? owner.version.localId ?? '',
+        filePath,
+    };
+}
+const isHtmlStorageProperty = (property) => isDataType(property.definition.refValueType ?? property.definition.dataType, ModelPropertyDataTypes.Html);
+/**
+ * Every upload a publish makes, in graph order (the root's first), one per attesting seed. The
+ * options select the phases of a publish with Html-embedded images: phase 1 defers the listed Html
+ * storage seeds, phase 2 uploads only those.
+ */
+async function getPublishUploadSources(graph, options) {
+    const onlyHtml = options?.onlyHtmlStorageSeedLocalIds?.length ? new Set(options.onlyHtmlStorageSeedLocalIds) : undefined;
+    const deferHtml = new Set(options?.deferHtmlStorageSeedLocalIds ?? []);
+    const sources = [];
+    const add = (source) => {
+        if (source && !sources.some((s) => s.seedLocalId === source.seedLocalId))
+            sources.push(source);
+    };
+    for (const node of [graph.root, ...graph.nodes.filter((n) => n !== graph.root)]) {
+        if (!onlyHtml)
+            add(await compositeSource(node));
+        if (node.kind !== 'root' && node.kind !== 'draft')
+            continue;
+        for (const property of node.properties) {
+            if (property.kind !== 'storageSeed' || property.deferred)
+                continue;
+            const seedLocalId = property.refs[0]?.node?.seedLocalId;
+            if (!seedLocalId)
+                continue;
+            if (isHtmlStorageProperty(property) ? deferHtml.has(seedLocalId) || (onlyHtml && !onlyHtml.has(seedLocalId)) : onlyHtml)
+                continue;
+            add(await storageSeedSource(node, property));
+        }
+        if (onlyHtml)
+            continue;
+        for (const row of node.embeddedImages) {
+            const image = graph.nodes.find((n) => n.seedLocalId === row.imageSeedLocalId && n.kind === 'embeddedImage');
+            const filePath = image ? await findEmbeddedImageFilePath(image.seedLocalId) : undefined;
+            if (image && filePath)
+                add({ ...slotTarget(image), filePath });
+        }
+    }
+    return sources;
+}
+/** The bytes of one source; a missing local ItemStorage edit fails the publish. */
+async function readSource(source, options) {
+    const { filePath, children, missingLocalEdits, ...target } = source;
+    const missing = missingLocalEdits?.[0];
+    if (missing) {
+        // Uploading without it would publish a composite that silently lacks this edit.
+        throw new Error(`Cannot publish ${source.seedLocalId}: the local file for ${missing.name} ` +
+            `was not found (looked in ${missing.tried.join(', ')})`);
+    }
+    if (children) {
+        // Composite of the node's ItemStorage files; see helpers/compositeUpload.ts for the format.
+        // Children are read as bytes: a binary child is base64-framed instead of decoded as text.
+        const parts = [];
+        for (const child of children)
+            parts.push({ name: child.name, bytes: (await readUploadFile(child.filePath)).bytes });
+        return buildPublishUploadData(encodeCompositeUpload(parts), 'application/octet-stream', target, options);
+    }
+    const { bytes, contentType } = await readUploadFile(filePath);
+    return buildPublishUploadData(bytes, contentType, target, options);
+}
+/** Fails like a publish would when an item's relation names a seed that isn't there. */
+function assertRefsResolve(graph) {
+    for (const broken of graph.brokenRefs) {
+        if (broken.list)
+            continue;
+        throw new Error(broken.reason === 'invalid'
+            ? `Invalid relation value for ${broken.propertyKey}: expected local seed id or 0x uid`
+            : `No relatedItem found for ${broken.propertyKey}`);
+    }
+}
+/**
+ * True if publish would include at least one Arweave upload (local file / storage seed present,
+ * or a saved local edit whose file is missing, which the upload then reports). Reads rows and
+ * file metadata only, for routing (e.g. skip the Arweave steps).
+ */
+async function itemHasPublishUploadCandidates(item) {
+    const graph = await getPublishGraph(item);
+    assertRefsResolve(graph);
+    return (await getPublishUploadSources(graph)).length > 0;
+}
+/**
+ * Upload data for a publish of `item`: its own, and that of every seed the publish attests with it
+ * (see publishGraph.ts). Raw bytes plus Content-SHA-256 / Content-Type / configured tags; no
+ * Arweave transaction is created, so this does not touch the network. The bundler path in
+ * `@seedprotocol/publish` signs these as DataItems; {@link getPublishUploads} turns them into L1
+ * transactions.
+ */
+const getPublishUploadData = async (item, options) => {
+    const graph = await getPublishGraph(item);
+    assertRefsResolve(graph);
+    const sources = await getPublishUploadSources(graph, options);
+    logger('%d uploads for %s', sources.length, item.seedLocalId);
+    const uploads = [];
+    for (const source of sources)
+        uploads.push(await readSource(source, options));
+    return uploads;
+};
+/**
+ * Arweave L1 transactions for a publish of `item`: {@link getPublishUploadData}, each made into an
+ * unsigned transaction carrying the same tags.
+ */
+const getPublishUploads = async (item, options) => {
+    const uploadData = await getPublishUploadData(item, options);
+    // Each createTransaction fetches the price / anchor from the gateway: run a few at once.
+    return mapWithConcurrency(uploadData, CREATE_TRANSACTION_CONCURRENCY, async (upload) => ({
+        itemPropertyName: upload.itemPropertyName,
+        itemPropertyLocalId: upload.itemPropertyLocalId,
+        seedLocalId: upload.seedLocalId,
+        versionLocalId: upload.versionLocalId,
+        transactionToSign: await BaseArweaveClient.createTransaction(upload.data, {
+            tags: upload.tags.length ? upload.tags : undefined,
+        }),
+    }));
+};
+
+var getPublishUploads$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    CREATE_TRANSACTION_CONCURRENCY: CREATE_TRANSACTION_CONCURRENCY,
+    getPublishUploadData: getPublishUploadData,
+    getPublishUploadSources: getPublishUploadSources,
+    getPublishUploads: getPublishUploads,
+    itemHasPublishUploadCandidates: itemHasPublishUploadCandidates,
+    resolveItemStorageChildFile: resolveItemStorageChildFile
+});
+
+/** The item can't be exported as it is. `code` says why. */
+class ArchiveExportError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.name = 'ArchiveExportError';
+        this.code = code;
+    }
+}
+const ARWEAVE_TX_ID = /^[a-z0-9_-]{43}$/i;
+const SOFTWARE_AGENT = '@seedprotocol/sdk exportArchive (https://github.com/JournoLabs/seed-protocol-sdk)';
+const isoFromMs = (ms) => typeof ms === 'number' && Number.isFinite(ms) && ms > 0 ? new Date(ms).toISOString() : undefined;
+const toBytes = async (data) => typeof Blob !== 'undefined' && data instanceof Blob ? new Uint8Array(await data.arrayBuffer()) : new Uint8Array(data);
+const readBytes = async (filePath) => toBytes(await BaseFileManager.readFileAsBuffer(filePath));
+/** The Arweave transaction id a gateway URL serves (`https://<host>/<tx>` or `/raw/<tx>`), if it is one. */
+function arweaveTxIdOfUrl(url) {
+    try {
+        const parsed = new URL(url);
+        if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:')
+            return undefined;
+        const segments = parsed.pathname.split('/').filter(Boolean);
+        const last = segments[segments.length - 1];
+        const isTxPath = segments.length === 1 || (segments.length === 2 && segments[0] === 'raw');
+        return isTxPath && last && ARWEAVE_TX_ID.test(last) ? last : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const hasValue = (value) => value != null && value !== '';
+/** A saved local value that no attestation backs: the bag would mix it with the published record. */
+const isUnpublishedEdit = (property) => {
+    const row = property.row;
+    return !!row && !property.deferred && !row.uid && row.derivedFromUid == null && hasValue(row.propertyValue);
+};
+/**
+ * Builds the bag for `item`'s current published state:
+ *
+ * - `data/index.html` (or `data/<property>.html` when the model has several Html properties): the
+ *   Html with references to files in the bag rewritten to relative paths.
+ * - `data/source/<property>.html`: each Html exactly as published.
+ * - `data/assets/<sha256>.<ext>`: Images, Files and images the Html references.
+ * - `data/item.json`: every property's value, attestation uid and Arweave transaction.
+ * - `metadata/dc.xml` and `metadata/premis.xml`.
+ *
+ * Throws {@link ArchiveExportError} `not_published` for an item without a live published version,
+ * and `unpublished_changes` when a property holds a saved value that isn't published yet.
+ * A file that can't be read or downloaded is left out and reported in `omitted`, not thrown.
+ */
+async function exportArchive(item, options = {}) {
+    const fetch = options.fetch ?? true;
+    const now = options.baggingDate ?? new Date();
+    const graph = await getPublishGraph(item);
+    const root = graph.root;
+    const seedRow = await findSeedRow({ localId: root.seedLocalId });
+    const seedUid = root.seedUid;
+    const version = await getLatestPublishedVersionRow(root.seedLocalId);
+    if (!seedUid || !isValidEasAttestationUid(seedUid) || seedRow?.revokedAt || !version) {
+        throw new ArchiveExportError('not_published', `${root.modelName} ${root.seedLocalId} has no live published version`);
+    }
+    const unpublished = root.properties.filter(isUnpublishedEdit).map((p) => p.key);
+    if (unpublished.length > 0) {
+        throw new ArchiveExportError('unpublished_changes', `${root.modelName} ${root.seedLocalId} has unpublished changes to ${unpublished.join(', ')}; publish them first`);
+    }
+    const chainId = getEasReadChainId();
+    const chain = getEasChainDeployment(chainId);
+    const explorerUrl = (uid) => (chain ? getEasAttestationExplorerUrl(chain, uid) : undefined);
+    const schemaName = item.getService?.().getSnapshot().context.schemaName;
+    const attester = seedRow?.publisher ?? undefined;
+    const omitted = [];
+    const payload = [];
+    const fileInfo = new Map();
+    const assetPathByTx = new Map();
+    const assetPathByProperty = new Map();
+    const htmlSources = [];
+    const properties = {};
+    const addAsset = (bytes, mimeType, arweaveTransactionId) => {
+        const ext = getExtensionForMimeType(mimeType);
+        const path = `assets/${digestHex('sha256', bytes)}${ext ? `.${ext}` : ''}`;
+        if (!payload.some((f) => f.path === path)) {
+            payload.push({ path, bytes });
+            fileInfo.set(path, { mimeType, arweaveTransactionId });
+        }
+        if (arweaveTransactionId)
+            assetPathByTx.set(arweaveTransactionId, path);
+        return path;
+    };
+    for (const property of root.properties) {
+        const { key, definition: def, kind, row } = property;
+        const dataType = normalizeDataType(def.dataType) ?? String(def.dataType);
+        const entry = {
+            dataType,
+            attestationUid: row?.uid ?? row?.derivedFromUid ?? undefined,
+            attestedAt: isoFromMs(row?.attestationCreatedAt),
+        };
+        properties[key] = entry;
+        if (kind === 'basic' || kind === 'storageTransaction') {
+            entry.value = row?.propertyValue ?? null;
+            continue;
+        }
+        if (kind === 'relation' || kind === 'list') {
+            entry.value = kind === 'list' ? property.refs.map((r) => r.ref) : (property.refs[0]?.ref ?? null);
+            continue;
+        }
+        if (kind === 'itemStorage') {
+            const { filePath } = await resolveItemStorageChildFile(root, property);
+            if (!filePath) {
+                if (row && hasValue(row.propertyValue))
+                    omitted.push({ property: key, reason: 'its file is not on this device' });
+                continue;
+            }
+            const bytes = await readBytes(filePath);
+            if (dataType === 'Html') {
+                htmlSources.push({ key, text: new TextDecoder().decode(bytes) });
+            }
+            else {
+                const mimeType = resolveUploadMimeType({ fileName: filePath, bytes }) ?? 'application/octet-stream';
+                entry.file = addAsset(bytes, mimeType);
+                assetPathByProperty.set(key, entry.file);
+            }
+            continue;
+        }
+        // storageSeed: the value is a storage seed whose own row records the Arweave transaction.
+        if (!row || !hasValue(row.propertyValue))
+            continue;
+        const storageKind = storedValueKind(def, row);
+        if (!storageKind || storageKind === 'itemStorage') {
+            omitted.push({ property: key, reason: `${dataType} storage seeds are not exported yet` });
+            continue;
+        }
+        const arweaveTransactionId = await storageSeedTransactionId(resolveSeedIdsFromRefString(normalizeRelationPropertyValue(row.propertyValue) ?? ''));
+        if (arweaveTransactionId)
+            entry.arweaveTransactionId = arweaveTransactionId;
+        const display = await resolveStorageDisplay(storageKind, row, { fetch });
+        if (storageKind === 'html') {
+            const text = display.filePath ? await BaseFileManager.readFileAsString(display.filePath) : display.renderValue;
+            if (text === undefined) {
+                omitted.push({ property: key, reason: 'its Html could not be read or downloaded' });
+                continue;
+            }
+            htmlSources.push({ key, text, arweaveTransactionId });
+            continue;
+        }
+        if (!display.filePath) {
+            omitted.push({ property: key, reason: 'its file could not be read or downloaded' });
+            continue;
+        }
+        const bytes = await readBytes(display.filePath);
+        const mimeType = resolveUploadMimeType({ fileName: display.filePath, bytes }) ?? 'application/octet-stream';
+        entry.file = addAsset(bytes, mimeType, arweaveTransactionId);
+        assetPathByProperty.set(key, entry.file);
+    }
+    /** The bag path for an image the Html names by transaction id but no property holds (an embedded image). */
+    const embeddedAssetPath = async (txId) => {
+        const known = assetPathByTx.get(txId);
+        if (known)
+            return known;
+        const imageRow = await getMetadata({ storageTransactionId: txId });
+        let filePath = imageRow?.seedLocalId ? await findEmbeddedImageFilePath(imageRow.seedLocalId) : undefined;
+        if (!filePath) {
+            const display = await resolveStorageDisplay('image', { refResolvedValue: txId, localStorageDir: '/images' }, { fetch });
+            filePath = display.filePath;
+        }
+        if (!filePath)
+            return undefined;
+        const bytes = await readBytes(filePath);
+        const mimeType = resolveUploadMimeType({ fileName: filePath, bytes }) ?? 'application/octet-stream';
+        return addAsset(bytes, mimeType, txId);
+    };
+    const encoder = new TextEncoder();
+    for (const html of htmlSources) {
+        const targets = new Map();
+        // Collect first: rewriteHtmlUrls takes a synchronous mapping.
+        rewriteHtmlUrls(html.text, (url) => {
+            targets.set(url, url);
+            return undefined;
+        });
+        for (const url of targets.keys()) {
+            if (url.startsWith(SEED_PROPERTY_REF_PREFIX)) {
+                const path = assetPathByProperty.get(url.slice(SEED_PROPERTY_REF_PREFIX.length));
+                if (path)
+                    targets.set(url, path);
+                else
+                    targets.delete(url);
+                continue;
+            }
+            const txId = arweaveTxIdOfUrl(url);
+            const path = txId ? await embeddedAssetPath(txId) : undefined;
+            if (path)
+                targets.set(url, path);
+            else {
+                targets.delete(url);
+                if (txId)
+                    omitted.push({ property: html.key, reason: `references ${url}, which is not in the bag` });
+            }
+        }
+        const rewritten = rewriteHtmlUrls(html.text, (url) => targets.get(url));
+        const viewPath = htmlSources.length === 1 ? 'index.html' : `${html.key}.html`;
+        payload.push({ path: viewPath, bytes: encoder.encode(rewritten) });
+        fileInfo.set(viewPath, { mimeType: 'text/html' });
+        const sourcePath = `source/${html.key}.html`;
+        payload.push({ path: sourcePath, bytes: encoder.encode(html.text) });
+        fileInfo.set(sourcePath, { mimeType: 'text/html', arweaveTransactionId: html.arweaveTransactionId });
+        properties[html.key].file = sourcePath;
+    }
+    const itemJson = {
+        seedUid,
+        versionUid: version.uid,
+        schemaName,
+        modelName: root.modelName,
+        chain: { id: chainId, name: chain?.name },
+        attester,
+        properties,
+        omitted,
+    };
+    payload.push({ path: 'item.json', bytes: encoder.encode(`${JSON.stringify(itemJson, null, 2)}\n`) });
+    fileInfo.set('item.json', { mimeType: 'application/json' });
+    // Descriptive metadata comes from the archive document, so nothing is guessed from property names.
+    const primary = htmlSources[0];
+    const doc = primary ? parseArchiveDocument(primary.text) : undefined;
+    const versionDate = isoFromMs(version.attestationCreatedAt);
+    const dc = dublinCoreXml({
+        title: doc?.name,
+        creator: doc?.authors,
+        description: doc?.summary,
+        date: doc?.published ?? versionDate?.slice(0, 10),
+        type: 'Text',
+        format: primary ? 'text/html' : undefined,
+        identifier: [seedUid, explorerUrl(seedUid)].filter((v) => !!v),
+        source: doc?.url,
+    });
+    const premis = premisXml({
+        objects: [
+            {
+                kind: 'intellectualEntity',
+                identifiers: [
+                    { type: 'Seed Protocol seed UID', value: seedUid },
+                    { type: 'Seed Protocol version UID', value: version.uid },
+                ],
+            },
+            ...payload.map((file) => {
+                const info = fileInfo.get(file.path);
+                return {
+                    kind: 'file',
+                    identifiers: [{ type: 'bag path', value: `data/${file.path}` }],
+                    fixity: { 'SHA-256': digestHex('sha256', file.bytes), 'SHA-512': digestHex('sha512', file.bytes) },
+                    size: file.bytes.byteLength,
+                    formatName: info?.mimeType ?? 'application/octet-stream',
+                    originalName: info?.arweaveTransactionId ? getPublicArweaveRawUrl(info.arweaveTransactionId) : undefined,
+                };
+            }),
+        ],
+        events: [...(await historyEvents(root.seedLocalId, seedUid, version, attester)), ...bagEvents(now, seedUid)],
+        agents: [
+            ...(attester
+                ? [{ identifiers: [{ type: 'EVM address', value: attester }], note: `EAS attester on chain ${chainId}` }]
+                : []),
+            { identifiers: [{ type: 'software', value: '@seedprotocol/sdk' }], name: '@seedprotocol/sdk', type: 'software' },
+        ],
+    });
+    const info = [];
+    if (options.sourceOrganization)
+        info.push(['Source-Organization', options.sourceOrganization]);
+    info.push(['External-Identifier', seedUid]);
+    if (doc?.name)
+        info.push(['External-Description', doc.name]);
+    info.push(['Seed-Uid', seedUid], ['Seed-Version-Uid', version.uid], ['Seed-Model', root.modelName]);
+    if (schemaName)
+        info.push(['Seed-Schema', schemaName]);
+    info.push(['EAS-Chain-Id', String(chainId)]);
+    if (chain?.name)
+        info.push(['EAS-Chain-Name', chain.name]);
+    if (attester)
+        info.push(['EAS-Attester', attester]);
+    const bag = createBag({
+        payload,
+        tagFiles: [
+            { path: 'metadata/dc.xml', bytes: encoder.encode(dc) },
+            { path: 'metadata/premis.xml', bytes: encoder.encode(premis) },
+        ],
+        info,
+        baggingDate: now,
+        softwareAgent: SOFTWARE_AGENT,
+    });
+    return { bag, omitted };
+}
+/**
+ * The seed's attested history: its first live Version as creation, later Versions and property
+ * attestations made after the current Version (patches) as modifications. Attestations without
+ * a recorded time are left out, since PREMIS events need one.
+ */
+async function historyEvents(seedLocalId, seedUid, current, attester) {
+    const db = BaseDb.getAppDb();
+    const agents = attester ? [{ type: 'EVM address', value: attester, role: 'attester' }] : [];
+    const objects = [{ type: 'Seed Protocol seed UID', value: seedUid }];
+    const versionRows = (await db
+        .select({ uid: versions.uid, attestationCreatedAt: versions.attestationCreatedAt, revokedAt: versions.revokedAt })
+        .from(versions)
+        .where(eq(versions.seedLocalId, seedLocalId)))
+        .filter((v) => isValidEasAttestationUid(v.uid) && v.attestationCreatedAt)
+        .sort((a, b) => a.attestationCreatedAt - b.attestationCreatedAt);
+    const events = versionRows.map((v, index) => ({
+        identifier: { type: 'EAS attestation UID', value: v.uid },
+        type: index === 0 ? 'creation' : 'modification',
+        dateTime: isoFromMs(v.attestationCreatedAt),
+        detail: index === 0 ? 'First Version attested' : 'New Version attested',
+        outcome: 'success',
+        outcomeNote: v.revokedAt ? `Version revoked at ${new Date(v.revokedAt * 1000).toISOString()}` : undefined,
+        agents,
+        objects,
+    }));
+    if (current.attestationCreatedAt) {
+        const patches = (await db
+            .select({ uid: metadata$1.uid, propertyName: metadata$1.propertyName, attestationCreatedAt: metadata$1.attestationCreatedAt })
+            .from(metadata$1)
+            .where(and(eq(metadata$1.seedLocalId, seedLocalId), eq(metadata$1.versionUid, current.uid))));
+        for (const row of patches) {
+            if (!isValidEasAttestationUid(row.uid) || !row.attestationCreatedAt)
+                continue;
+            if (row.attestationCreatedAt <= current.attestationCreatedAt)
+                continue;
+            events.push({
+                identifier: { type: 'EAS attestation UID', value: row.uid },
+                type: 'modification',
+                dateTime: isoFromMs(row.attestationCreatedAt),
+                detail: `Property ${row.propertyName} attested again on Version ${current.uid}`,
+                outcome: 'success',
+                agents,
+                objects,
+            });
+        }
+    }
+    return events.sort((a, b) => a.dateTime.localeCompare(b.dateTime));
+}
+/** The bag's own events: its checksums and the package itself. */
+const bagEvents = (now, seedUid) => {
+    const agents = [{ type: 'software', value: '@seedprotocol/sdk', role: 'executing program' }];
+    const objects = [{ type: 'Seed Protocol seed UID', value: seedUid }];
+    const dateTime = now.toISOString();
+    return [
+        {
+            identifier: { type: 'bag event', value: `message-digest-${dateTime}` },
+            type: 'message digest calculation',
+            dateTime,
+            detail: 'SHA-256 and SHA-512 of every payload and tag file',
+            outcome: 'success',
+            agents,
+            objects,
+        },
+        {
+            identifier: { type: 'bag event', value: `package-${dateTime}` },
+            type: 'information package creation',
+            dateTime,
+            detail: 'BagIt 1.0 bag written by exportArchive',
+            outcome: 'success',
+            agents,
+            objects,
+        },
+    ];
+};
+
 /**
  * Thrown by Item.create when values don't fit the model: unknown keys, wrong types, or values
  * that break the property's validation rules. Nothing is left written: most values are checked
@@ -6634,5 +8179,45 @@ var errors = /*#__PURE__*/Object.freeze({
     UnknownModelError: UnknownModelError
 });
 
-export { sendEasSyncClientRequest as $, waitForEasReadChain as A, assertLocalDbChain as B, ConflictError as C, writeModelUids as D, getContentHash as E, saveDefinition as F, EAS_CHAIN_ID_APP_STATE_KEY as G, INIT_CONFIG_CONFLICT_MESSAGE as H, ItemCreateValidationError as I, ItemCreateError as J, claimUnpublishedDrafts as K, createLocalQueryDataSource as L, Model as M, easSyncActor as N, getClient as O, getPublishedSeedRecord as P, getSchemaNameFromId as Q, RelationTargetError as R, SCHEMA_FILE_FORMAT as S, TModelSchema as T, UnknownModelError as U, isSeedQueryLocalSourceRegistered as V, listCompleteSchemaFiles as W, mergeEasSyncRequestIntents as X, registerSeedQueryLocalSource as Y, requestEasSyncFromAddressChange as Z, requestEasSyncFromModelsInit as _, applyCreateItem as a, setRetriesWhenOnlineEnabled as a0, startEasSyncActor as a1, unregisterSeedQueryLocalSource as a2, saveDefinition$1 as a3, Model$1 as a4, schema as a5, SEEDPROTOCOL_Seed_Protocol_v1 as a6, itemAppliers as a7, errors as a8, applyDelete as b, applyItemStorageValue as c, deleteFiles as d, applyStorageValue as e, TModelValues as f, ClientManager as g, syncSchemaFromSource as h, importJsonSchema as i, transformImportToSchemaFile as j, localModelSchemaLookups as k, loadSchemaFromFile as l, listLatestSchemaFiles as m, readSchemaFile as n, applySchemaFile as o, resolveSchemaRow as p, loadAllSchemasFromDb as q, readJsonImportFile as r, startItemOutbox as s, throwItemWriteError as t, getDraftSaveError as u, queueDraftSave as v, writeNextSchemaVersion as w, setupEntityLiveQuery as x, mergeSchemaFiles as y, trackDraftSave as z };
-//# sourceMappingURL=errors-CnT0fSMK.js.map
+/** Error thrown when publish validation fails. Includes all validation errors for user to fix. */
+class PublishValidationFailedError extends Error {
+    constructor(message, validationErrors) {
+        super(message);
+        this.validationErrors = validationErrors;
+        this.name = 'PublishValidationFailedError';
+    }
+}
+/** Validation error code for a relation, list member or image/file ref to an unpublished seed. */
+const RELATED_ITEM_UNPUBLISHED_CODE = 'related_item_unpublished';
+const describeUnpublishedRelatedItem = (r) => `${r.propertyName} -> ${r.modelName} ${r.seedLocalId} (seed ${r.seedUid})`;
+/**
+ * Thrown before anything is uploaded or attested when the item references items whose seed was
+ * unpublished: the parent would attest a revoked seed uid. Republish those items (which gives
+ * them a new seed uid) or remove the references, then publish again.
+ * See docs/ATTESTATION_REVOCATION.md ("Republishing").
+ *
+ * A PublishValidationFailedError, so validateItemForPublish and the publish package's checking
+ * step report it as validation errors (code `related_item_unpublished`, one per reference).
+ */
+class RelatedItemUnpublishedError extends PublishValidationFailedError {
+    constructor(unpublishedRelatedItems, otherValidationErrors = []) {
+        const lines = unpublishedRelatedItems.map(describeUnpublishedRelatedItem);
+        const message = `Cannot publish: it references ${lines.length} unpublished item${lines.length === 1 ? '' : 's'} ` +
+            `(their seed attestations were revoked). Republish them or remove the references, then publish again:\n` +
+            lines.join('\n');
+        super(message, [
+            ...unpublishedRelatedItems.map((r) => ({
+                field: r.propertyName,
+                message: `${r.propertyName} references unpublished ${r.modelName} ${r.seedLocalId} (seed ${r.seedUid}). ` +
+                    `Republish it or remove the reference.`,
+                code: RELATED_ITEM_UNPUBLISHED_CODE,
+            })),
+            ...otherValidationErrors,
+        ]);
+        this.name = 'RelatedItemUnpublishedError';
+        this.unpublishedRelatedItems = unpublishedRelatedItems;
+    }
+}
+
+export { extractDataUriImagesFromHtml as $, ArchiveExportError as A, waitForEasReadChain as B, ConflictError as C, assertLocalDbChain as D, writeModelUids as E, getPublishGraph as F, htmlPropertyForHtmlSeed as G, HtmlEmbeddedDataUriLimitError as H, ItemCreateError as I, saveDefinition as J, getPublishUploadSources as K, EAS_CHAIN_ID_APP_STATE_KEY as L, Model as M, HTML_EMBEDDED_MAX_IMAGES_PER_DOC as N, HTML_EMBEDDED_MAX_IMAGE_BYTES as O, PublishValidationFailedError as P, HTML_EMBEDDED_MAX_TOTAL_BYTES as Q, RELATED_ITEM_UNPUBLISHED_CODE as R, SCHEMA_FILE_FORMAT as S, TModelSchema as T, UnknownModelError as U, INIT_CONFIG_CONFLICT_MESSAGE as V, SEED_PROPERTY_REF_PREFIX as W, claimUnpublishedDrafts as X, clearHtmlEmbeddedImageCoPublishRows as Y, createLocalQueryDataSource as Z, easSyncActor as _, HtmlSeedPropertyRefError as a, findSeedPropertyRefsInHtml as a0, getClient as a1, getPublishUploadData as a2, getPublishedSeedRecord as a3, getSchemaNameFromId as a4, isSeedQueryLocalSourceRegistered as a5, itemHasPublishUploadCandidates as a6, listCompleteSchemaFiles as a7, mergeEasSyncRequestIntents as a8, prepareHtmlEmbeddedImagesForPublish as a9, registerSeedQueryLocalSource as aa, replaceDataUrisInParsedHtml as ab, replaceSeedPropertyRefsInHtml as ac, requestEasSyncFromAddressChange as ad, requestEasSyncFromModelsInit as ae, resolveEffectiveHtmlEmbeddedDataUriPolicy as af, rewriteHtmlEmbeddedImagesOnDisk as ag, sendEasSyncClientRequest as ah, setRetriesWhenOnlineEnabled as ai, startEasSyncActor as aj, unregisterSeedQueryLocalSource as ak, saveDefinition$1 as al, Model$1 as am, schema as an, SEEDPROTOCOL_Seed_Protocol_v1 as ao, itemAppliers as ap, getPublishUploads$1 as aq, errors as ar, ItemCreateValidationError as b, RelatedItemUnpublishedError as c, deleteFiles as d, RelationTargetError as e, ClientManager as f, exportArchive as g, syncSchemaFromSource as h, importJsonSchema as i, transformImportToSchemaFile as j, localModelSchemaLookups as k, loadSchemaFromFile as l, listLatestSchemaFiles as m, readSchemaFile as n, applySchemaFile as o, resolveSchemaRow as p, loadAllSchemasFromDb as q, readJsonImportFile as r, startItemOutbox as s, throwItemWriteError as t, getDraftSaveError as u, queueDraftSave as v, writeNextSchemaVersion as w, setupEntityLiveQuery as x, mergeSchemaFiles as y, trackDraftSave as z };
+//# sourceMappingURL=publishErrors-DZXDX3B6.js.map