@seedprotocol/sdk 0.7.3 → 0.7.4-next.784.g879c6a3

package/dist/{Item-DBFchXpC.js → Item-cq9VcsAY.js}

@@ -1,5 +1,5 @@
 import { waitFor, fromCallback, setup, assign, stateIn, createActor, isMachineSnapshot } from 'xstate';
-import { n as normalizeDataType, E as BaseDb, C as versions, m as metadata, A as seeds, z as schemas, s as models, q as modelSchemas, aQ as getOwnedAddressesFromDb, a9 as ZERO_BYTES32, aB as normalizeAddressList, a0 as normalizeHexAddress, ay as getAddressesForItemsFilter, H as toSnakeCase$1, ad as INTERNAL_PROPERTY_NAMES, J as BaseFileManager, aS as getStorageTransactionIdForSeedUid, aT as convertTxIdToImage, i as isDataType, X as normalizePublisher, ax as ensureImageLocal, ap as ImageSize, aU as downloadTransactionIdWithDedupe, u as properties, M as ModelPropertyDataTypes, $ as generateId, ag as INTERNAL_DATA_TYPES, r as modelUids, L as resolveItemModelFileId, aV as getPropertyIdForSchemaFileId, K as getPropertyIdForModelAndName, aW as getDataTypeFromString, aX as getMimeType, am as INTERNAL_STORAGE_MODEL_FILE_IDS, V as getItemStorageSubdir, W as getItemStorageLocalFileName, g as normalizePropertyRecordSchema, aY as PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, a5 as getCorrectId, G as eventEmitter, ae as isStorageSeedRef } from './BasePathResolver-Cm4apKRb.js';
+import { n as normalizeDataType, E as BaseDb, C as versions, m as metadata, A as seeds, z as schemas, s as models, q as modelSchemas, aQ as getOwnedAddressesFromDb, a9 as ZERO_BYTES32, aB as normalizeAddressList, a0 as normalizeHexAddress, ay as getAddressesForItemsFilter, H as toSnakeCase$1, ad as INTERNAL_PROPERTY_NAMES, J as BaseFileManager, aS as getStorageTransactionIdForSeedUid, aT as convertTxIdToImage, i as isDataType, X as normalizePublisher, ax as ensureImageLocal, ap as ImageSize, aU as downloadTransactionIdWithDedupe, u as properties, M as ModelPropertyDataTypes, $ as generateId, ag as INTERNAL_DATA_TYPES, r as modelUids, L as resolveItemModelFileId, aV as getPropertyIdForSchemaFileId, K as getPropertyIdForModelAndName, aW as getDataTypeFromString, aX as getMimeType, am as INTERNAL_STORAGE_MODEL_FILE_IDS, V as getItemStorageSubdir, W as getItemStorageLocalFileName, g as normalizePropertyRecordSchema, aY as PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, a5 as getCorrectId, G as eventEmitter, ae as isStorageSeedRef } from './BasePathResolver-DxdS0wJ0.js';
 import { or, isNull, eq, max, count, and, getTableColumns, sql, desc, inArray, isNotNull, gt } from 'drizzle-orm';
 import pluralize from 'pluralize';
 import debug from 'debug';
@@ -8,8 +8,8 @@ import { startCase, upperFirst, camelCase, orderBy } from 'lodash-es';
 import { toSnakeCase } from 'drizzle-orm/casing';
 import { isValidEasAttestationUid, isPlaceholderUid, BaseQueryClient, BaseEasClient, GET_SCHEMAS, getEasSchemaUidForSchemaDefinition, getSchemaUidForModelFromCache, cachedSchemaLookup, setSchemaUidForModel, getEasSchemaUidForExactDefinition } from '@seedprotocol/eas';
 import { fetchArweaveRawTextAcrossGateways } from '@seedprotocol/arweave';
-import { d as notifyFileSaved, f as withTabLock } from './tabEvents-9s2WCYw-.js';
-import { modelPropertiesToObject } from './model-DGMe-TTm.js';
+import { d as notifyFileSaved, f as withTabLock } from './tabEvents-BTzckWrN.js';
+import { modelPropertiesToObject } from './model-oHA3YhOd.js';
 
 /**
  * Default readyTimeout for create/find/all with waitForReady. Loads that touch OPFS and the DB can take
@@ -724,9 +724,9 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
     try {
         const itemPropertyMod = await Promise.resolve().then(function () { return ItemProperty$1; });
         const { ItemProperty } = itemPropertyMod;
-        const { modelPropertiesToObject } = await import('./model-DGMe-TTm.js');
-        const _mod_0 = await import('./index-8O3Uow-Y.js');
-        const _ns_0 = _mod_0.f;
+        const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
+        const _mod_0 = await import('./errors-Cl8rbtKR.js');
+        const _ns_0 = _mod_0.h;
         const { Model } = _ns_0;
         // Resolve Model and build property schemas (use getByNameAsync for models not yet in cache)
         let propertySchemas = {};
@@ -743,7 +743,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             const schemaNameToTry = schemaName ?? model?.schemaName;
             if (schemaNameToTry) {
                 try {
-                    const _mod_1 = await import('./Schema-CpMNEnUO.js');
+                    const _mod_1 = await import('./Schema-Dc5EA8Yb.js');
                     const _ns_1 = _mod_1.b;
                     const { Schema } = _ns_1;
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false });
@@ -759,7 +759,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             }
             if (Object.keys(propertySchemas).length === 0) {
                 try {
-                    const _mod_2 = await import('./ClientManager-i3nJASkg.js');
+                    const _mod_2 = await import('./ClientManager-De-vKHGe.js');
                     const _ns_2 = _mod_2.K;
                     const { loadAllSchemasFromDb } = _ns_2;
                     const allSchemas = await loadAllSchemasFromDb();
@@ -780,11 +780,11 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             }
             if (Object.keys(propertySchemas).length === 0) {
                 try {
-                    const _mod_3 = await import('./ClientManager-i3nJASkg.js');
+                    const _mod_3 = await import('./ClientManager-De-vKHGe.js');
                     const _ns_3 = _mod_3.K;
                     const { listCompleteSchemaFiles } = _ns_3;
-                    const _mod_4 = await import('./BasePathResolver-Cm4apKRb.js');
-                    const _ns_4 = _mod_4.a_;
+                    const _mod_4 = await import('./BasePathResolver-DxdS0wJ0.js');
+                    const _ns_4 = _mod_4.a$;
                     const { BaseFileManager } = _ns_4;
                     const schemaFiles = await listCompleteSchemaFiles();
                     for (const { filePath } of schemaFiles) {
@@ -804,7 +804,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await import('./index-Cvt5UBz4.js');
+                const schemaMod = await import('./index-CqnU-5i0.js');
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
@@ -821,7 +821,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             }
         }
         // Fallbacks above may return schema-file shape ({ type, model, items }); normalize to dataType/ref/refValueType.
-        const { normalizePropertyRecordSchema } = await import('./property-DwPD283A.js');
+        const { normalizePropertyRecordSchema } = await import('./property-Brgr5RdT.js');
         propertySchemas = Object.fromEntries(Object.entries(propertySchemas).map(([name, def]) => [name, normalizePropertyRecordSchema(def)]));
         // Collapse rows that map to the same instance key (e.g. authorIdentityIds + authors -> authors).
         // ItemProperty.create cache does not sync propertyValue on hit; processing order would otherwise
@@ -854,7 +854,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 // Infer propertyRecordSchema from metadata when schema is missing (enables persistence)
                 let propSchema = propertySchemas[propertyName];
                 if (!propSchema && isRefTypeFromMeta) {
-                    const schemaMod = await import('./index-Cvt5UBz4.js');
+                    const schemaMod = await import('./index-CqnU-5i0.js');
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -1860,8 +1860,8 @@ const getItemsData = async ({ modelName, modelFileId, schemaName, deleted, inclu
         conditions.push(eq(seeds.type, toSnakeCase(modelName)));
     }
     if (!modelFileId && schemaName && modelName) {
-        const _mod_5 = await import('./BasePathResolver-Cm4apKRb.js');
-        const _ns_5 = _mod_5.b1;
+        const _mod_5 = await import('./BasePathResolver-DxdS0wJ0.js');
+        const _ns_5 = _mod_5.b2;
         const { resolveModelRecord } = _ns_5;
         modelFileId = (await resolveModelRecord(modelName, { schemaName }))?.schemaFileId ?? undefined;
         if (!modelFileId)
@@ -2143,7 +2143,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
     const { isRelation, propertyValue, propertyName, seedUid, propertyRecordSchema, populatedFromDb, schemaUid, } = context;
     const _resolveRelatedValue = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-Cvt5UBz4.js');
+        const schemaMod = await import('./index-CqnU-5i0.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -2578,8 +2578,8 @@ async function readHtmlBodyFromChildStorageArweave(seedLocalId) {
         /* offline / bad tx id */
     }
     try {
-        const _mod_6 = await import('./BasePathResolver-Cm4apKRb.js');
-        const _ns_6 = _mod_6.b3;
+        const _mod_6 = await import('./BasePathResolver-DxdS0wJ0.js');
+        const _ns_6 = _mod_6.b4;
         const { downloadTransactionIdWithDedupe } = _ns_6;
         await downloadTransactionIdWithDedupe(txId);
         const retryFp = BaseFileManager.getFilesPath('html', `${seedLocalId}.html`);
@@ -2639,7 +2639,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
     // to use dynamically imported ModelPropertyDataTypes
     const _hydrateFromDb = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-Cvt5UBz4.js');
+        const schemaMod = await import('./index-CqnU-5i0.js');
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -2772,7 +2772,9 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
                 }
                 if (filePath) {
                     localStorageDir = `/${dir}`;
-                    renderValue = await BaseFileManager.readFileAsString(filePath);
+                    // The same content URL saveFile sets, so the value reads the same before and after a reload.
+                    refResolvedDisplayValue = await BaseFileManager.getContentUrlFromPath(filePath);
+                    renderValue = refResolvedDisplayValue;
                 }
             }
             catch (e) {
@@ -2918,12 +2920,12 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
             const modelNameForNew = context.modelName;
             if (modelNameForNew) {
                 try {
-                    const _mod_7 = await import('./index-8O3Uow-Y.js');
-                    const _ns_7 = _mod_7.f;
+                    const _mod_7 = await import('./errors-Cl8rbtKR.js');
+                    const _ns_7 = _mod_7.h;
                     const { Model } = _ns_7;
-                    const { modelPropertiesToObject } = await import('./model-DGMe-TTm.js');
-                    const _mod_8 = await import('./BasePathResolver-Cm4apKRb.js');
-                    const _ns_8 = _mod_8.b1;
+                    const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
+                    const _mod_8 = await import('./BasePathResolver-DxdS0wJ0.js');
+                    const _ns_8 = _mod_8.b2;
                     const { resolveItemModelFileId } = _ns_8;
                     const normalizedModelName = upperFirst(camelCase(modelNameForNew));
                     const itemModelFileId = await resolveItemModelFileId({
@@ -2976,8 +2978,8 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
         // It ends up in the context below, and later lookups by name (Model.getByName) can't match it.
         const modelName = context.modelName || (metadataRecord.modelType ? upperFirst(camelCase(metadataRecord.modelType)) : undefined);
         // Model names are only unique per schema: pin lookups to the item's own model row.
-        const _mod_9 = await import('./BasePathResolver-Cm4apKRb.js');
-        const _ns_9 = _mod_9.b1;
+        const _mod_9 = await import('./BasePathResolver-DxdS0wJ0.js');
+        const _ns_9 = _mod_9.b2;
         const { resolveItemModelFileId, resolveModelRecord } = _ns_9;
         const modelFileId = await resolveItemModelFileId({
             modelFileId: context.modelFileId,
@@ -3020,47 +3022,13 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                             filenameSuffix: propRecord.filenameSuffix || undefined,
                             required: propRecord.required ?? undefined,
                         };
-                        // Merge with schema from file/DB to get validation rules (enum, pattern, etc.) - properties table doesn't store these
-                        try {
-                            const { getPropertySchema } = await import('./property-DwPD283A.js');
-                            let schemaFromFile = await getPropertySchema(normalizedModelName, propertyName, {
-                                modelFileId: modelRecord?.schemaFileId ?? modelFileId,
-                            });
-                            if (!schemaFromFile?.validation) {
-                                // Fallback: get validation from schemaData in database (Schema context may not be loaded yet)
-                                const _mod_10 = await import('./BasePathResolver-Cm4apKRb.js');
-                                const _ns_10 = _mod_10.a$;
-                                const { schemas: schemasTable } = _ns_10;
-                                const _mod_11 = await import('./BasePathResolver-Cm4apKRb.js');
-                                const _ns_11 = _mod_11.b0;
-                                const { modelSchemas } = _ns_11;
-                                const modelSchemaRows = await db
-                                    .select({ schemaId: modelSchemas.schemaId })
-                                    .from(modelSchemas)
-                                    .where(eq(modelSchemas.modelId, modelRecords[0].id))
-                                    .limit(1);
-                                if (modelSchemaRows.length > 0 && modelSchemaRows[0].schemaId) {
-                                    const schemaRows = await db
-                                        .select({ schemaData: schemasTable.schemaData })
-                                        .from(schemasTable)
-                                        .where(eq(schemasTable.id, modelSchemaRows[0].schemaId))
-                                        .limit(1);
-                                    if (schemaRows.length > 0 && schemaRows[0].schemaData) {
-                                        const parsed = JSON.parse(schemaRows[0].schemaData);
-                                        const modelDef = parsed?.models?.[normalizedModelName];
-                                        const propDef = modelDef?.properties?.[propertyName];
-                                        if (propDef?.validation) {
-                                            propertyRecordSchema = { ...propertyRecordSchema, validation: propDef.validation };
-                                        }
-                                    }
-                                }
-                            }
-                            else {
-                                propertyRecordSchema = { ...propertyRecordSchema, validation: schemaFromFile.validation };
-                            }
-                        }
-                        catch {
-                            // Schema not loaded or lookup failed - continue with DB schema only
+                        // Validation rules (enum, pattern, ...) aren't in the properties table
+                        const { resolvePropertyValidationRules } = await import('./propertyValidationRules-CDRitiiK.js');
+                        const validation = await resolvePropertyValidationRules(normalizedModelName, propertyName, {
+                            modelFileId: modelRecord?.schemaFileId ?? modelFileId,
+                        });
+                        if (validation) {
+                            propertyRecordSchema = { ...propertyRecordSchema, validation };
                         }
                     }
                 }
@@ -3072,10 +3040,10 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
         }
         if (!propertyRecordSchema && modelName) {
             try {
-                const _mod_12 = await import('./index-8O3Uow-Y.js');
-                const _ns_12 = _mod_12.f;
-                const { Model } = _ns_12;
-                const { modelPropertiesToObject } = await import('./model-DGMe-TTm.js');
+                const _mod_10 = await import('./errors-Cl8rbtKR.js');
+                const _ns_10 = _mod_10.h;
+                const { Model } = _ns_10;
+                const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
                 const normalizedModelName = upperFirst(camelCase(modelName));
                 // Try PascalCase first ("post" -> "Post"); then findByModelType for names with spaces ("new_model" -> "New model")
                 let model = Model.resolve(normalizedModelName, { modelFileId });
@@ -3226,7 +3194,8 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                     filePath = await resolveMatchingFilePath(dir, metadataRecord.refResolvedValue);
                 }
                 if (filePath) {
-                    renderValue = await BaseFileManager.readFileAsString(filePath);
+                    // The content URL saveFile and hydrateFromDb set, so the value reads the same everywhere.
+                    renderValue = await BaseFileManager.getContentUrlFromPath(filePath);
                 }
             }
             catch (e) {
@@ -3356,12 +3325,16 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
             if (localId == null)
                 return;
             // Use Drizzle update API for proper parameterization (avoids SQL injection from filenames with quotes)
+            const now = Date.now();
             const updatePayload = {
                 propertyValue: safeNewValue ?? null,
                 refSeedType: refSeedType ?? null,
                 refResolvedValue: refResolvedValue ?? null,
                 refResolvedDisplayValue: refResolvedDisplayValue ?? null,
-                updatedAt: Date.now(),
+                // Readers take the newest row by COALESCE(attestation_created_at, created_at), so a draft's
+                // time is when its value was last set: a synced value older than this edit mustn't win.
+                createdAt: now,
+                updatedAt: now,
             };
             if (localStorageDir !== undefined) {
                 updatePayload.localStorageDir = localStorageDir ?? null;
@@ -3434,6 +3407,48 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
     };
 };
 
+const queues = new Map();
+let nextTicket = 0;
+const propertyWriteKey = (seedId, propertyName) => (seedId && propertyName ? `${seedId}:${propertyName}` : undefined);
+const reservePropertyWrite = (key) => {
+    let queue = queues.get(key);
+    if (!queue) {
+        queue = { tail: Promise.resolve(), latest: 0, pending: 0 };
+        queues.set(key, queue);
+    }
+    const q = queue;
+    const ticket = ++nextTicket;
+    q.latest = ticket;
+    q.pending += 1;
+    let released = false;
+    const release = () => {
+        if (released)
+            return;
+        released = true;
+        q.pending -= 1;
+        if (q.pending === 0 && queues.get(key) === q)
+            queues.delete(key);
+    };
+    const run = async (write) => {
+        const previous = q.tail;
+        let done;
+        const mine = new Promise((resolve) => (done = resolve));
+        q.tail = previous.then(() => mine);
+        try {
+            await previous;
+            if (q.latest !== ticket)
+                return { skipped: true };
+            return { skipped: false, result: await write() };
+        }
+        finally {
+            done();
+            release();
+        }
+    };
+    return { run, release };
+};
+const hasPendingPropertyWrite = (key) => !!key && (queues.get(key)?.pending ?? 0) > 0;
+
 const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
     const { localId, propertyName: propertyNameRaw, seedLocalId, versionLocalId, versionUid, propertyValue: existingValue, propertyRecordSchema, modelName, } = context;
     let { schemaUid } = context;
@@ -3447,6 +3462,10 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
     if (!propertyRecordSchema) {
         throw new Error('Missing propertyRecordSchema');
     }
+    // Reserved now, before the async checks below, so a newer save always replaces this one.
+    const writeKey = propertyWriteKey(seedLocalId ?? context.seedUid, propertyNameRaw);
+    const writeSlot = writeKey ? reservePropertyWrite(writeKey) : undefined;
+    const writeValue = (write) => writeSlot ? writeSlot.run(write) : write().then((result) => ({ skipped: false, result }));
     const _analyzeInput = async () => {
         // Assignment writes straight to the DB, so check ownership here as save()/destroy()/publish() do.
         const { isItemOwned, OwnershipError } = await Promise.resolve().then(function () { return ownership; });
@@ -3455,9 +3474,9 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
             return false;
         }
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-Cvt5UBz4.js');
+        const schemaMod = await import('./index-CqnU-5i0.js');
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await import('./SchemaValidationService-DieV4KL-.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-DViJ056F.js');
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -3541,7 +3560,7 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
         // List (including list of relations / primitives): JSON in DB, array in context for publish (bytes32[])
         if (normalizedDataType === ModelPropertyDataTypes.List && Array.isArray(newValue)) {
             const stringValue = JSON.stringify(newValue);
-            const result = await updateItemPropertyValue({
+            const written = await writeValue(() => updateItemPropertyValue({
                 localId,
                 propertyName: propertyName,
                 newValue: stringValue,
@@ -3552,7 +3571,11 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
                 schemaUid,
                 dataType: propertyRecordSchema.dataType,
                 refValueType: propertyRecordSchema.refValueType,
-            });
+            }));
+            // A newer save replaced this one: it writes, and sets the context, instead.
+            if (written.skipped)
+                return true;
+            const result = written.result;
             const updatedContext = {
                 propertyValue: newValue,
                 renderValue: newValue,
@@ -3572,7 +3595,7 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
         const stringValue = newValue !== null && newValue !== undefined
             ? (typeof newValue === 'string' ? newValue : String(newValue))
             : null;
-        const result = await updateItemPropertyValue({
+        const written = await writeValue(() => updateItemPropertyValue({
             localId,
             propertyName: propertyName,
             newValue: stringValue,
@@ -3583,7 +3606,10 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
             schemaUid,
             dataType: propertyRecordSchema.dataType,
             refValueType: propertyRecordSchema.refValueType,
-        }); // Type assertion needed because newValue is not in MetadataType but is accepted by the function
+        })); // Type assertion needed because newValue is not in MetadataType but is accepted by the function
+        if (written.skipped)
+            return true;
+        const result = written.result;
         const stringValueForContext = typeof newValue === 'string' ? newValue : (newValue !== null && newValue !== undefined ? String(newValue) : undefined);
         let updatedContext = {
             propertyValue: stringValueForContext,
@@ -3607,7 +3633,7 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
         });
         return true;
     };
-    _analyzeInput().then((isDone) => {
+    _analyzeInput().finally(() => writeSlot?.release()).then((isDone) => {
         if (isDone) {
             sendBack({ type: 'saveValueToDbSuccess' });
         }
@@ -3749,7 +3775,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await import('./SchemaValidationService-DieV4KL-.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-DViJ056F.js');
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
             ? normalizeDataType(String(propertyRecordSchema.refValueType))
@@ -3839,6 +3865,13 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
     return inserted[0];
 };
 
+/**
+ * Name of a new Image or File seed's file in the shared `images/` or `files/` folder. Uploads keep
+ * their own name (and so their extension, which publish reads for the content type), prefixed with
+ * the new seed's local id: two posts that each upload `photo.png` mustn't write the same file.
+ */
+const storageFileNameForNewSeed = (seedLocalId, name) => `${seedLocalId}-${name}`;
+
 /** Fetch image from URL (including blob:) and return { buffer, mimeType } for saving as binary. */
 const fetchImageAsBuffer = async (url) => {
     const response = await fetch(url);
@@ -3922,6 +3955,9 @@ const saveImage = fromCallback(({ sendBack, input: { context, event } }) => {
                 fileName += `.${mimeType.split('/')[1]}`;
             }
         }
+        else if (!isExistingFileReference) {
+            fileName = storageFileNameForNewSeed(newImageSeedLocalId, fileName);
+        }
         const filePath = BaseFileManager.getFilesPath('images', fileName);
         await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('images'));
         await createVersion({
@@ -4035,6 +4071,35 @@ const saveImage = fromCallback(({ sendBack, input: { context, event } }) => {
 });
 
 let fileSchemaUid;
+/**
+ * What a string assigned to a File property means:
+ * - `data:` URL: its decoded bytes
+ * - `http(s):` or `blob:` URL: fetched
+ * - the name of a file already in the files folder: a reference to it
+ * - anything else: the file's text content
+ * (Bare strings used to be decoded as base64 when they looked like it, so "hello" became
+ * garbage, and names like "photo.jpg" were fetched as URLs.)
+ */
+async function classifyFileString(value) {
+    const dataUrl = /^data:([^,]*?)(;base64)?,(.*)$/s.exec(value);
+    if (dataUrl) {
+        const [, , isBase64, payload] = dataUrl;
+        const bytes = isBase64
+            ? Uint8Array.from(atob(payload), (c) => c.charCodeAt(0))
+            : new TextEncoder().encode(decodeURIComponent(payload));
+        return { kind: 'dataUrl', bytes: bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) };
+    }
+    if (/^(https?:\/\/|blob:)/i.test(value)) {
+        return { kind: 'url' };
+    }
+    if (!/[\\/]/.test(value) && value.length < 256) {
+        const existingFilePath = BaseFileManager.getFilesPath('files', value);
+        if (await BaseFileManager.pathExists(existingFilePath)) {
+            return { kind: 'existing' };
+        }
+    }
+    return { kind: 'text' };
+}
 const saveFile = fromCallback(({ sendBack, input: { context, event } }) => {
     const { localId, propertyName: propertyNameRaw, propertyValue: existingValue, propertyRecordSchema, modelName, seedLocalId, seedUid, versionLocalId, versionUid, } = context;
     let { schemaUid } = context;
@@ -4074,22 +4139,22 @@ const saveFile = fromCallback(({ sendBack, input: { context, event } }) => {
             const fetchedSchemaUid = await getEasSchemaUidForModel('File');
             fileSchemaUid = fetchedSchemaUid ?? undefined;
         }
+        let isExistingFileReference = false;
         if (typeof newValue === 'string') {
-            const newValueType = getDataTypeFromString(newValue);
-            if (newValueType === 'base64') {
-                const base64Data = newValue.split(',')[1] || newValue;
-                const binaryString = atob(base64Data);
-                const binaryArray = new Uint8Array(binaryString.length);
-                for (let i = 0; i < binaryString.length; i++) {
-                    binaryArray[i] = binaryString.charCodeAt(i);
-                }
-                fileData = binaryArray.buffer;
+            const source = await classifyFileString(newValue);
+            if (source.kind === 'dataUrl') {
+                fileData = source.bytes;
             }
-            else if (newValueType === 'url') {
+            else if (source.kind === 'url') {
                 const response = await fetch(newValue);
                 fileData = await response.arrayBuffer();
-                const urlPath = new URL(newValue);
-                fileName = urlPath.pathname.split('/').pop();
+                if (!newValue.startsWith('blob:')) {
+                    fileName = new URL(newValue).pathname.split('/').pop() || undefined;
+                }
+            }
+            else if (source.kind === 'existing') {
+                isExistingFileReference = true;
+                fileName = newValue;
             }
             else {
                 fileData = newValue;
@@ -4099,18 +4164,6 @@ const saveFile = fromCallback(({ sendBack, input: { context, event } }) => {
             fileName = newValue.name;
             fileData = await newValue.arrayBuffer(); // Blob API: works in browsers and Node (no FileReader in Node)
         }
-        // Handle existing file reference: filename from listFiles() that exists in files folder
-        let isExistingFileReference = false;
-        if (typeof newValue === 'string' &&
-            getDataTypeFromString(newValue) === null) {
-            const existingFilePath = BaseFileManager.getFilesPath('files', newValue);
-            const pathExistsResult = await BaseFileManager.pathExists(existingFilePath);
-            if (pathExistsResult) {
-                isExistingFileReference = true;
-                fileName = newValue;
-                fileData = undefined;
-            }
-        }
         if (!fileData && !isExistingFileReference) {
             throw new Error('No file data found');
         }
@@ -4121,6 +4174,9 @@ const saveFile = fromCallback(({ sendBack, input: { context, event } }) => {
         if (!fileName) {
             fileName = newFileSeedLocalId;
         }
+        else if (!isExistingFileReference) {
+            fileName = storageFileNameForNewSeed(newFileSeedLocalId, fileName);
+        }
         const filePath = BaseFileManager.getFilesPath('files', fileName);
         await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('files'));
         await createVersion({
@@ -4331,7 +4387,7 @@ const saveRelation = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-Cvt5UBz4.js');
+        const schemaMod = await import('./index-CqnU-5i0.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -4623,6 +4679,9 @@ const saveItemStorage = fromCallback(({ sendBack, input: { context, event } }) =
                 .set({
                 refResolvedValue: fileName,
                 localStorageDir,
+                // The draft is as new as its content (see updateItemPropertyValue).
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
                 // Same shape as a row the migration or publish converted (convertVerbatimItemStorageRow).
                 ...(clearsVerbatimValue && { propertyValue: null, refValueType: 'file' }),
             })
@@ -4669,6 +4728,30 @@ const withListRelationStorageName = (context) => {
         return context;
     return { ...context, propertyName: storageName, isRelation: true };
 };
+/**
+ * List values are stored as JSON array strings. Whichever actor or event delivers one, a List
+ * property holds the array, so `value` reads the same on a new item and after a reload.
+ */
+const withListValueParsed = (context) => {
+    if (normalizePropertyRecordSchema(context.propertyRecordSchema ?? {})?.dataType !== 'List')
+        return context;
+    const parse = (value) => {
+        if (typeof value !== 'string' || !value.trimStart().startsWith('['))
+            return value;
+        try {
+            const parsed = JSON.parse(value);
+            return Array.isArray(parsed) ? parsed : value;
+        }
+        catch {
+            return value;
+        }
+    };
+    const propertyValue = parse(context.propertyValue);
+    const renderValue = parse(context.renderValue);
+    if (propertyValue === context.propertyValue && renderValue === context.renderValue)
+        return context;
+    return { ...context, propertyValue, renderValue };
+};
 const propertyMachine = setup({
     types: {
         context: {},
@@ -4736,9 +4819,7 @@ const propertyMachine = setup({
                     }
                     newContext[key] = event[key];
                 }
-                return 'propertyRecordSchema' in event
-                    ? withListRelationStorageName(newContext)
-                    : newContext;
+                return withListValueParsed('propertyRecordSchema' in event ? withListRelationStorageName(newContext) : newContext);
             }),
         },
         destroyStarted: {
@@ -4790,7 +4871,7 @@ const propertyMachine = setup({
                     target: 'idle',
                     actions: assign(({ context, event }) => {
                         const property = event.property;
-                        return withListRelationStorageName({
+                        return withListValueParsed(withListRelationStorageName({
                             ...context,
                             propertyName: property.propertyName || context.propertyName,
                             propertyValue: property.propertyValue !== undefined ? property.propertyValue : context.propertyValue,
@@ -4808,7 +4889,7 @@ const propertyMachine = setup({
                             refResolvedValue: property.refResolvedValue !== undefined ? property.refResolvedValue : context.refResolvedValue,
                             refResolvedDisplayValue: property.refResolvedDisplayValue !== undefined ? property.refResolvedDisplayValue : context.refResolvedDisplayValue,
                             localStorageDir: property.localStorageDir !== undefined ? property.localStorageDir : context.localStorageDir,
-                        });
+                        }));
                     }),
                 },
                 loadOrCreatePropertyError: {
@@ -5025,12 +5106,12 @@ const getPropertyData = async ({ propertyName, seedLocalId, seedUid, modelName,
     let names = [...getMetadataPropertyNamesForQuery(propertyName)];
     if (modelName) {
         try {
-            const _mod_13 = await import('./index-8O3Uow-Y.js');
-            const _ns_13 = _mod_13.f;
-            const { Model } = _ns_13;
-            const _mod_14 = await import('./BasePathResolver-Cm4apKRb.js');
-            const _ns_14 = _mod_14.b1;
-            const { resolveItemModelFileId } = _ns_14;
+            const _mod_11 = await import('./errors-Cl8rbtKR.js');
+            const _ns_11 = _mod_11.h;
+            const { Model } = _ns_11;
+            const _mod_12 = await import('./BasePathResolver-DxdS0wJ0.js');
+            const _ns_12 = _mod_12.b2;
+            const { resolveItemModelFileId } = _ns_12;
             // Model names are only unique per schema: use the seed's own model when it is recorded.
             const modelFileId = await resolveItemModelFileId({ seedLocalId, seedUid });
             const model = await Model.resolveAsync(modelName, { modelFileId });
@@ -5076,31 +5157,17 @@ var getPropertyData$1 = /*#__PURE__*/Object.freeze({
 });
 
 /**
- * Unload an entity instance and clean up all resources
+ * Release one reference to a cached entity instance. When none remain, remove it from the
+ * caches, clean up its subscriptions and stop its service
  *
  * @param instance - Entity instance to unload
  * @param config - Unload configuration
  */
 function unloadEntity(instance, config) {
-    // Clean up liveQuery subscriptions
-    const instanceState = config.instanceState.get(instance);
-    if (instanceState) {
-        for (const key of ['liveQuerySubscription', 'schemaLiveQuerySubscription']) {
-            const sub = instanceState[key];
-            if (sub?.unsubscribe) {
-                try {
-                    sub.unsubscribe();
-                    instanceState[key] = null;
-                }
-                catch (error) {
-                    // Ignore errors during cleanup
-                }
-            }
-        }
-    }
     // Get cache keys for this instance
     const cacheKeys = config.getCacheKeys(instance);
     // Remove from all caches (decrement refCount, delete if 0)
+    let stillReferenced = false;
     for (const cache of config.caches) {
         for (const key of cacheKeys) {
             const entry = cache.get(key);
@@ -5117,6 +5184,27 @@ function unloadEntity(instance, config) {
                 }
                 else {
                     cache.set(key, entry);
+                    stillReferenced = true;
+                }
+            }
+        }
+    }
+    // Other holders (e.g. another hook that created the same cached instance) still use it:
+    // keep its subscriptions and service running. Stopping here broke them.
+    if (stillReferenced)
+        return;
+    // Clean up liveQuery subscriptions
+    const instanceState = config.instanceState.get(instance);
+    if (instanceState) {
+        for (const key of ['liveQuerySubscription', 'schemaLiveQuerySubscription']) {
+            const sub = instanceState[key];
+            if (sub?.unsubscribe) {
+                try {
+                    sub.unsubscribe();
+                    instanceState[key] = null;
+                }
+                catch (error) {
+                    // Ignore errors during cleanup
                 }
             }
         }
@@ -5222,9 +5310,9 @@ const HTML_PROP_SEED_UID_RE = /^0x[a-fA-F0-9]{64}$/;
  */
 const resolvePropertyRecordSchemaFromSchemaData = async (modelName, propertyName, modelType, schemaName) => {
     try {
-        const _mod_15 = await import('./ClientManager-i3nJASkg.js');
-        const _ns_15 = _mod_15.K;
-        const { loadAllSchemasFromDb } = _ns_15;
+        const _mod_13 = await import('./ClientManager-De-vKHGe.js');
+        const _ns_13 = _mod_13.K;
+        const { loadAllSchemasFromDb } = _ns_13;
         const allSchemas = await loadAllSchemasFromDb();
         const modelNameAlt = modelType ? upperFirst(camelCase(modelType)) : '';
         for (const { schema } of allSchemas) {
@@ -5276,13 +5364,13 @@ hints = {}) => {
         return undefined;
     }
     try {
-        const _mod_16 = await import('./index-8O3Uow-Y.js');
-        const _ns_16 = _mod_16.f;
-        const { Model } = _ns_16;
-        const { modelPropertiesToObject } = await import('./model-DGMe-TTm.js');
-        const _mod_17 = await import('./BasePathResolver-Cm4apKRb.js');
-        const _ns_17 = _mod_17.b1;
-        const { resolveItemModelFileId } = _ns_17;
+        const _mod_14 = await import('./errors-Cl8rbtKR.js');
+        const _ns_14 = _mod_14.h;
+        const { Model } = _ns_14;
+        const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
+        const _mod_15 = await import('./BasePathResolver-DxdS0wJ0.js');
+        const _ns_15 = _mod_15.b2;
+        const { resolveItemModelFileId } = _ns_15;
         const modelFileId = await resolveItemModelFileId(hints);
         let model = modelFileId
             ? await Model.resolveAsync(modelName || modelTypeToModelName(modelType ?? ''), { modelFileId })
@@ -5440,7 +5528,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await import('./index-Cvt5UBz4.js');
+            const schemaMod = await import('./index-CqnU-5i0.js');
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -5611,9 +5699,9 @@ class ItemProperty {
                 const normalizedRefValueType = normalizeDataType(propertyRecordSchema?.refValueType);
                 const propertyNames = getMetadataPropertyNamesForQuery(propertyName, normalizedDataType, normalizedRefValueType);
                 const propertyNameVariant = propertyNames.length > 1 ? propertyNames[1] : undefined;
-                const _mod_18 = await import('./index-AVFTVp1m.js');
-                const _ns_18 = _mod_18.s;
-                const seedSchemaMod = _ns_18;
+                const _mod_16 = await import('./index-DAl9U4rn.js');
+                const _ns_16 = _mod_16.s;
+                const seedSchemaMod = _ns_16;
                 const { metadata } = seedSchemaMod;
                 const drizzleMod = await import('drizzle-orm');
                 const { eq, and, or } = drizzleMod;
@@ -5745,6 +5833,14 @@ class ItemProperty {
                                 return;
                             const metaRow = metadataRows[0];
                             logger(`[ItemProperty._setupLiveQuerySubscription] Metadata updated in database for propertyName: ${propertyName}`);
+                            // While this property has a save pending, the row is older than the value in memory
+                            // (the user may still be typing): showing it would drop keystrokes, and another tab's
+                            // write would replace the value being typed. The save sets the context itself.
+                            const { context } = this._service.getSnapshot();
+                            if (context.isSaving ||
+                                hasPendingPropertyWrite(propertyWriteKey(context.seedLocalId ?? context.seedUid, context.propertyName))) {
+                                return;
+                            }
                             // Update context with metadata changes
                             this._service.send({
                                 type: 'updateContext',
@@ -5827,9 +5923,9 @@ class ItemProperty {
             const ctx = this._service.getSnapshot().context;
             let modelFileId;
             try {
-                const _mod_19 = await import('./BasePathResolver-Cm4apKRb.js');
-                const _ns_19 = _mod_19.b1;
-                const { resolveItemModelFileId } = _ns_19;
+                const _mod_17 = await import('./BasePathResolver-DxdS0wJ0.js');
+                const _ns_17 = _mod_17.b2;
+                const { resolveItemModelFileId } = _ns_17;
                 modelFileId = await resolveItemModelFileId({
                     modelFileId: ctx.modelFileId,
                     seedLocalId: ctx.seedLocalId,
@@ -6190,9 +6286,9 @@ class ItemProperty {
         const propertiesData = await getItemProperties({ seedLocalId, seedUid });
         const instances = [];
         const seenNormalized = new Set();
-        const _mod_20 = await import('./BasePathResolver-Cm4apKRb.js');
-        const _ns_20 = _mod_20.b1;
-        const { resolveItemModelFileId } = _ns_20;
+        const _mod_18 = await import('./BasePathResolver-DxdS0wJ0.js');
+        const _ns_18 = _mod_18.b2;
+        const { resolveItemModelFileId } = _ns_18;
         const itemModelFileId = await resolveItemModelFileId({ seedLocalId, seedUid });
         for (const data of propertiesData) {
             const d = data;
@@ -6208,10 +6304,10 @@ class ItemProperty {
             }
             else if (baseName) {
                 try {
-                    const _mod_21 = await import('./index-8O3Uow-Y.js');
-                    const _ns_21 = _mod_21.f;
-                    const { Model } = _ns_21;
-                    const { modelPropertiesToObject } = await import('./model-DGMe-TTm.js');
+                    const _mod_19 = await import('./errors-Cl8rbtKR.js');
+                    const _ns_19 = _mod_19.h;
+                    const { Model } = _ns_19;
+                    const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
                     const model = await Model.resolveAsync(modelName, { modelFileId });
                     if (model?.properties) {
                         const schemas = modelPropertiesToObject(model.properties);
@@ -6225,10 +6321,10 @@ class ItemProperty {
             }
             if (modelName && propertyName) {
                 try {
-                    const _mod_22 = await import('./index-8O3Uow-Y.js');
-                    const _ns_22 = _mod_22.f;
-                    const { Model } = _ns_22;
-                    const { modelPropertiesToObject } = await import('./model-DGMe-TTm.js');
+                    const _mod_20 = await import('./errors-Cl8rbtKR.js');
+                    const _ns_20 = _mod_20.h;
+                    const { Model } = _ns_20;
+                    const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
                     const model = await Model.resolveAsync(modelName, { modelFileId });
                     if (model?.properties?.length) {
                         const schemas = modelPropertiesToObject(model.properties);
@@ -6557,9 +6653,9 @@ class ItemProperty {
                 if (!propertyName || (!seedLocalId && !seedUid))
                     return;
                 if (db) {
-                    const _mod_23 = await import('./index-AVFTVp1m.js');
-                    const _ns_23 = _mod_23.s;
-                    const seedSchemaMod = _ns_23;
+                    const _mod_21 = await import('./index-DAl9U4rn.js');
+                    const _ns_21 = _mod_21.s;
+                    const seedSchemaMod = _ns_21;
                     const { metadata } = seedSchemaMod;
                     const drizzleMod = await import('drizzle-orm');
                     const { and, eq } = drizzleMod;
@@ -6602,9 +6698,9 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
     }
     const seedType = toSnakeCase(modelName);
     // Dynamic import to break circular dependency
-    const _mod_24 = await import('./index-8O3Uow-Y.js');
-    const _ns_24 = _mod_24.f;
-    const modelMod = _ns_24;
+    const _mod_22 = await import('./errors-Cl8rbtKR.js');
+    const _ns_22 = _mod_22.h;
+    const modelMod = _ns_22;
     const { Model } = modelMod;
     const model = await Model.resolveAsync(modelName, { modelFileId });
     const propertySchemas = model?.properties ? modelPropertiesToObject(model.properties) : undefined;
@@ -6785,9 +6881,9 @@ const getModel = () => {
         // the fragile `import(...).then(n => n.X)` chunk-namespace pattern.
         if (!modelImportPromise) {
             modelImportPromise = (async () => {
-                const _mod_25 = await import('./index-8O3Uow-Y.js');
-                const _ns_25 = _mod_25.f;
-                const mod = _ns_25;
+                const _mod_23 = await import('./errors-Cl8rbtKR.js');
+                const _ns_23 = _mod_23.h;
+                const mod = _ns_23;
                 ModelClass = mod.Model;
                 return mod;
             })();
@@ -6953,14 +7049,14 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const getPublishUploadsMod = await import('./getPublishUploads-SFHCbf_y.js');
+            const getPublishUploadsMod = await import('./getPublishUploads-DJ1UPh7i.js');
             const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this, [], undefined, options);
         };
         this.getPublishPayload = async (uploadedTransactions, options) => {
-            const _mod_26 = await import('./getPublishPayload-CTCvRUoU.js');
-            const _ns_26 = _mod_26.g;
-            const getPublishPayloadMod = _ns_26;
+            const _mod_24 = await import('./getPublishPayload-C278kK9P.js');
+            const _ns_24 = _mod_24.g;
+            const getPublishPayloadMod = _ns_24;
             const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions, options);
         };
@@ -7494,26 +7590,32 @@ class Item {
         const db = BaseDb.getAppDb();
         if (db && props.modelName) {
             // Model names are only unique per schema: resolve the exact models row from the most specific scope.
-            const _mod_27 = await import('./BasePathResolver-Cm4apKRb.js');
-            const _ns_27 = _mod_27.b1;
-            const { resolveModelRecord } = _ns_27;
+            const _mod_25 = await import('./BasePathResolver-DxdS0wJ0.js');
+            const _ns_25 = _mod_25.b2;
+            const { resolveModelRecord } = _ns_25;
             const modelRecord = await resolveModelRecord(props.modelName, {
                 modelFileId: props.modelFileId ?? modelInstance?.id,
                 schemaName: schemaName ?? modelInstance?.schemaName,
             });
             const modelRecords = modelRecord ? [modelRecord] : [];
+            if (!modelRecord) {
+                const _mod_26 = await import('./errors-Cl8rbtKR.js');
+                const _ns_26 = _mod_26.j;
+                const { UnknownModelError } = _ns_26;
+                throw new UnknownModelError(props.modelName, schemaName ?? modelInstance?.schemaName);
+            }
             if (modelRecord?.schemaFileId) {
                 props.modelFileId = modelRecord.schemaFileId;
             }
             // Scope the constructor's Model lookup to this model's schema (as getItemData does on reload),
             // so a same-named model cached from another schema can't supply the property set.
             if (modelRecord && !props.schemaName) {
-                const _mod_28 = await import('./BasePathResolver-Cm4apKRb.js');
+                const _mod_27 = await import('./BasePathResolver-DxdS0wJ0.js');
+                const _ns_27 = _mod_27.b1;
+                const { modelSchemas } = _ns_27;
+                const _mod_28 = await import('./BasePathResolver-DxdS0wJ0.js');
                 const _ns_28 = _mod_28.b0;
-                const { modelSchemas } = _ns_28;
-                const _mod_29 = await import('./BasePathResolver-Cm4apKRb.js');
-                const _ns_29 = _mod_29.a$;
-                const { schemas: schemasTable } = _ns_29;
+                const { schemas: schemasTable } = _ns_28;
                 const schemaRows = await db
                     .select({ schemaName: schemasTable.name })
                     .from(modelSchemas)
@@ -7567,6 +7669,12 @@ class Item {
                 modelPropertyData[key] = value;
             }
         }
+        // Strict by default: unknown keys and invalid values reject before anything is written.
+        // Values that go through the property save pipeline (files, Html, ItemStorage) are
+        // validated there.
+        if (propertyNames.length > 0 && options?.validate !== false) {
+            await Item.assertValidCreateValues(props, propertyNames, dataTypeByPropertyName, new Set(pipelineValues.map(([key]) => key)));
+        }
         const { seedLocalId, versionLocalId, } = await createNewItem(modelPropertyData);
         props.seedLocalId = seedLocalId;
         props.latestVersionLocalId = versionLocalId;
@@ -7864,9 +7972,9 @@ class Item {
         if (!appDb || Item.instanceCache.size === 0) {
             return;
         }
-        const _mod_30 = await import('./index-AVFTVp1m.js');
-        const _ns_30 = _mod_30.s;
-        const { metadata } = _ns_30;
+        const _mod_29 = await import('./index-DAl9U4rn.js');
+        const _ns_29 = _mod_29.s;
+        const { metadata } = _ns_29;
         const { eq, and } = await import('drizzle-orm');
         const dedupedInstances = new Map();
         for (const entry of Item.instanceCache.values()) {
@@ -8025,7 +8133,64 @@ class Item {
         });
         state.definedPropertyNames.add(propertyName);
     }
-    /** Same as `item.publish(options)`; requires @seedprotocol/publish. */
+    /** Throws ItemCreateValidationError for unknown keys and values that break their property's rules. */
+    static async assertValidCreateValues(props, propertyNames, dataTypeByPropertyName, skipKeys) {
+        const _mod_30 = await import('./errors-Cl8rbtKR.js');
+        const _ns_30 = _mod_30.j;
+        const { ItemCreateValidationError } = _ns_30;
+        const { getPropertySchema } = await import('./property-Brgr5RdT.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-DViJ056F.js');
+        const validationService = new SchemaValidationService();
+        const modelName = props.modelName;
+        const known = new Set(propertyNames);
+        const problems = [];
+        for (const [key, value] of Object.entries(props)) {
+            if (Item.CREATE_METADATA_KEYS.has(key) || skipKeys.has(key))
+                continue;
+            if (!known.has(key)) {
+                problems.push({
+                    property: key,
+                    code: 'unknown_property',
+                    message: `${modelName} has no property "${key}"`,
+                });
+                continue;
+            }
+            if (value === undefined || value === null)
+                continue;
+            const propertySchema = await getPropertySchema(modelName, key, {
+                modelFileId: props.modelFileId,
+                schemaName: props.schemaName,
+            });
+            const dataType = normalizeDataType(propertySchema?.dataType ?? dataTypeByPropertyName.get(key) ?? '');
+            if (!dataType)
+                continue;
+            // Lists may be passed as the JSON array string they are stored as.
+            let checked = value;
+            if (dataType === ModelPropertyDataTypes.List && typeof value === 'string') {
+                try {
+                    const parsed = JSON.parse(value);
+                    if (Array.isArray(parsed))
+                        checked = parsed;
+                }
+                catch {
+                    // Not JSON: validated as given, and rejected as a non-array
+                }
+            }
+            const { resolvePropertyValidationRules } = await import('./propertyValidationRules-CDRitiiK.js');
+            const rules = propertySchema?.validation ??
+                (await resolvePropertyValidationRules(modelName, key, {
+                    modelFileId: props.modelFileId,
+                    schemaName: props.schemaName,
+                }));
+            const result = validationService.validatePropertyValue(checked, dataType, rules, propertySchema?.refValueType);
+            for (const error of result.errors) {
+                problems.push({ property: key, code: error.code, message: error.message });
+            }
+        }
+        if (problems.length > 0) {
+            throw new ItemCreateValidationError(modelName, problems);
+        }
+    }
     /**
      * Set `publisher` on loaded Items for these seeds (after claimUnpublishedDrafts stamped
      * their rows). Items that aren't loaded read it from the DB when they load.
@@ -8342,7 +8507,7 @@ class Item {
                 itemActor.send(event);
             };
             try {
-                const _mod_31 = await import('./index-AVFTVp1m.js');
+                const _mod_31 = await import('./index-DAl9U4rn.js');
                 const _ns_31 = _mod_31.s;
                 const seedSchemaMod = _ns_31;
                 const { seeds, versions, metadata } = seedSchemaMod;
@@ -8691,6 +8856,15 @@ class Item {
     }
 }
 Item.instanceCache = new Map();
+/** Same as `item.publish(options)`; requires @seedprotocol/publish. */
+/** Keys Item.create accepts besides the model's properties. */
+Item.CREATE_METADATA_KEYS = new Set([
+    'modelName', 'schemaName', 'modelInstance', 'modelFileId', 'type',
+    'seedLocalId', 'seedUid', 'schemaUid', 'attestationCreatedAt',
+    'latestVersionUid', 'latestVersionLocalId', 'publishedVersionUid', 'publishedVersionLocalId',
+    'versionsCount', 'lastVersionPublishedAt', 'lastLocalUpdateAt',
+    'createdAt', 'updatedAt', 'publisher', 'revokedAt',
+]);
 
 var Item$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -8698,4 +8872,4 @@ var Item$1 = /*#__PURE__*/Object.freeze({
 });
 
 export { getInvariantSafePropertyDescriptor as $, getGetPublisherForNewSeeds as A, getMetadataLatest as B, ClientManagerState as C, DEFAULT_READY_TIMEOUT_MS as D, getPublishExecutor as E, getRevokeExecutor as F, getUploadExecutor as G, getVersionData$1 as H, Item as I, isLocalUnsealedDraft as J, isSeedRowOwned as K, localUnsealedDraftSql as L, METADATA_LATEST_FIRST_ORDER_SQL as M, ownedPublisherSql as N, OwnershipError as O, PUBLISH_NOT_CONFIGURED_MESSAGE as P, ownedSeedsSql as Q, pickLatestMetadataRowPerProperty as R, placeholderUidSql as S, propertyMachine as T, publisherInAddressListSql as U, publisherIsInOwnedSet as V, setAdditionalSyncAddresses as W, setGetPublisherForNewSeeds as X, setPublishExecutor as Y, setRevokeExecutor as Z, setUploadExecutor as _, chunkValues as a, clearDestroySubscriptions as a0, unloadEntity as a1, ClientManagerEvents as a2, withLockedItemStorageRow as a3, getItemStorageFilePath as a4, writeItemStorageFile as a5, resolvePublisherFromSeedRow as a6, getPropertyData$1 as a7, Item$1 as a8, rowsPerInsert as b, compareMetadataRowsLatestFirst as c, getGetAdditionalSyncAddresses as d, ItemProperty as e, ItemPropertySaveValidationError as f, getItemData as g, assertItemOwned as h, isItemOwned as i, getEasSchemaUidForModel as j, getLatestPublishedVersionRow as k, listRelationEasPropertyName as l, isVersionRevoked as m, waitForEntityIdle as n, createReactiveProxy as o, parseListPropertyValueFromStorage as p, findEntity as q, resolveStorageNameToSchemaName as r, selectInBatches as s, forceRemoveFromCaches as t, runDestroyLifecycle as u, isPublishedMetadataRow as v, writeInBatches as w, MachineIds as x, createNewItem as y, getEasSchemaForItemProperty as z };
-//# sourceMappingURL=Item-DBFchXpC.js.map
+//# sourceMappingURL=Item-cq9VcsAY.js.map