@seedprotocol/sdk 0.7.8-next.1071.g2a141c1 → 0.7.8

package/dist/{Item-tX3kpbj4.js → Item-CjTEShfk.js}

@@ -1,12 +1,12 @@
-import debug from 'debug';
+import { v as timingNow, x as timingSince, y as timingLogger, z as TAB_ID, o as onTabMessage, c as whenLeaderTab, a as isLeaderTab, k as postTabMessage, f as createSessionObjectUrl, t as timingMarks, B as timed, u as notifyFileSaved, C as revokeSessionObjectUrl, b as watchEntityRows, D as queryEntityRows, E as isSessionObjectUrl, G as timedDb } from './changeFeed-DcsZ7deG.js';
 import { waitFor, fromCallback, setup, assign, stateIn, createActor, isMachineSnapshot } from 'xstate';
-import { F as BaseDb, E as versions, m as metadata, B as seeds, G as resolveStorageNameToSchemaName, b2 as toSchemaPropertyName, i as isDataType, ai as generateId, u as pendingWrites, b3 as isSqliteBusyError, A as schemas, s as models, q as modelSchemas, b0 as getOwnedAddressesFromDb, a3 as ZERO_BYTES32, aH as normalizeAddressList, aj as normalizeHexAddress, aE as getAddressesForItemsFilter, a7 as INTERNAL_PROPERTY_NAMES, b4 as easSchemaDefinitionForProperty, N as BaseFileManager, b5 as getStorageTransactionIdForSeedUid, b6 as convertTxIdToImage, ad as normalizePublisher, ab as listRelationEasPropertyName, n as normalizeDataType, L as resolveItemModelFileId, b7 as getPropertyIdForSchemaFileId, K as getPropertyIdForModelAndName, a_ as getMetadataPropertyNamesForQuery, aD as ensureImageLocal, av as ImageSize, b8 as downloadTransactionIdWithDedupe, b9 as resolveMetadataRecord, v as properties, M as ModelPropertyDataTypes, I as eventEmitter, r as modelUids, ak as toMetadataPropertyName, ba as getDataTypeFromString, bb as getMimeType, Y as INTERNAL_STORAGE_MODEL_FILE_IDS, g as normalizePropertyRecordSchema, bc as listRelationStoragePropertyName, bd as PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, R as getCorrectId, a0 as getItemStorageSubdir, a1 as getItemStorageLocalFileName, be as toItemPropertyKey, bf as getAlternatePropertyNameForInstanceLookup, a8 as isStorageSeedRef } from './index-s73wD_LC.js';
+import { G as BaseDb, F as versions, m as metadata, C as seeds, H as resolveStorageNameToSchemaName, b5 as toSchemaPropertyName, i as isDataType, aj as generateId, v as pendingWrites, aq as isSqliteBusyError, B as schemas, t as models, r as modelSchemas, b3 as getOwnedAddressesFromDb, a5 as ZERO_BYTES32, aJ as normalizeAddressList, ak as normalizeHexAddress, aG as getAddressesForItemsFilter, a8 as INTERNAL_PROPERTY_NAMES, b6 as easSchemaDefinitionForProperty, Q as BaseFileManager, b7 as getStorageTransactionIdForSeedUid, b8 as convertTxIdToImage, ae as normalizePublisher, ac as listRelationEasPropertyName, n as normalizeDataType, O as resolveItemModelFileId, b9 as getPropertyIdForSchemaFileId, N as getPropertyIdForModelAndName, b1 as getMetadataPropertyNamesForQuery, aF as ensureImageLocal, ax as ImageSize, ba as downloadTransactionIdWithDedupe, bb as resolveMetadataRecord, M as ModelPropertyDataTypes, J as eventEmitter, s as modelUids, al as toMetadataPropertyName, bc as getDataTypeFromString, bd as getMimeType, _ as INTERNAL_STORAGE_MODEL_FILE_IDS, g as normalizePropertyRecordSchema, be as listRelationStoragePropertyName, bf as PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, V as getCorrectId, a2 as getItemStorageSubdir, a3 as getItemStorageLocalFileName, bg as toItemPropertyKey, bh as getAlternatePropertyNameForInstanceLookup, w as properties, a9 as isStorageSeedRef } from './index-C0SetTd1.js';
 import { or, isNull, eq, max, count, and, getTableColumns, sql, asc, inArray, lt, isNotNull, desc, gt } from 'drizzle-orm';
 import pluralize from 'pluralize';
+import debug from 'debug';
 import { BehaviorSubject } from 'rxjs';
 import { startCase, upperFirst, camelCase, orderBy } from 'lodash-es';
 import { isValidEasAttestationUid, easName, isPlaceholderUid, getEasSchemaUidForSchemaDefinition, getEasSchemaUidForExactDefinition, getSchemaUidForModelFromCache, setSchemaUidForModel, cachedSchemaLookup, BaseQueryClient, BaseEasClient, GET_SCHEMAS } from '@seedprotocol/eas';
-import { h as TAB_ID, o as onTabMessage, w as whenLeaderTab, i as isLeaderTab, d as postTabMessage, c as createSessionObjectUrl, g as notifyFileSaved, r as revokeSessionObjectUrl, j as isSessionObjectUrl } from './tabEvents-BuorBItJ.js';
 import { fetchArweaveRawTextAcrossGateways } from '@seedprotocol/arweave';
 import { modelPropertiesToObject } from './model-oHA3YhOd.js';
 
@@ -290,32 +290,6 @@ function createReactiveProxy(config) {
     return proxy;
 }
 
-/**
- * Phase timings for item creates, finds and property saves, and ready waits that timed out but
- * were allowed to continue, under `DEBUG=seedSdk:timing`. Timing lines are `<label> <ms>ms` plus
- * any details, so an app can report where a slow call spent its time.
- */
-const timingLogger = debug('seedSdk:timing');
-const now = () => (typeof performance !== 'undefined' ? performance.now() : Date.now());
-/** Runs `fn` and logs how long it took (also when it throws). Costs nothing when the namespace is off. */
-async function timed(label, fn, details) {
-    if (!timingLogger.enabled)
-        return fn();
-    const start = now();
-    let failed = false;
-    try {
-        return await fn();
-    }
-    catch (error) {
-        failed = true;
-        throw error;
-    }
-    finally {
-        const extra = details?.();
-        timingLogger(`${label} ${Math.round(now() - start)}ms${failed ? ' (failed)' : ''}${extra ? ` ${extra}` : ''}`);
-    }
-}
-
 const ENV = (typeof process !== 'undefined' && process.env)
     ? process.env
     : (typeof window !== 'undefined' && window.env)
@@ -647,7 +621,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
         const itemPropertyMod = await Promise.resolve().then(function () { return ItemProperty$1; });
         const { ItemProperty } = itemPropertyMod;
         const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
-        const _mod_0 = await import('./errors-a4Tj6hly.js');
+        const _mod_0 = await import('./errors-rIWK7gwJ.js');
         const _ns_0 = _mod_0.i;
         const { Model } = _ns_0;
         // Resolve Model and build property schemas (use getByNameAsync for models not yet in cache)
@@ -665,7 +639,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             const schemaNameToTry = schemaName ?? model?.schemaName;
             if (schemaNameToTry) {
                 try {
-                    const _mod_1 = await import('./Schema-CY3OxwKS.js');
+                    const _mod_1 = await import('./Schema-CX9CTtho.js');
                     const _ns_1 = _mod_1.b;
                     const { Schema } = _ns_1;
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false, hold: false });
@@ -681,7 +655,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             }
             if (Object.keys(propertySchemas).length === 0) {
                 try {
-                    const _mod_2 = await import('./ClientManager-Bv15o3Oz.js');
+                    const _mod_2 = await import('./ClientManager-B1r_8P5Z.js');
                     const _ns_2 = _mod_2.X;
                     const { loadAllSchemasFromDb } = _ns_2;
                     const allSchemas = await loadAllSchemasFromDb();
@@ -702,11 +676,11 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             }
             if (Object.keys(propertySchemas).length === 0) {
                 try {
-                    const _mod_3 = await import('./ClientManager-Bv15o3Oz.js');
+                    const _mod_3 = await import('./ClientManager-B1r_8P5Z.js');
                     const _ns_3 = _mod_3.X;
                     const { listCompleteSchemaFiles } = _ns_3;
-                    const _mod_4 = await import('./index-s73wD_LC.js');
-                    const _ns_4 = _mod_4.bi;
+                    const _mod_4 = await import('./index-C0SetTd1.js');
+                    const _ns_4 = _mod_4.bk;
                     const { BaseFileManager } = _ns_4;
                     const schemaFiles = await listCompleteSchemaFiles();
                     for (const { filePath } of schemaFiles) {
@@ -726,7 +700,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await import('./index-bOwhhJJL.js');
+                const schemaMod = await import('./index-Dp4uyZYx.js');
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
@@ -743,7 +717,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-mP9mOZ2L.js');
+        const { normalizePropertyRecordSchema } = await import('./property-pcDxNEpy.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
@@ -776,7 +750,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-bOwhhJJL.js');
+                    const schemaMod = await import('./index-Dp4uyZYx.js');
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -880,6 +854,7 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
         else if (seedUid) {
             whereClauses.push(eq(seeds.uid, seedUid));
         }
+        const timingStart = timingNow();
         const seedRecords = await db
             .select()
             .from(seeds)
@@ -913,6 +888,7 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
         const schemaUid = seedRecord.schemaUid || undefined;
         const modelFileId = seedRecord.modelFileId || context.modelFileId || undefined;
         const modelScope = { modelFileId, schemaName: context.schemaName };
+        const seedMs = timingSince(timingStart);
         // Step 2: Query versions table to find all versions for that seed
         const versionData = getVersionData$1();
         const versionRecords = await db
@@ -980,6 +956,7 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
         }
         // Step 3: Latest metadata row per property_name for this seed (matches loadOrCreateProperty /
         // getItemProperties). Strict version_local_id = latest would drop properties whose rows lag version bumps.
+        const versionsMs = timingSince(timingStart) - seedMs;
         const metadataLatest = getMetadataLatest({
             seedLocalId: resolvedSeedLocalId,
             seedUid: resolvedSeedUid,
@@ -990,6 +967,7 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
             .from(metadataLatest)
             .where(eq(metadataLatest.rowNum, 1));
         logger$b(`Found ${metadataRecords.length} latest-per-property metadata rows for seed ${resolvedSeedLocalId} (latestVersionLocalId=${latestVersionLocalId} used for placeholders only)`);
+        const metadataMs = timingSince(timingStart) - seedMs - versionsMs;
         // Step 4: Create ItemProperty instances from metadata records + placeholders for model schema properties
         // Always call when we have a valid version so placeholders are created for properties without metadata
         const propertyInstances = await createItemPropertyInstances(metadataRecords, resolvedSeedLocalId, resolvedSeedUid, modelName, latestVersionLocalId, latestVersionUid, modelScope);
@@ -998,6 +976,10 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
         // Publish/attestation can keep properties in `saving` for many seconds; 5s caused timeouts during EAS work.
         const propertyIdleTimeoutMs = 120000;
         Promise.all(Array.from(propertyInstances.values()).map((prop) => waitForEntityIdle(prop, { timeout: propertyIdleTimeoutMs, throwOnError: false }))).catch(() => { });
+        if (timingLogger.enabled) {
+            const totalMs = timingSince(timingStart);
+            timingLogger(`item ${resolvedSeedLocalId} loadOrCreateItem ${totalMs}ms: seed ${seedMs}, versions ${versionsMs}, metadata ${metadataMs}, ${propertyInstances.size} property instances ${totalMs - seedMs - versionsMs - metadataMs}`);
+        }
         // Step 5: Return loaded item data with property instances
         sendBack({
             type: 'loadOrCreateItemSuccess',
@@ -1349,6 +1331,10 @@ function registerOutboxApplier(kind, applier) {
             appliers.delete(kind);
     };
 }
+/** Bumped before every append in this tab, so a pending-value read begun earlier isn't reused after it. */
+let appendGeneration = 0;
+/** How many appends this tab has started; see getPendingSetValue. */
+const outboxAppendGeneration = () => appendGeneration;
 /**
  * Appends one op, or several that apply together (they share a new group id unless they carry
  * one), and tells the leader to drain. Returns the op ids in order.
@@ -1373,6 +1359,7 @@ async function appendOutboxOps(inputs) {
         status: 'pending',
         attempts: 0,
     }));
+    appendGeneration += 1;
     await BaseDb.getAppDb().insert(pendingWrites).values(rows);
     startOutbox();
     if (isLeaderTab())
@@ -1858,11 +1845,33 @@ async function getPendingPropertyRows(seedLocalId, propertyNames) {
     }
     return rows;
 }
+/**
+ * One read of all of a seed's pending rows while it's in flight: an item's properties load together
+ * and would otherwise each send the same query. A caller joins a read only if this tab hasn't
+ * appended an op since it began, so none misses a value assigned before it asked. Each caller still
+ * has the pending rows before it reads the stored row. The test hook sees these reads as reads of
+ * all properties (undefined names).
+ */
+const sharedReads = new Map();
+function sharedPendingPropertyRows(seedLocalId) {
+    const generation = outboxAppendGeneration();
+    const existing = sharedReads.get(seedLocalId);
+    if (existing && existing.generation === generation)
+        return existing.read;
+    const created = { generation, read: getPendingPropertyRows(seedLocalId) };
+    sharedReads.set(seedLocalId, created);
+    const forget = () => {
+        if (sharedReads.get(seedLocalId) === created)
+            sharedReads.delete(seedLocalId);
+    };
+    created.read.then(forget, forget);
+    return created.read;
+}
 /** One property's pending row (see getPendingPropertyRows); undefined when it has none. */
 async function getPendingPropertyRow(seedLocalId, propertyName) {
-    if (!propertyName)
+    if (!propertyName || !seedLocalId)
         return undefined;
-    const rows = await getPendingPropertyRows(seedLocalId, [propertyName]);
+    const rows = await sharedPendingPropertyRows(seedLocalId);
     for (const name of propertyNameVariants(propertyName)) {
         const row = rows.get(name);
         if (row)
@@ -2458,8 +2467,8 @@ const getItemsData = async ({ modelName, modelFileId, schemaName, deleted, inclu
         conditions.push(eq(seeds.type, easName(modelName)));
     }
     if (!modelFileId && schemaName && modelName) {
-        const _mod_5 = await import('./index-s73wD_LC.js');
-        const _ns_5 = _mod_5.bl;
+        const _mod_5 = await import('./index-C0SetTd1.js');
+        const _ns_5 = _mod_5.bn;
         const { resolveModelRecord } = _ns_5;
         modelFileId = (await resolveModelRecord(modelName, { schemaName }))?.schemaFileId ?? undefined;
         if (!modelFileId)
@@ -2686,7 +2695,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
     const { isRelation, propertyValue, propertyName, propertyRecordSchema, populatedFromDb, } = context;
     const _resolveRelatedValue = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-bOwhhJJL.js');
+        const schemaMod = await import('./index-Dp4uyZYx.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -3100,7 +3109,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await import('./SchemaValidationService-BR2ABK2r.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-T5mqnY8q.js');
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
             ? normalizeDataType(String(propertyRecordSchema.refValueType))
@@ -3155,6 +3164,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
             .insert(metadata)
             .values({
             ...metadataValues,
+            // Stamped here: a value carried in metadataValues would otherwise win over the column default.
             createdAt: Date.now(),
             updatedAt: Date.now(),
         })
@@ -3307,8 +3317,8 @@ async function readHtmlBodyFromChildStorageArweave(seedLocalId) {
         /* offline / bad tx id */
     }
     try {
-        const _mod_6 = await import('./index-s73wD_LC.js');
-        const _ns_6 = _mod_6.bn;
+        const _mod_6 = await import('./index-C0SetTd1.js');
+        const _ns_6 = _mod_6.bp;
         const { downloadTransactionIdWithDedupe } = _ns_6;
         await downloadTransactionIdWithDedupe(txId);
         const retryFp = BaseFileManager.getFilesPath('html', `${seedLocalId}.html`);
@@ -3368,7 +3378,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-bOwhhJJL.js');
+        const schemaMod = await import('./index-Dp4uyZYx.js');
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -3416,7 +3426,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
         }
         const stored = rows?.[0] ?? { seedLocalId, seedUid, propertyName };
         const firstRow = pending ? applyPendingRow({ ...stored }, pending) : { ...stored };
-        const _mod_7 = await import('./ClientManager-Bv15o3Oz.js');
+        const _mod_7 = await import('./ClientManager-B1r_8P5Z.js');
         const _ns_7 = _mod_7.Z;
         const { getPropertyConflict } = _ns_7;
         const conflict = await getPropertyConflict(firstRow.seedLocalId ?? seedLocalId, propertyName);
@@ -3643,6 +3653,8 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
         if (!db) {
             throw new Error('Database not available');
         }
+        const timing = timingMarks();
+        const timingLabel = `property ${seedLocalId ?? seedUid} ${propertyName} loadOrCreateProperty`;
         // Use getMetadataLatest subquery pattern to get the latest metadata record for the property
         const metadataLatest = getMetadataLatest({
             seedLocalId: seedLocalId ?? undefined,
@@ -3657,12 +3669,14 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
         // applies between the two reads is then in one of them
         const { applyPendingRow, getPendingPropertyRow, pendingSetValueOf } = await Promise.resolve().then(function () { return pendingValues; });
         const pendingFirst = seedLocalId ? await getPendingPropertyRow(seedLocalId, propertyName) : undefined;
+        timing.mark('pending value');
         const metadataRecords = await db
             .with(metadataLatest)
             .select()
             .from(metadataLatest)
             .where(and(propertyNameWhere, eq(metadataLatest.rowNum, 1)))
             .limit(5);
+        timing.mark('metadata');
         if (metadataRecords.length === 0) {
             // Metadata not found - this is a new property, will be created elsewhere.
             // Still resolve propertyRecordSchema from Model so getSegmentedItemProperties and
@@ -3671,12 +3685,12 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
             const modelNameForNew = context.modelName;
             if (modelNameForNew) {
                 try {
-                    const _mod_8 = await import('./errors-a4Tj6hly.js');
+                    const _mod_8 = await import('./errors-rIWK7gwJ.js');
                     const _ns_8 = _mod_8.i;
                     const { Model } = _ns_8;
                     const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
-                    const _mod_9 = await import('./index-s73wD_LC.js');
-                    const _ns_9 = _mod_9.bl;
+                    const _mod_9 = await import('./index-C0SetTd1.js');
+                    const _ns_9 = _mod_9.bn;
                     const { resolveItemModelFileId } = _ns_9;
                     const normalizedModelName = upperFirst(camelCase(modelNameForNew));
                     const itemModelFileId = await resolveItemModelFileId({
@@ -3737,60 +3751,25 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
         // It ends up in the context below, and later lookups by name (Model.getByName) can't match it.
         const modelName = context.modelName || (metadataRecord.modelType ? upperFirst(camelCase(metadataRecord.modelType)) : undefined);
         // Model names are only unique per schema: pin lookups to the item's own model row.
-        const _mod_10 = await import('./index-s73wD_LC.js');
-        const _ns_10 = _mod_10.bl;
-        const { resolveItemModelFileId, resolveModelRecord } = _ns_10;
+        const _mod_10 = await import('./index-C0SetTd1.js');
+        const _ns_10 = _mod_10.bn;
+        const { resolveItemModelFileId } = _ns_10;
         const modelFileId = await resolveItemModelFileId({
             modelFileId: context.modelFileId,
             seedLocalId: seedLocalId ?? metadataRecord.seedLocalId,
             seedUid: seedUid ?? metadataRecord.seedUid,
             propertyId: metadataRecord.propertyId,
         });
+        timing.mark('model file id');
         if (modelName) {
             try {
                 // Normalize snake_case to PascalCase: "test_post" -> "TestPost" (startCase gives "Test Post" which fails)
                 const normalizedModelName = upperFirst(camelCase(modelName));
-                // Query properties table to get property schema
-                const modelRecord = await resolveModelRecord(normalizedModelName, { modelFileId }, db);
-                const modelRecords = modelRecord ? [modelRecord] : [];
-                if (modelRecords.length > 0 && modelRecords[0].id) {
-                    const propertyRecords = await db
-                        .select()
-                        .from(properties)
-                        .where(and(eq(properties.modelId, modelRecords[0].id), eq(properties.name, propertyName)))
-                        .limit(1);
-                    if (propertyRecords.length > 0) {
-                        const propRecord = propertyRecords[0];
-                        // properties table has refModelId but not refModelName; resolve ref model name when refModelId is set
-                        let refModelName;
-                        if (propRecord.refModelId != null) {
-                            const refModelRows = await db
-                                .select({ name: models.name })
-                                .from(models)
-                                .where(eq(models.id, propRecord.refModelId))
-                                .limit(1);
-                            refModelName = refModelRows[0]?.name ?? undefined;
-                        }
-                        propertyRecordSchema = {
-                            id: propRecord.id,
-                            dataType: propRecord.dataType,
-                            ref: refModelName ?? undefined,
-                            refValueType: propRecord.refValueType || undefined,
-                            storageType: propRecord.storageType || undefined,
-                            localStorageDir: propRecord.localStorageDir || undefined,
-                            filenameSuffix: propRecord.filenameSuffix || undefined,
-                            required: propRecord.required ?? undefined,
-                        };
-                        // Validation rules (enum, pattern, ...) aren't in the properties table
-                        const { resolvePropertyValidationRules } = await import('./propertyValidationRules-DwzrYA7c.js');
-                        const validation = await resolvePropertyValidationRules(normalizedModelName, propertyName, {
-                            modelFileId: modelRecord?.schemaFileId ?? modelFileId,
-                        });
-                        if (validation) {
-                            propertyRecordSchema = { ...propertyRecordSchema, validation };
-                        }
-                    }
-                }
+                // One read for the whole model, shared by the item's other properties loading now
+                const { loadModelPropertyRecordSchemas } = await import('./modelPropertyRecordSchemas-C_lYTzMr.js');
+                const schemas = await loadModelPropertyRecordSchemas(normalizedModelName, modelFileId, db);
+                propertyRecordSchema = schemas.get(propertyName);
+                timing.mark('model schema');
             }
             catch (error) {
                 logger$3(`Error loading propertyRecordSchema from database: ${error}`);
@@ -3800,7 +3779,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
         // Fix 1: Fallback to in-memory Model when DB doesn't have model/properties yet (e.g. runtime-created model)
         if (!propertyRecordSchema && modelName) {
             try {
-                const _mod_11 = await import('./errors-a4Tj6hly.js');
+                const _mod_11 = await import('./errors-rIWK7gwJ.js');
                 const _ns_11 = _mod_11.i;
                 const { Model } = _ns_11;
                 const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
@@ -3971,6 +3950,8 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
             propertyValueOut = parseListPropertyValueFromStorage(propertyValueOut);
             renderValue = propertyValueOut;
         }
+        timing.mark('value');
+        timing.log(timingLabel);
         // Return loaded property data (use propertyName from context to match schema key, e.g. "html" not "htmlId")
         sendBack({
             type: 'loadOrCreatePropertySuccess',
@@ -4115,7 +4096,6 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
                 // 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;
@@ -4148,7 +4128,6 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
             refResolvedValue: refResolvedValue || null,
             refResolvedDisplayValue: refResolvedDisplayValue || null,
             localStorageDir: localStorageDir || null,
-            createdAt: Date.now(),
         });
         return {
             localId: newLocalId,
@@ -4186,7 +4165,6 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
         refResolvedValue: refResolvedValue || null,
         refResolvedDisplayValue: refResolvedDisplayValue || null,
         localStorageDir: localStorageDir || null,
-        createdAt: Date.now(),
     });
     return {
         localId: newLocalId,
@@ -4261,7 +4239,7 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
             const result = await updateItemPropertyValue({ ...props, seedLocalId, propertyName: propertyNameRaw });
             return { skipped: false, result, conflict: null };
         }
-        const { appendOutboxOp, getOutboxOps, outboxOpResult, startItemOutbox, throwItemWriteError, waitForOutboxOp } = await import('./index-BgEwcREa.js');
+        const { appendOutboxOp, getOutboxOps, outboxOpResult, startItemOutbox, throwItemWriteError, waitForOutboxOp } = await import('./index-CJK3F_MK.js');
         startItemOutbox();
         // Checked right before appending (no await in between): ops apply in append order
         if (writeTicket && !writeTicket.isLatest())
@@ -4292,9 +4270,9 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
             return false;
         }
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-bOwhhJJL.js');
+        const schemaMod = await import('./index-Dp4uyZYx.js');
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await import('./SchemaValidationService-BR2ABK2r.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-T5mqnY8q.js');
         const propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -4524,7 +4502,6 @@ const createSeed = async ({ type, seedUid, modelFileId }, options = {}) => {
         type,
         modelFileId: modelFileId ?? null,
         uid: seedUid,
-        createdAt: Date.now(),
         schemaUid: schemaUid || null,
         ...(publisher && { publisher }),
     });
@@ -4554,7 +4531,7 @@ async function writeStorageValue(item, value, ticket) {
     if (!seedLocalId) {
         throw new Error(`No local seed for the item to save ${item.propertyName} to`);
     }
-    const { appendOutboxOp, getOutboxOps, outboxOpResult, startItemOutbox, throwItemWriteError, waitForOutboxOp } = await import('./index-BgEwcREa.js');
+    const { appendOutboxOp, getOutboxOps, outboxOpResult, startItemOutbox, throwItemWriteError, waitForOutboxOp } = await import('./index-CJK3F_MK.js');
     startItemOutbox();
     // Checked right before appending (no await in between): ops apply in append order
     if (ticket && !ticket.isLatest()) {
@@ -5546,11 +5523,11 @@ const getPropertyData = async ({ propertyName, seedLocalId, seedUid, modelName,
     let names = [...getMetadataPropertyNamesForQuery(propertyName)];
     if (modelName) {
         try {
-            const _mod_12 = await import('./errors-a4Tj6hly.js');
+            const _mod_12 = await import('./errors-rIWK7gwJ.js');
             const _ns_12 = _mod_12.i;
             const { Model } = _ns_12;
-            const _mod_13 = await import('./index-s73wD_LC.js');
-            const _ns_13 = _mod_13.bl;
+            const _mod_13 = await import('./index-C0SetTd1.js');
+            const _ns_13 = _mod_13.bn;
             const { resolveItemModelFileId } = _ns_13;
             // Model names are only unique per schema: use the seed's own model when it is recorded.
             const modelFileId = await resolveItemModelFileId({ seedLocalId, seedUid });
@@ -5786,7 +5763,7 @@ const HTML_PROP_SEED_UID_RE = /^0x[a-fA-F0-9]{64}$/;
  */
 const resolvePropertyRecordSchemaFromSchemaData = async (modelName, propertyName, modelType, schemaName) => {
     try {
-        const _mod_14 = await import('./ClientManager-Bv15o3Oz.js');
+        const _mod_14 = await import('./ClientManager-B1r_8P5Z.js');
         const _ns_14 = _mod_14.X;
         const { loadAllSchemasFromDb } = _ns_14;
         const allSchemas = await loadAllSchemasFromDb();
@@ -5840,12 +5817,12 @@ hints = {}) => {
         return undefined;
     }
     try {
-        const _mod_15 = await import('./errors-a4Tj6hly.js');
+        const _mod_15 = await import('./errors-rIWK7gwJ.js');
         const _ns_15 = _mod_15.i;
         const { Model } = _ns_15;
         const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
-        const _mod_16 = await import('./index-s73wD_LC.js');
-        const _ns_16 = _mod_16.bl;
+        const _mod_16 = await import('./index-C0SetTd1.js');
+        const _ns_16 = _mod_16.bn;
         const { resolveItemModelFileId } = _ns_16;
         const modelFileId = await resolveItemModelFileId(hints);
         let model = modelFileId
@@ -6042,7 +6019,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await import('./index-bOwhhJJL.js');
+            const schemaMod = await import('./index-Dp4uyZYx.js');
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -6274,12 +6251,16 @@ class ItemProperty {
                 const propertyNameWhere = propertyNames.length > 1
                     ? or(...propertyNames.map((n) => eq(metadataLatest$1.propertyName, n)))
                     : eq(metadataLatest$1.propertyName, propertyNames[0]);
-                const initialMetadata = await db
-                    .with(metadataLatest$1)
-                    .select()
-                    .from(metadataLatest$1)
-                    .where(and(propertyNameWhere, eq(metadataLatest$1.rowNum, 1)))
-                    .limit(15);
+                // In the browser the feed watch below reads the same row at once, so only Node (no change
+                // feed) reads it here.
+                const initialMetadata = isBrowser
+                    ? []
+                    : await db
+                        .with(metadataLatest$1)
+                        .select()
+                        .from(metadataLatest$1)
+                        .where(and(propertyNameWhere, eq(metadataLatest$1.rowNum, 1)))
+                        .limit(15);
                 if (initialMetadata.length > 0) {
                     const normalizedDataType = normalizeDataType(propertyRecordSchema?.dataType);
                     const normalizedRefValueType = normalizeDataType(propertyRecordSchema?.refValueType);
@@ -6300,9 +6281,8 @@ class ItemProperty {
                         localStorageDir: metaRow.localStorageDir || undefined,
                     });
                 }
-                // Only set up liveQuery subscription in browser environment
+                // Only watch for changes in the browser (the change feed is browser-only)
                 if (isBrowser) {
-                    // Set up liveQuery to watch metadata table for this property
                     // Use proper SQL parameter binding - ensure values are strings, not objects
                     const resolvedSeedUid = seedUid || null;
                     const resolvedSeedLocalId = seedLocalId || null;
@@ -6310,114 +6290,117 @@ class ItemProperty {
                     // Build query with primitive params only (SQLocal bind rejects SQL fragment objects)
                     // ORDER BY spells out METADATA_LATEST_FIRST_ORDER_SQL (compareMetadataRowsLatestFirst) for the same reason
                     const [p0, p1, p2] = propertyNames;
-                    const metadata$ = BaseDb.liveQuery((sql) => {
+                    const metadataQuery = (sql) => {
                         if (resolvedSeedUid) {
                             if (propertyNames.length === 1) {
                                 return sql `
-                    SELECT local_id as localId, uid, property_name as propertyName, property_value as propertyValue, 
-                           version_local_id as versionLocalId, version_uid as versionUid, schema_uid as schemaUid,
-                           ref_resolved_value as refResolvedValue, ref_resolved_display_value as refResolvedDisplayValue, local_storage_dir as localStorageDir
-                    FROM metadata
-                    WHERE seed_uid = ${resolvedSeedUid} AND property_name = ${p0} AND property_name IS NOT NULL
-                    ORDER BY (revoked_at IS NOT NULL), COALESCE(attestation_created_at, created_at) DESC, local_id DESC LIMIT 1
-                  `;
+                  SELECT local_id as localId, uid, property_name as propertyName, property_value as propertyValue, 
+                         version_local_id as versionLocalId, version_uid as versionUid, schema_uid as schemaUid,
+                         ref_resolved_value as refResolvedValue, ref_resolved_display_value as refResolvedDisplayValue, local_storage_dir as localStorageDir
+                  FROM metadata
+                  WHERE seed_uid = ${resolvedSeedUid} AND property_name = ${p0} AND property_name IS NOT NULL
+                  ORDER BY (revoked_at IS NOT NULL), COALESCE(attestation_created_at, created_at) DESC, local_id DESC LIMIT 1
+                `;
                             }
                             if (propertyNames.length === 2) {
                                 return sql `
-                    SELECT local_id as localId, uid, property_name as propertyName, property_value as propertyValue, 
-                           version_local_id as versionLocalId, version_uid as versionUid, schema_uid as schemaUid,
-                           ref_resolved_value as refResolvedValue, ref_resolved_display_value as refResolvedDisplayValue, local_storage_dir as localStorageDir
-                    FROM metadata
-                    WHERE seed_uid = ${resolvedSeedUid} AND (property_name = ${p0} OR property_name = ${p1}) AND property_name IS NOT NULL
-                    ORDER BY (revoked_at IS NOT NULL), COALESCE(attestation_created_at, created_at) DESC, local_id DESC LIMIT 1
-                  `;
+                  SELECT local_id as localId, uid, property_name as propertyName, property_value as propertyValue, 
+                         version_local_id as versionLocalId, version_uid as versionUid, schema_uid as schemaUid,
+                         ref_resolved_value as refResolvedValue, ref_resolved_display_value as refResolvedDisplayValue, local_storage_dir as localStorageDir
+                  FROM metadata
+                  WHERE seed_uid = ${resolvedSeedUid} AND (property_name = ${p0} OR property_name = ${p1}) AND property_name IS NOT NULL
+                  ORDER BY (revoked_at IS NOT NULL), COALESCE(attestation_created_at, created_at) DESC, local_id DESC LIMIT 1
+                `;
                             }
                             if (propertyNames.length >= 3) {
                                 return sql `
-                    SELECT local_id as localId, uid, property_name as propertyName, property_value as propertyValue, 
-                           version_local_id as versionLocalId, version_uid as versionUid, schema_uid as schemaUid,
-                           ref_resolved_value as refResolvedValue, ref_resolved_display_value as refResolvedDisplayValue, local_storage_dir as localStorageDir
-                    FROM metadata
-                    WHERE seed_uid = ${resolvedSeedUid} AND (property_name = ${p0} OR property_name = ${p1} OR property_name = ${p2}) AND property_name IS NOT NULL
-                    ORDER BY (revoked_at IS NOT NULL), COALESCE(attestation_created_at, created_at) DESC, local_id DESC LIMIT 1
-                  `;
+                  SELECT local_id as localId, uid, property_name as propertyName, property_value as propertyValue, 
+                         version_local_id as versionLocalId, version_uid as versionUid, schema_uid as schemaUid,
+                         ref_resolved_value as refResolvedValue, ref_resolved_display_value as refResolvedDisplayValue, local_storage_dir as localStorageDir
+                  FROM metadata
+                  WHERE seed_uid = ${resolvedSeedUid} AND (property_name = ${p0} OR property_name = ${p1} OR property_name = ${p2}) AND property_name IS NOT NULL
+                  ORDER BY (revoked_at IS NOT NULL), COALESCE(attestation_created_at, created_at) DESC, local_id DESC LIMIT 1
+                `;
                             }
                         }
                         else if (resolvedSeedLocalId) {
                             if (propertyNames.length === 1) {
                                 return sql `
-                    SELECT local_id as localId, uid, property_name as propertyName, property_value as propertyValue, 
-                           version_local_id as versionLocalId, version_uid as versionUid, schema_uid as schemaUid,
-                           ref_resolved_value as refResolvedValue, ref_resolved_display_value as refResolvedDisplayValue, local_storage_dir as localStorageDir
-                    FROM metadata
-                    WHERE seed_local_id = ${resolvedSeedLocalId} AND property_name = ${p0} AND property_name IS NOT NULL
-                    ORDER BY (revoked_at IS NOT NULL), COALESCE(attestation_created_at, created_at) DESC, local_id DESC LIMIT 1
-                  `;
+                  SELECT local_id as localId, uid, property_name as propertyName, property_value as propertyValue, 
+                         version_local_id as versionLocalId, version_uid as versionUid, schema_uid as schemaUid,
+                         ref_resolved_value as refResolvedValue, ref_resolved_display_value as refResolvedDisplayValue, local_storage_dir as localStorageDir
+                  FROM metadata
+                  WHERE seed_local_id = ${resolvedSeedLocalId} AND property_name = ${p0} AND property_name IS NOT NULL
+                  ORDER BY (revoked_at IS NOT NULL), COALESCE(attestation_created_at, created_at) DESC, local_id DESC LIMIT 1
+                `;
                             }
                             if (propertyNames.length === 2) {
                                 return sql `
-                    SELECT local_id as localId, uid, property_name as propertyName, property_value as propertyValue, 
-                           version_local_id as versionLocalId, version_uid as versionUid, schema_uid as schemaUid,
-                           ref_resolved_value as refResolvedValue, ref_resolved_display_value as refResolvedDisplayValue, local_storage_dir as localStorageDir
-                    FROM metadata
-                    WHERE seed_local_id = ${resolvedSeedLocalId} AND (property_name = ${p0} OR property_name = ${p1}) AND property_name IS NOT NULL
-                    ORDER BY (revoked_at IS NOT NULL), COALESCE(attestation_created_at, created_at) DESC, local_id DESC LIMIT 1
-                  `;
+                  SELECT local_id as localId, uid, property_name as propertyName, property_value as propertyValue, 
+                         version_local_id as versionLocalId, version_uid as versionUid, schema_uid as schemaUid,
+                         ref_resolved_value as refResolvedValue, ref_resolved_display_value as refResolvedDisplayValue, local_storage_dir as localStorageDir
+                  FROM metadata
+                  WHERE seed_local_id = ${resolvedSeedLocalId} AND (property_name = ${p0} OR property_name = ${p1}) AND property_name IS NOT NULL
+                  ORDER BY (revoked_at IS NOT NULL), COALESCE(attestation_created_at, created_at) DESC, local_id DESC LIMIT 1
+                `;
                             }
                             if (propertyNames.length >= 3) {
                                 return sql `
-                    SELECT local_id as localId, uid, property_name as propertyName, property_value as propertyValue, 
-                           version_local_id as versionLocalId, version_uid as versionUid, schema_uid as schemaUid,
-                           ref_resolved_value as refResolvedValue, ref_resolved_display_value as refResolvedDisplayValue, local_storage_dir as localStorageDir
-                    FROM metadata
-                    WHERE seed_local_id = ${resolvedSeedLocalId} AND (property_name = ${p0} OR property_name = ${p1} OR property_name = ${p2}) AND property_name IS NOT NULL
-                    ORDER BY (revoked_at IS NOT NULL), COALESCE(attestation_created_at, created_at) DESC, local_id DESC LIMIT 1
-                  `;
+                  SELECT local_id as localId, uid, property_name as propertyName, property_value as propertyValue, 
+                         version_local_id as versionLocalId, version_uid as versionUid, schema_uid as schemaUid,
+                         ref_resolved_value as refResolvedValue, ref_resolved_display_value as refResolvedDisplayValue, local_storage_dir as localStorageDir
+                  FROM metadata
+                  WHERE seed_local_id = ${resolvedSeedLocalId} AND (property_name = ${p0} OR property_name = ${p1} OR property_name = ${p2}) AND property_name IS NOT NULL
+                  ORDER BY (revoked_at IS NOT NULL), COALESCE(attestation_created_at, created_at) DESC, local_id DESC LIMIT 1
+                `;
                             }
                         }
                         return sql `SELECT 1 WHERE 1 = 0`;
-                    });
+                    };
                     const instanceState = itemPropertyInstanceState.get(this);
                     if (!instanceState) {
                         logger('[ItemProperty._setupLiveQuerySubscription] Instance state not found');
                         return;
                     }
-                    // Unloaded or destroyed while setup awaited: subscribing now would leak the query.
+                    // Unloaded or destroyed while setup awaited: watching now would leak the watch.
                     if (isActorStopped(this._service))
                         return;
-                    // Subscribe to liveQuery updates
-                    const subscription = metadata$.subscribe({
-                        next: async (metadataRows) => {
-                            if (metadataRows.length === 0)
-                                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',
-                                propertyValue: metaRow.propertyValue,
-                                renderValue: metaRow.propertyValue,
-                                localId: metaRow.localId || undefined,
-                                uid: metaRow.uid || undefined,
-                                versionLocalId: metaRow.versionLocalId || undefined,
-                                versionUid: metaRow.versionUid || undefined,
-                                schemaUid: metaRow.schemaUid || undefined,
-                                refResolvedValue: metaRow.refResolvedValue || undefined,
-                                ...displayValueFromRow(metaRow),
-                                localStorageDir: metaRow.localStorageDir || undefined,
-                            });
-                        },
-                        error: (error) => {
-                            logger(`[ItemProperty._setupLiveQuerySubscription] LiveQuery error: ${error}`);
-                        },
+                    // Re-read on each change to this property's metadata rows (ADR 0020)
+                    const subscription = watchEntityRows({
+                        seedLocalId: resolvedSeedLocalId,
+                        seedUid: resolvedSeedUid,
+                        tables: ['metadata'],
+                        propertyNames,
+                    }, () => queryEntityRows(metadataQuery), (metadataRows) => {
+                        if (metadataRows.length === 0)
+                            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',
+                            propertyValue: metaRow.propertyValue,
+                            renderValue: metaRow.propertyValue,
+                            localId: metaRow.localId || undefined,
+                            uid: metaRow.uid || undefined,
+                            versionLocalId: metaRow.versionLocalId || undefined,
+                            versionUid: metaRow.versionUid || undefined,
+                            schemaUid: metaRow.schemaUid || undefined,
+                            refResolvedValue: metaRow.refResolvedValue || undefined,
+                            ...displayValueFromRow(metaRow),
+                            localStorageDir: metaRow.localStorageDir || undefined,
+                        });
+                    }, {
+                        immediate: true,
+                        onError: (error) => logger(`[ItemProperty._setupLiveQuerySubscription] Metadata read error: ${error}`),
                     });
                     instanceState.liveQuerySubscription = subscription;
                     logger(`[ItemProperty._setupLiveQuerySubscription] LiveQuery subscription set up for propertyName: ${propertyName}`);
@@ -6482,8 +6465,8 @@ class ItemProperty {
             const ctx = this._service.getSnapshot().context;
             let modelFileId;
             try {
-                const _mod_17 = await import('./index-s73wD_LC.js');
-                const _ns_17 = _mod_17.bl;
+                const _mod_17 = await import('./index-C0SetTd1.js');
+                const _ns_17 = _mod_17.bn;
                 const { resolveItemModelFileId } = _ns_17;
                 modelFileId = await resolveItemModelFileId({
                     modelFileId: ctx.modelFileId,
@@ -6833,8 +6816,8 @@ class ItemProperty {
         const propertiesData = await getItemProperties({ seedLocalId, seedUid });
         const instances = [];
         const seenNormalized = new Set();
-        const _mod_18 = await import('./index-s73wD_LC.js');
-        const _ns_18 = _mod_18.bl;
+        const _mod_18 = await import('./index-C0SetTd1.js');
+        const _ns_18 = _mod_18.bn;
         const { resolveItemModelFileId } = _ns_18;
         const itemModelFileId = await resolveItemModelFileId({ seedLocalId, seedUid });
         for (const data of propertiesData) {
@@ -6851,7 +6834,7 @@ class ItemProperty {
             }
             else if (baseName) {
                 try {
-                    const _mod_19 = await import('./errors-a4Tj6hly.js');
+                    const _mod_19 = await import('./errors-rIWK7gwJ.js');
                     const _ns_19 = _mod_19.i;
                     const { Model } = _ns_19;
                     const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
@@ -6868,7 +6851,7 @@ class ItemProperty {
             }
             if (modelName && propertyName) {
                 try {
-                    const _mod_20 = await import('./errors-a4Tj6hly.js');
+                    const _mod_20 = await import('./errors-rIWK7gwJ.js');
                     const _ns_20 = _mod_20.i;
                     const { Model } = _ns_20;
                     const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
@@ -7071,7 +7054,7 @@ class ItemProperty {
         const { seedLocalId, propertyName } = this._getSnapshotContext();
         if (!seedLocalId || !propertyName)
             return;
-        const { appendOutboxOpAndWait, markPropertyConflictsResolved, startItemOutbox, throwItemWriteError } = await import('./index-BgEwcREa.js');
+        const { appendOutboxOpAndWait, markPropertyConflictsResolved, startItemOutbox, throwItemWriteError } = await import('./index-CJK3F_MK.js');
         if (choice === 'remote') {
             startItemOutbox();
             await appendOutboxOpAndWait({
@@ -7318,7 +7301,7 @@ class ItemProperty {
                 if (db && seedLocalId) {
                     // Through the outbox (ADR 0019): after the property's pending edits, which would
                     // otherwise write its rows back
-                    const { appendOutboxOpAndWait, startItemOutbox, throwItemWriteError } = await import('./index-BgEwcREa.js');
+                    const { appendOutboxOpAndWait, startItemOutbox, throwItemWriteError } = await import('./index-CJK3F_MK.js');
                     startItemOutbox();
                     await appendOutboxOpAndWait({
                         seedLocalId,
@@ -7328,7 +7311,7 @@ class ItemProperty {
                     }).catch(throwItemWriteError);
                 }
                 else if (db) {
-                    const _mod_21 = await import('./index-B6hPWSM4.js');
+                    const _mod_21 = await import('./index-CZQrNqvq.js');
                     const _ns_21 = _mod_21.s;
                     const seedSchemaMod = _ns_21;
                     const { metadata } = seedSchemaMod;
@@ -7378,7 +7361,7 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
     }
     const seedType = easName(modelName);
     // Dynamic import to break circular dependency
-    const _mod_22 = await import('./errors-a4Tj6hly.js');
+    const _mod_22 = await import('./errors-rIWK7gwJ.js');
     const _ns_22 = _mod_22.i;
     const modelMod = _ns_22;
     const { Model } = modelMod;
@@ -7434,7 +7417,7 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
             }
             rows.push({ propertyName, propertyValue, propertyRecordSchema, schemaUid: schemaUids.get(propertyName) });
         }
-        const { appendOutboxOpAndWait, startItemOutbox } = await import('./index-BgEwcREa.js');
+        const { appendOutboxOpAndWait, startItemOutbox } = await import('./index-CJK3F_MK.js');
         startItemOutbox();
         const fields = await timed(`${label} seed fields`, () => resolveNewSeedFields(seedType));
         const applied = await timed(`${label} outbox apply`, () => appendOutboxOpAndWait({
@@ -7453,7 +7436,7 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
     }
     catch (error) {
         // Staged values of a create that never got appended (once appended, the op's discard does it)
-        const _mod_23 = await import('./ClientManager-Bv15o3Oz.js');
+        const _mod_23 = await import('./ClientManager-B1r_8P5Z.js');
         const _ns_23 = _mod_23._;
         const { deleteFiles } = _ns_23;
         await deleteFiles(stagedPaths);
@@ -7552,7 +7535,6 @@ const updateSeedUid = async ({ seedLocalId, seedUid, publisher, attestationCreat
         ...(replacesSeedAttestation && { revokedAt: null, attestationRaw: null }),
         ...(shouldSetPublisher && { publisher: normalizedPublisher }),
         ...(attestationCreatedAt != null && { attestationCreatedAt }),
-        updatedAt: Date.now(),
     })
         .where(eq(seeds.localId, seedLocalId));
     // Attested version and property rows recorded before the seed uid was known (a republish records
@@ -7584,7 +7566,7 @@ const getModel = () => {
         // the fragile `import(...).then(n => n.X)` chunk-namespace pattern.
         if (!modelImportPromise) {
             modelImportPromise = (async () => {
-                const _mod_24 = await import('./errors-a4Tj6hly.js');
+                const _mod_24 = await import('./errors-rIWK7gwJ.js');
                 const _ns_24 = _mod_24.i;
                 const mod = _ns_24;
                 ModelClass = mod.Model;
@@ -7723,7 +7705,7 @@ class Item {
          * sync wrote while they were pending (ADR 0019). Each property's is also on `property.conflict`.
          */
         this.conflicts = async () => {
-            const _mod_25 = await import('./ClientManager-Bv15o3Oz.js');
+            const _mod_25 = await import('./ClientManager-B1r_8P5Z.js');
             const _ns_25 = _mod_25.Z;
             const { getItemConflicts } = _ns_25;
             return getItemConflicts(this.seedLocalId);
@@ -7818,14 +7800,14 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const _mod_26 = await import('./getPublishUploads-CaJHy3SL.js');
+            const _mod_26 = await import('./getPublishUploads-DVsDx6Xf.js');
             const _ns_26 = _mod_26.o;
             const getPublishUploadsMod = _ns_26;
             const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this, [], undefined, options);
         };
         this.getPublishPayload = async (uploadedTransactions, options) => {
-            const _mod_27 = await import('./getPublishPayload-C2g5pPD2.js');
+            const _mod_27 = await import('./getPublishPayload-BGl2SaGK.js');
             const _ns_27 = _mod_27.g;
             const getPublishPayloadMod = _ns_27;
             const { getPublishPayload } = getPublishPayloadMod;
@@ -8205,15 +8187,16 @@ class Item {
      * child ItemProperty actors are still hydrating. useItems / Item.all must not return that shell.
      */
     static async waitForItemInstanceReadyForRead(item, readyTimeout) {
-        await waitForEntityIdle(item, { timeout: readyTimeout });
+        const label = `item ${item.seedLocalId ?? item.seedUid}`;
+        await timedDb(`${label} ready: item idle`, () => waitForEntityIdle(item, { timeout: readyTimeout }));
         const svc = item.getService();
         try {
-            await waitFor(svc, (snap) => {
+            await timed(`${label} ready: property instances`, () => waitFor(svc, (snap) => {
                 if ('value' in snap && snap.value === 'error') {
                     throw new Error('Entity failed to load');
                 }
                 return Item.isItemSnapshotReadyForRead(snap);
-            }, { timeout: readyTimeout });
+            }, { timeout: readyTimeout }));
         }
         catch (e) {
             if (e?.message === 'Entity failed to load') {
@@ -8231,10 +8214,10 @@ class Item {
         if (!pis || pis.size === 0) {
             return;
         }
-        await Promise.all([...pis.values()].map((prop) => waitForEntityIdle(prop, {
+        await timedDb(`${label} ready: ${pis.size} properties idle`, () => Promise.all([...pis.values()].map((prop) => waitForEntityIdle(prop, {
             timeout: readyTimeout,
             throwOnError: false,
-        })));
+        }))));
         if (timingLogger.enabled) {
             const notIdle = [...pis.entries()]
                 .filter(([, prop]) => {
@@ -8368,8 +8351,8 @@ 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_28 = await import('./index-s73wD_LC.js');
-            const _ns_28 = _mod_28.bl;
+            const _mod_28 = await import('./index-C0SetTd1.js');
+            const _ns_28 = _mod_28.bn;
             const { resolveModelRecord } = _ns_28;
             const modelRecord = await resolveModelRecord(props.modelName, {
                 modelFileId: props.modelFileId ?? modelInstance?.id,
@@ -8377,7 +8360,7 @@ class Item {
             });
             const modelRecords = modelRecord ? [modelRecord] : [];
             if (!modelRecord) {
-                const _mod_29 = await import('./errors-a4Tj6hly.js');
+                const _mod_29 = await import('./errors-rIWK7gwJ.js');
                 const _ns_29 = _mod_29.j;
                 const { UnknownModelError } = _ns_29;
                 throw new UnknownModelError(props.modelName, schemaName ?? modelInstance?.schemaName);
@@ -8388,11 +8371,11 @@ class Item {
             // Scope the constructor's Model lookup to this model's schema (as getItemData does on reload),
             // so a same-named model cached from another schema can't supply the property set.
             if (modelRecord && !props.schemaName) {
-                const _mod_30 = await import('./index-s73wD_LC.js');
-                const _ns_30 = _mod_30.bk;
+                const _mod_30 = await import('./index-C0SetTd1.js');
+                const _ns_30 = _mod_30.bm;
                 const { modelSchemas } = _ns_30;
-                const _mod_31 = await import('./index-s73wD_LC.js');
-                const _ns_31 = _mod_31.bj;
+                const _mod_31 = await import('./index-C0SetTd1.js');
+                const _ns_31 = _mod_31.bl;
                 const { schemas: schemasTable } = _ns_31;
                 const schemaRows = await db
                     .select({ schemaName: schemasTable.name })
@@ -8495,7 +8478,7 @@ class Item {
             /* best-effort cache cleanup */
         }
         try {
-            const { appendOutboxOpAndWait, deleteFiles, startItemOutbox } = await import('./index-BgEwcREa.js');
+            const { appendOutboxOpAndWait, deleteFiles, startItemOutbox } = await import('./index-CJK3F_MK.js');
             startItemOutbox();
             const applied = await appendOutboxOpAndWait({
                 seedLocalId,
@@ -8518,7 +8501,7 @@ class Item {
         for (const [propertyName, value] of pipelineValues) {
             const property = await this.waitForPropertyInstance(item, propertyName, timeout);
             if (!property) {
-                const _mod_32 = await import('./errors-a4Tj6hly.js');
+                const _mod_32 = await import('./errors-rIWK7gwJ.js');
                 const _ns_32 = _mod_32.j;
                 const { ItemCreateError } = _ns_32;
                 throw new ItemCreateError(`Item.create: property ${item.modelName}.${propertyName} did not load for item ${item.seedLocalId}; value was not saved`, { code: 'property_not_loaded', modelName: item.modelName, property: propertyName, seedLocalId: item.seedLocalId });
@@ -8530,14 +8513,14 @@ class Item {
             }
             catch (error) {
                 if (error instanceof ItemPropertySaveValidationError) {
-                    const _mod_33 = await import('./errors-a4Tj6hly.js');
+                    const _mod_33 = await import('./errors-rIWK7gwJ.js');
                     const _ns_33 = _mod_33.j;
                     const { ItemCreateValidationError } = _ns_33;
                     const created = new ItemCreateValidationError(item.modelName, error.validationErrors.map((e) => ({ property: propertyName, code: e.code, message: e.message })));
                     created.cause = error;
                     throw created;
                 }
-                const _mod_34 = await import('./errors-a4Tj6hly.js');
+                const _mod_34 = await import('./errors-rIWK7gwJ.js');
                 const _ns_34 = _mod_34.j;
                 const { ItemCreateError } = _ns_34;
                 throw new ItemCreateError(`Item.create: failed to save ${item.modelName}.${propertyName} for item ${item.seedLocalId}: ` +
@@ -8617,9 +8600,10 @@ class Item {
      * The ID can be either seedUid or seedLocalId
      * @param id - seedUid or seedLocalId
      * @param modelName - Optional model name for querying
+     * @param idKind - 'localId' when the id was given as a seedLocalId: looked up as one first
      * @returns Item instance or undefined if not found
      */
-    static async createById(id, modelName) {
+    static async createById(id, modelName, idKind) {
         if (!id) {
             return undefined;
         }
@@ -8628,27 +8612,21 @@ class Item {
         if (cached) {
             return cached;
         }
-        // Determine if id is seedUid or seedLocalId by querying database
-        // Try seedUid first, then seedLocalId
-        let itemData = await getItemData({
-            modelName,
-            seedUid: id,
-        });
-        if (!itemData) {
-            // Try as seedLocalId
-            itemData = await getItemData({
-                modelName,
-                seedLocalId: id,
-            });
-        }
+        // Try seedUid first, then seedLocalId; local id first when the caller says it's one (a find by
+        // seedLocalId), which saves the uid lookup. Either way the other is tried if the first misses.
+        const byUid = () => timedDb(`load ${id} item data by uid`, () => getItemData({ modelName, seedUid: id }));
+        const byLocalId = () => timedDb(`load ${id} item data by local id`, () => getItemData({ modelName, seedLocalId: id }));
+        const itemData = idKind === 'localId'
+            ? (await byLocalId()) ?? (await byUid())
+            : (await byUid()) ?? (await byLocalId());
         if (!itemData) {
             return undefined;
         }
         // Item.create() will handle caching the new instance
-        return await Item.create({
+        return await timedDb(`load ${id} Item.create`, () => Item.create({
             ...itemData,
             modelName,
-        });
+        }));
     }
     static async find({ modelName, seedLocalId, seedUid, waitForReady = true, readyTimeout = DEFAULT_READY_TIMEOUT_MS, }) {
         if (!seedLocalId && !seedUid) {
@@ -8661,7 +8639,7 @@ class Item {
         }
         let cached = false;
         try {
-            return await timed(`find ${modelName ?? '?'} ${id}`, () => findEntity({
+            return await timedDb(`find ${modelName ?? '?'} ${id}`, () => findEntity({
                 getById: (id) => {
                     const instance = Item.getById(id) || undefined;
                     cached = instance !== undefined;
@@ -8669,7 +8647,7 @@ class Item {
                 },
                 createById: async (id) => {
                     // Pass modelName to createById if available
-                    return await Item.createById(id, modelName);
+                    return await Item.createById(id, modelName, seedLocalId ? 'localId' : undefined);
                 },
             }, { id }, {
                 waitForReady,
@@ -8710,7 +8688,7 @@ class Item {
         if (!appDb || Item.instanceCache.size === 0) {
             return;
         }
-        const _mod_35 = await import('./index-B6hPWSM4.js');
+        const _mod_35 = await import('./index-CZQrNqvq.js');
         const _ns_35 = _mod_35.s;
         const { metadata } = _ns_35;
         const { eq, and } = await import('drizzle-orm');
@@ -8844,11 +8822,11 @@ class Item {
     }
     /** Throws ItemCreateValidationError for unknown keys and values that break their property's rules. */
     static async assertValidCreateValues(props, propertyNames, dataTypeByPropertyName, skipKeys) {
-        const _mod_36 = await import('./errors-a4Tj6hly.js');
+        const _mod_36 = await import('./errors-rIWK7gwJ.js');
         const _ns_36 = _mod_36.j;
         const { ItemCreateValidationError } = _ns_36;
-        const { getPropertySchema } = await import('./property-mP9mOZ2L.js');
-        const { SchemaValidationService } = await import('./SchemaValidationService-BR2ABK2r.js');
+        const { getPropertySchema } = await import('./property-pcDxNEpy.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-T5mqnY8q.js');
         const validationService = new SchemaValidationService();
         const modelName = props.modelName;
         const known = new Set(propertyNames);
@@ -8885,7 +8863,7 @@ class Item {
                     // Not JSON: validated as given, and rejected as a non-array
                 }
             }
-            const { resolvePropertyValidationRules } = await import('./propertyValidationRules-DwzrYA7c.js');
+            const { resolvePropertyValidationRules } = await import('./propertyValidationRules-BEjN0f3-.js');
             const rules = propertySchema?.validation ??
                 (await resolvePropertyValidationRules(modelName, key, {
                     modelFileId: props.modelFileId,
@@ -9187,6 +9165,7 @@ class Item {
             }
             setupState.subscriptionSetUp = true;
             logger(`[Item._setupLiveQuerySubscription] Setting up liveQuery for seedLocalId: ${seedLocalId}`);
+            const timingStart = timingNow();
             const itemActor = this._service;
             const sendToItemMachine = (event) => {
                 const status = itemActor.getSnapshot().status;
@@ -9196,7 +9175,7 @@ class Item {
                 itemActor.send(event);
             };
             try {
-                const _mod_37 = await import('./index-B6hPWSM4.js');
+                const _mod_37 = await import('./index-CZQrNqvq.js');
                 const _ns_37 = _mod_37.s;
                 const seedSchemaMod = _ns_37;
                 const { seeds, metadata } = seedSchemaMod;
@@ -9239,7 +9218,9 @@ class Item {
                     logger(`[Item._setupLiveQuerySubscription] No version found for seedLocalId: ${seedLocalId}`);
                     return;
                 }
-                if (currentVersionLocalId) {
+                // In the browser the versions liveQuery below emits at once and its handler runs this same
+                // metadata read and property setup, so only Node (no liveQuery) does it here.
+                if (currentVersionLocalId && !isBrowser) {
                     // Query initial metadata records for the latest version
                     const initialMetadata = await db
                         .select()
@@ -9288,174 +9269,178 @@ class Item {
                         latestVersionUid: seedRecord.latestVersionUid,
                     });
                 }
-                // Only set up liveQuery subscription in browser environment
+                // Only watch for changes in the browser (the change feed is browser-only)
                 if (isBrowser) {
-                    // Watch the seed row by local id: its uid changes when an unpublished item is published
-                    // again (a new seed attestation), and a watch on the uid would stop seeing the row.
-                    const seeds$ = BaseDb.liveQuery((sql) => sql `
+                    const seedsQuery = (sql) => sql `
               SELECT local_id as localId, uid, schema_uid as schemaUid, revoked_at as revokedAt, publisher
               FROM seeds
               WHERE local_id = ${watchedSeedLocalId}
-            `);
-                    // Set up liveQuery to watch versions table for this seed
-                    const versions$ = BaseDb.liveQuery((sql) => sql `
+            `;
+                    const versionsQuery = (sql) => sql `
               SELECT local_id as localId, uid, seed_local_id as seedLocalId, revoked_at as revokedAt
               FROM versions
               WHERE seed_local_id = ${watchedSeedLocalId}
               ORDER BY COALESCE(attestation_created_at, created_at) DESC
-            `);
+            `;
                     const instanceState = itemInstanceState.get(this);
                     if (!instanceState) {
                         logger('[Item._setupLiveQuerySubscription] Instance state not found');
                         return;
                     }
-                    // Unloaded or destroyed while setup awaited: subscribing now would leak the query.
+                    // Unloaded or destroyed while setup awaited: watching now would leak the watches.
                     if (isActorStopped(this._service))
                         return;
-                    // Subscribe to seeds updates
-                    const seedsSubscription = seeds$.subscribe({
-                        next: async (seedRows) => {
-                            if (seedRows.length === 0)
-                                return;
-                            const seedRow = seedRows[0];
-                            logger(`[Item._setupLiveQuerySubscription] Seed updated in database`);
-                            // Update context with seed data
-                            const status = itemActor.getSnapshot().status;
-                            if (status === 'stopped' || status === 'done')
-                                return;
-                            // The row still has a uid this item moved away from (a republish set the new seed uid
-                            // on the item; its DB write has not landed): stale, so neither its uid nor its
-                            // revocation applies. Once the row has the item's uid, the DB has caught up.
-                            const rowUid = seedRow.uid?.toLowerCase();
-                            const superseded = supersededSeedUids.get(this._service);
-                            if (rowUid && superseded?.has(rowUid)) {
-                                logger('[Item._setupLiveQuerySubscription] Ignoring seed row with a superseded uid');
-                                return;
-                            }
-                            if (rowUid && rowUid === this._getSnapshotContext().seedUid?.toLowerCase()) {
-                                superseded?.clear();
-                            }
-                            // A new uid written elsewhere (sync, another tab's republish) goes through the tracked
-                            // setter so the instance cache's uid alias follows it. A row without a uid (not yet
-                            // persisted) never clears the item's uid.
-                            if (seedRow.uid && seedRow.uid !== this._getSnapshotContext().seedUid) {
-                                Item.sendTrackedPropertyUpdate(this, 'seedUid', seedRow.uid);
-                            }
+                    // Re-read the seed row and the versions on each change to them (ADR 0020). Both run once
+                    // now too, as the liveQueries' first emissions did: the versions handler adds the
+                    // property instances to the item's context.
+                    const seedsSubscription = watchEntityRows({ seedLocalId: watchedSeedLocalId, tables: ['seeds'] }, () => queryEntityRows(seedsQuery), async (seedRows) => {
+                        if (seedRows.length === 0)
+                            return;
+                        const seedRow = seedRows[0];
+                        logger(`[Item._setupLiveQuerySubscription] Seed updated in database`);
+                        // Update context with seed data
+                        const status = itemActor.getSnapshot().status;
+                        if (status === 'stopped' || status === 'done')
+                            return;
+                        // The row still has a uid this item moved away from (a republish set the new seed uid
+                        // on the item; its DB write has not landed): stale, so neither its uid nor its
+                        // revocation applies. Once the row has the item's uid, the DB has caught up.
+                        const rowUid = seedRow.uid?.toLowerCase();
+                        const superseded = supersededSeedUids.get(this._service);
+                        if (rowUid && superseded?.has(rowUid)) {
+                            logger('[Item._setupLiveQuerySubscription] Ignoring seed row with a superseded uid');
+                            return;
+                        }
+                        if (rowUid && rowUid === this._getSnapshotContext().seedUid?.toLowerCase()) {
+                            superseded?.clear();
+                        }
+                        // A new uid written elsewhere (sync, another tab's republish) goes through the tracked
+                        // setter so the instance cache's uid alias follows it. A row without a uid (not yet
+                        // persisted) never clears the item's uid.
+                        if (seedRow.uid && seedRow.uid !== this._getSnapshotContext().seedUid) {
+                            Item.sendTrackedPropertyUpdate(this, 'seedUid', seedRow.uid);
+                        }
+                        sendToItemMachine({
+                            type: 'updateContext',
+                            seedLocalId: seedRow.localId,
+                            schemaUid: seedRow.schemaUid || undefined,
+                            revokedAt: seedRow.revokedAt ?? undefined,
+                            // claimUnpublishedDrafts (here or in another tab) stamps drafts' publisher.
+                            ...(seedRow.publisher ? { publisher: seedRow.publisher } : {}),
+                        });
+                    }, {
+                        immediate: true,
+                        onError: (error) => logger(`[Item._setupLiveQuerySubscription] Seeds read error: ${error}`),
+                    });
+                    let versionsRuns = 0;
+                    const versionsSubscribedAt = timingNow();
+                    const versionsSubscription = watchEntityRows({ seedLocalId: watchedSeedLocalId, tables: ['versions'] }, () => queryEntityRows(versionsQuery), async (versionRows) => {
+                        const versionsRun = ++versionsRuns;
+                        const runStart = timingNow();
+                        if (versionsRun === 1 && timingLogger.enabled) {
+                            timingLogger(`item ${watchedSeedLocalId} versions read first result ${timingSince(versionsSubscribedAt)}ms after watching, ${timingSince(timingStart)}ms after watch setup began`);
+                        }
+                        if (versionRows.length === 0)
+                            return;
+                        // Get the most recent version that isn't revoked. When every version is revoked (the
+                        // item was unpublished) there is no latest version any more.
+                        const latestVersion = versionRows.find((v) => !isVersionRevoked(v.revokedAt));
+                        if (!latestVersion) {
                             sendToItemMachine({
                                 type: 'updateContext',
-                                seedLocalId: seedRow.localId,
-                                schemaUid: seedRow.schemaUid || undefined,
-                                revokedAt: seedRow.revokedAt ?? undefined,
-                                // claimUnpublishedDrafts (here or in another tab) stamps drafts' publisher.
-                                ...(seedRow.publisher ? { publisher: seedRow.publisher } : {}),
+                                latestVersionLocalId: undefined,
+                                latestVersionUid: undefined,
                             });
-                        },
-                        error: (error) => {
-                            logger(`[Item._setupLiveQuerySubscription] Seeds liveQuery error: ${error}`);
-                        },
-                    });
-                    // Subscribe to versions updates
-                    const versionsSubscription = versions$.subscribe({
-                        next: async (versionRows) => {
-                            if (versionRows.length === 0)
-                                return;
-                            // Get the most recent version that isn't revoked. When every version is revoked (the
-                            // item was unpublished) there is no latest version any more.
-                            const latestVersion = versionRows.find((v) => !isVersionRevoked(v.revokedAt));
-                            if (!latestVersion) {
-                                sendToItemMachine({
-                                    type: 'updateContext',
-                                    latestVersionLocalId: undefined,
-                                    latestVersionUid: undefined,
-                                });
-                                return;
-                            }
-                            const latestVersionLocalId = latestVersion.localId;
-                            logger(`[Item._setupLiveQuerySubscription] Versions updated, latest version: ${latestVersionLocalId}`);
-                            // Query metadata for the latest version
-                            const metadataRows = await db
-                                .select()
-                                .from(metadata)
-                                .where(and(eq(metadata.seedLocalId, watchedSeedLocalId), eq(metadata.versionLocalId, latestVersionLocalId)));
-                            // CRITICAL: Create ItemProperty instances BEFORE updating context
-                            if (metadataRows.length > 0) {
+                            return;
+                        }
+                        const latestVersionLocalId = latestVersion.localId;
+                        logger(`[Item._setupLiveQuerySubscription] Versions updated, latest version: ${latestVersionLocalId}`);
+                        // Query metadata for the latest version
+                        const metadataRows = await db
+                            .select()
+                            .from(metadata)
+                            .where(and(eq(metadata.seedLocalId, watchedSeedLocalId), eq(metadata.versionLocalId, latestVersionLocalId)));
+                        // CRITICAL: Create ItemProperty instances BEFORE updating context
+                        if (metadataRows.length > 0) {
+                            try {
+                                const itemPropertyMod = await Promise.resolve().then(function () { return ItemProperty$1; });
+                                const { ItemProperty } = itemPropertyMod;
+                                const itemModelName = this._service.getSnapshot().context.modelName;
+                                const schemaNameForModel = this._service.getSnapshot().context.schemaName;
+                                let propertySchemas = {};
                                 try {
-                                    const itemPropertyMod = await Promise.resolve().then(function () { return ItemProperty$1; });
-                                    const { ItemProperty } = itemPropertyMod;
-                                    const itemModelName = this._service.getSnapshot().context.modelName;
-                                    const schemaNameForModel = this._service.getSnapshot().context.schemaName;
-                                    let propertySchemas = {};
-                                    try {
-                                        if (itemModelName) {
-                                            const M = getModel();
-                                            const model = M?.resolve(itemModelName, {
-                                                modelFileId: this._service.getSnapshot().context.modelFileId,
-                                                schemaName: schemaNameForModel,
-                                            });
-                                            if (model?.properties?.length) {
-                                                propertySchemas = modelPropertiesToObject(model.properties);
-                                            }
+                                    if (itemModelName) {
+                                        const M = getModel();
+                                        const model = M?.resolve(itemModelName, {
+                                            modelFileId: this._service.getSnapshot().context.modelFileId,
+                                            schemaName: schemaNameForModel,
+                                        });
+                                        if (model?.properties?.length) {
+                                            propertySchemas = modelPropertiesToObject(model.properties);
                                         }
                                     }
-                                    catch {
-                                        // Model not loaded
-                                    }
-                                    const createPromises = metadataRows.map(async (metaRow) => {
-                                        try {
-                                            let propertyName = metaRow.propertyName;
-                                            const listSchemaKey = propertyName &&
-                                                Object.keys(propertySchemas).length > 0 &&
-                                                resolveStorageNameToSchemaName(propertySchemas, propertyName);
-                                            if (listSchemaKey) {
-                                                propertyName = listSchemaKey;
-                                            }
-                                            else {
-                                                const baseName = propertyName?.endsWith('Id') ? propertyName.slice(0, -2) : undefined;
-                                                const refSeedType = metaRow.refSeedType;
-                                                const isRefTypeFromMeta = refSeedType === 'file' || refSeedType === 'image' || refSeedType === 'relation' || refSeedType === 'html';
-                                                if (baseName && (propertySchemas[baseName] || isRefTypeFromMeta)) {
-                                                    propertyName = baseName;
-                                                }
+                                }
+                                catch {
+                                    // Model not loaded
+                                }
+                                const createPromises = metadataRows.map(async (metaRow) => {
+                                    try {
+                                        let propertyName = metaRow.propertyName;
+                                        const listSchemaKey = propertyName &&
+                                            Object.keys(propertySchemas).length > 0 &&
+                                            resolveStorageNameToSchemaName(propertySchemas, propertyName);
+                                        if (listSchemaKey) {
+                                            propertyName = listSchemaKey;
+                                        }
+                                        else {
+                                            const baseName = propertyName?.endsWith('Id') ? propertyName.slice(0, -2) : undefined;
+                                            const refSeedType = metaRow.refSeedType;
+                                            const isRefTypeFromMeta = refSeedType === 'file' || refSeedType === 'image' || refSeedType === 'relation' || refSeedType === 'html';
+                                            if (baseName && (propertySchemas[baseName] || isRefTypeFromMeta)) {
+                                                propertyName = baseName;
                                             }
-                                            const property = await ItemProperty.find({
+                                        }
+                                        const property = await ItemProperty.find({
+                                            propertyName,
+                                            seedLocalId: watchedSeedLocalId,
+                                            seedUid: this._getSnapshotContext().seedUid ?? seedUid,
+                                            modelName: itemModelName,
+                                            hold: false,
+                                        });
+                                        // The item stopped while the lookup ran: it can't take its hold, so nothing would
+                                        if (property && isActorStopped(this._service))
+                                            ItemProperty.unloadUnheldForItem([property.seedLocalId, property.seedUid]);
+                                        if (property) {
+                                            sendToItemMachine({
+                                                type: 'addPropertyInstance',
                                                 propertyName,
-                                                seedLocalId: watchedSeedLocalId,
-                                                seedUid: this._getSnapshotContext().seedUid ?? seedUid,
-                                                modelName: itemModelName,
-                                                hold: false,
+                                                propertyInstance: property,
                                             });
-                                            // The item stopped while the lookup ran: it can't take its hold, so nothing would
-                                            if (property && isActorStopped(this._service))
-                                                ItemProperty.unloadUnheldForItem([property.seedLocalId, property.seedUid]);
-                                            if (property) {
-                                                sendToItemMachine({
-                                                    type: 'addPropertyInstance',
-                                                    propertyName,
-                                                    propertyInstance: property,
-                                                });
-                                                logger(`[Item._setupLiveQuerySubscription] Created/cached ItemProperty instance for propertyName "${propertyName}" from liveQuery`);
-                                            }
-                                        }
-                                        catch (error) {
-                                            logger(`[Item._setupLiveQuerySubscription] Error creating ItemProperty instance: ${error}`);
+                                            logger(`[Item._setupLiveQuerySubscription] Created/cached ItemProperty instance for propertyName "${propertyName}" from liveQuery`);
                                         }
-                                    });
-                                    await Promise.all(createPromises);
-                                }
-                                catch (error) {
-                                    logger(`[Item._setupLiveQuerySubscription] Error importing ItemProperty or creating instances from liveQuery: ${error}`);
+                                    }
+                                    catch (error) {
+                                        logger(`[Item._setupLiveQuerySubscription] Error creating ItemProperty instance: ${error}`);
+                                    }
+                                });
+                                await Promise.all(createPromises);
+                                if (timingLogger.enabled) {
+                                    timingLogger(`item ${watchedSeedLocalId} versions run ${versionsRun}: metadata read + ${metadataRows.length} ItemProperty.find ${timingSince(runStart)}ms`);
                                 }
                             }
-                            // Update context with latest version info
-                            sendToItemMachine({
-                                type: 'updateContext',
-                                latestVersionLocalId,
-                                latestVersionUid: latestVersion.uid || undefined,
-                            });
-                        },
-                        error: (error) => {
-                            logger(`[Item._setupLiveQuerySubscription] Versions liveQuery error: ${error}`);
-                        },
+                            catch (error) {
+                                logger(`[Item._setupLiveQuerySubscription] Error importing ItemProperty or creating instances from liveQuery: ${error}`);
+                            }
+                        }
+                        // Update context with latest version info
+                        sendToItemMachine({
+                            type: 'updateContext',
+                            latestVersionLocalId,
+                            latestVersionUid: latestVersion.uid || undefined,
+                        });
+                    }, {
+                        immediate: true,
+                        onError: (error) => logger(`[Item._setupLiveQuerySubscription] Versions read error: ${error}`),
                     });
                     // Store combined subscription
                     instanceState.liveQuerySubscription = {
@@ -9558,7 +9543,7 @@ class Item {
                     return;
                 }
                 // Through the outbox (ADR 0019): after the item's pending edits, not before them
-                const { appendOutboxOpAndWait, startItemOutbox, throwItemWriteError } = await import('./index-BgEwcREa.js');
+                const { appendOutboxOpAndWait, startItemOutbox, throwItemWriteError } = await import('./index-CJK3F_MK.js');
                 startItemOutbox();
                 await appendOutboxOpAndWait({
                     seedLocalId: context.seedLocalId,
@@ -9586,4 +9571,4 @@ var Item$1 = /*#__PURE__*/Object.freeze({
 });
 
 export { getGetPublisherForNewSeeds as $, assertItemOwned as A, isItemOwned as B, waitForEntityIdle as C, compareMetadataRowsLatestFirst as D, getEasSchemaUidForModel as E, getLatestPublishedVersionRow as F, parseListPropertyValueFromStorage as G, chunkValues as H, Item as I, rowsPerInsert as J, getGetAdditionalSyncAddresses as K, selectInBatches as L, METADATA_LATEST_FIRST_ORDER_SQL as M, isVersionRevoked as N, OUTBOX_DEFER_MS as O, isActorStopped as P, DEFAULT_READY_TIMEOUT_MS as Q, createReactiveProxy as R, sameEntity as S, findEntity as T, forceRemoveFromCaches as U, runDestroyLifecycle as V, isPublishedMetadataRow as W, ClientManagerState as X, MachineIds as Y, PUBLISH_NOT_CONFIGURED_MESSAGE as Z, createNewItem as _, appendOutboxOpAndWait as a, getMetadataLatest as a0, getPublishExecutor as a1, getRevokeExecutor as a2, getUploadExecutor as a3, getVersionData$1 as a4, isLocalUnsealedDraft as a5, isSeedRowOwned as a6, localUnsealedDraftSql as a7, ownedPublisherSql as a8, ownedSeedsSql as a9, pickLatestMetadataRowPerProperty as aa, placeholderUidSql as ab, propertyMachine as ac, publisherInAddressListSql as ad, publisherIsInOwnedSet as ae, setAdditionalSyncAddresses as af, setGetPublisherForNewSeeds as ag, setPublishExecutor as ah, setRevokeExecutor as ai, setUploadExecutor as aj, ActorKeyedState as ak, clearDestroySubscriptions as al, unloadEntity as am, ClientManagerEvents as an, resolvePublisherFromSeedRow as ao, getSeedPublisher as ap, propertyNameVariants as aq, createSeed as ar, createMetadata as as, updateItemPropertyValue as at, getPropertyData$1 as au, Item$1 as av, waitForOutboxOp as b, appendOutboxOp as c, OUTBOX_MAX_ATTEMPTS as d, OUTBOX_PRUNE_AFTER_MS as e, OUTBOX_PRUNE_FAILED_AFTER_MS as f, getOutboxOps as g, OUTBOX_RETRY_DELAYS_MS as h, OutboxOpDeferredError as i, OutboxOpFailedError as j, OutboxOpRejectedError as k, OutboxOpRetryableError as l, appendOutboxOps as m, drainOutbox as n, outboxOpResult as o, getPendingSetValue as p, outboxOpValue as q, pruneOutbox as r, registerOutboxApplier as s, startOutbox as t, writeInBatches as u, getItemData as v, waitForPendingOutboxOps as w, ItemProperty as x, ItemPropertySaveValidationError as y, OwnershipError as z };
-//# sourceMappingURL=Item-tX3kpbj4.js.map
+//# sourceMappingURL=Item-CjTEShfk.js.map