@seedprotocol/sdk 0.7.9-next.1110.g7eb9e57 → 0.7.9-next.1177.ga3e08ed

package/dist/{Item-CjTEShfk.js → Item-0oDoTPhi.js}

@@ -1,13 +1,14 @@
-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 { u as timingNow, v as timingSince, x as timingLogger, y as TAB_ID, o as onTabMessage, c as whenLeaderTab, a as isLeaderTab, k as postTabMessage, f as createSessionObjectUrl, t as timingMarks, z as timed, r as notifyFileSaved, B as revokeSessionObjectUrl, b as watchEntityRows, C as queryEntityRows, D as isSessionObjectUrl, E as timedDb } from './changeFeed-DKdVlUmt.js';
 import { waitFor, fromCallback, setup, assign, stateIn, createActor, isMachineSnapshot } from 'xstate';
-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 { L as BaseDb, v as versions, m as metadata, s as seeds, N as resolveStorageNameToSchemaName, aY as toSchemaPropertyName, i as isDataType, ad as generateId, C as pendingWrites, ak as isSqliteBusyError, J as schemas, p as models, z as modelSchemas, aW as getOwnedAddressesFromDb, a0 as ZERO_BYTES32, aB as normalizeAddressList, ae as normalizeHexAddress, ax as getAddressesForItemsFilter, a2 as INTERNAL_PROPERTY_NAMES, aZ as easSchemaDefinitionForProperty, Q as BaseFileManager, a_ as getStorageTransactionIdForSeedUid, a$ as convertTxIdToImage, a8 as normalizePublisher, a6 as listRelationEasPropertyName, n as normalizeDataType, U as resolveItemModelFileId, b0 as getPropertyIdForSchemaFileId, S as getPropertyIdForModelAndName, aU as getMetadataPropertyNamesForQuery, aw as ensureImageLocal, ap as ImageSize, b1 as downloadTransactionIdWithDedupe, b2 as resolveMetadataRecord, M as ModelPropertyDataTypes, o as modelUids, af as toMetadataPropertyName, b3 as getDataTypeFromString, b4 as getMimeType, V as INTERNAL_STORAGE_MODEL_FILE_IDS, g as normalizePropertyRecordSchema, b5 as listRelationStoragePropertyName, b6 as PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, k as getCorrectId, Z as getItemStorageSubdir, _ as getItemStorageLocalFileName, b7 as toItemPropertyKey, b8 as getAlternatePropertyNameForInstanceLookup, E as properties, a3 as isStorageSeedRef } from './index-Dx_GTdyQ.js';
+import { or, isNull, eq, sql, max, count, and, getTableColumns, 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 { fetchArweaveRawTextAcrossGateways } from '@seedprotocol/arweave';
+import { e as eventEmitter } from './eventBus-7vxTCc3a.js';
 import { modelPropertiesToObject } from './model-oHA3YhOd.js';
 
 /**
@@ -290,11 +291,6 @@ function createReactiveProxy(config) {
     return proxy;
 }
 
-const ENV = (typeof process !== 'undefined' && process.env)
-    ? process.env
-    : (typeof window !== 'undefined' && window.env)
-        ? window.env
-        : {};
 var MachineIds;
 (function (MachineIds) {
     MachineIds["CLIENT_MANAGER"] = "@seedSdk/clientManager";
@@ -307,7 +303,6 @@ var MachineIds;
     MachineIds["MODEL"] = "@seedSdk/model";
     MachineIds["FILE_SYSTEM"] = "@seedSdk/fileSystem";
 })(MachineIds || (MachineIds = {}));
-const { INTERNAL, GLOBAL } = MachineIds;
 var ClientManagerState;
 (function (ClientManagerState) {
     ClientManagerState["UNINITIALIZED"] = "uninitialized";
@@ -335,40 +330,6 @@ var ClientManagerEvents;
     ClientManagerEvents["ADD_MODELS_TO_DB_SUCCESS"] = "addModelsToDbSuccess";
     ClientManagerEvents["PROCESS_SCHEMA_FILES_SUCCESS"] = "processSchemaFilesSuccess";
 })(ClientManagerEvents || (ClientManagerEvents = {}));
-var GlobalState;
-(function (GlobalState) {
-    GlobalState["UNINITIALIZED"] = "uninitialized";
-    GlobalState["INITIALIZING"] = "initializing";
-    GlobalState["INITIALIZED"] = "initialized";
-    GlobalState["PUBLISHING_ITEM"] = "publishingItem";
-    GlobalState["ADDING_MODELS_TO_DB"] = "addingModelsToDb";
-})(GlobalState || (GlobalState = {}));
-const { INITIALIZING, PUBLISHING_ITEM, ADDING_MODELS_TO_DB, } = GlobalState;
-var InternalState;
-(function (InternalState) {
-    InternalState["IDLE"] = "idle";
-    InternalState["INITIALIZING"] = "initializing";
-    InternalState["VALIDATING_INPUT"] = "validatingInput";
-    InternalState["CONFIGURING_FS"] = "configuringFs";
-    InternalState["LOADING_SEED_DB"] = "loadingSeedDb";
-    InternalState["SAVING_CONFIG"] = "savingConfig";
-    InternalState["LOADING_APP_DB"] = "loadingAppDb";
-    InternalState["LOADING_SDK_DB"] = "loadingSdkDb";
-})(InternalState || (InternalState = {}));
-const { VALIDATING_INPUT, CONFIGURING_FS, LOADING_SEED_DB, LOADING_APP_DB } = InternalState;
-/**
- * @deprecated Evaluated once at import and ignores `SeedConfig.eas` / publish chain config.
- * Use `getEasEndpoint()` from `@seedprotocol/eas`.
- */
-ENV.NEXT_PUBLIC_EAS_ENDPOINT ||
-    ENV.EAS_ENDPOINT ||
-    'https://optimism-sepolia.easscan.org/graphql';
-/**
- * @deprecated Use BaseArweaveClient.getHost() instead.
- * This constant is kept for backward compatibility but will be removed in a future version.
- * Migration: import { BaseArweaveClient } from '@/helpers' and use BaseArweaveClient.getHost()
- */
-ENV.NEXT_PUBLIC_ARWEAVE_HOST || 'ar.seedprotocol.io';
 
 const waitForDb$1 = fromCallback(({ sendBack }) => {
     // Usually ready already: polling first cost every new Item 100ms.
@@ -398,8 +359,21 @@ const isVersionRevoked = (revokedAt) => revokedAt != null && revokedAt !== 0;
 const versionNotRevoked = () => or(isNull(versions.revokedAt), eq(versions.revokedAt, 0));
 
 /**
- * Per-seed version aggregates plus the latest version row by (created_at DESC, local_id DESC) via
- * max(created_at) then max(local_id) tie-break.
+ * The order that picks a seed's head version: newest first by attestation time, or by local
+ * creation time for a version that has no attestation yet (ADR 0006: latest = highest
+ * `timeCreated`), then `local_id DESC` so versions that tie still give one answer. Sync inserts a
+ * batch of versions with one `created_at`, so ordering by `created_at` alone leaves them tied.
+ *
+ * Every reader that picks a head version, attested or not, orders by this. Unqualified column
+ * names: use it in queries that read `versions` alone.
+ */
+const LATEST_VERSION_ORDER_SQL = 'COALESCE(attestation_created_at, created_at) DESC, local_id DESC';
+/** {@link LATEST_VERSION_ORDER_SQL} for a Drizzle `orderBy`. */
+const latestVersionOrder = () => sql.raw(LATEST_VERSION_ORDER_SQL);
+
+/**
+ * Per-seed version aggregates plus the latest version row: the first live version by
+ * `LATEST_VERSION_ORDER_SQL`.
  *
  * Revoked versions (`revoked_at` set) are never the latest version and don't count toward
  * `lastVersionPublishedAt`. `versionsCount` and `lastLocalUpdateAt` still cover every version row,
@@ -423,36 +397,35 @@ const getVersionData$1 = () => {
         .select({
         seedLocalId: versions.seedLocalId,
         lastVersionPublishedAt: max(versions.attestationCreatedAt).as('lastVersionPublishedAt'),
-        maxCreatedAt: max(versions.createdAt).as('maxCreatedAt'),
     })
         .from(versions)
         .where(versionNotRevoked())
         .groupBy(versions.seedLocalId));
-    const latestVersionIds = appDb.$with('latest_version_ids').as(appDb
-        .with(liveVersionStats)
+    const rankedLiveVersions = appDb.$with('ranked_live_versions').as(appDb
         .select({
         seedLocalId: versions.seedLocalId,
-        latestVersionLocalId: max(versions.localId).as('latestVersionLocalId'),
+        latestVersionLocalId: sql `${versions.localId}`.as('latestVersionLocalId'),
+        rowNum: sql
+            .raw(`ROW_NUMBER() OVER (PARTITION BY seed_local_id ORDER BY ${LATEST_VERSION_ORDER_SQL})`)
+            .as('rowNum'),
     })
         .from(versions)
-        .innerJoin(liveVersionStats, and(eq(versions.seedLocalId, liveVersionStats.seedLocalId), eq(versions.createdAt, liveVersionStats.maxCreatedAt)))
-        .where(versionNotRevoked())
-        .groupBy(versions.seedLocalId));
+        .where(versionNotRevoked()));
     return appDb.$with('versionData').as(appDb
-        .with(versionStats, liveVersionStats, latestVersionIds)
+        .with(versionStats, liveVersionStats, rankedLiveVersions)
         .select({
         seedLocalId: versionStats.seedLocalId,
         seedUid: versions.seedUid,
         latestVersionUid: versions.uid,
-        latestVersionLocalId: latestVersionIds.latestVersionLocalId,
+        latestVersionLocalId: rankedLiveVersions.latestVersionLocalId,
         versionsCount: versionStats.versionsCount,
         lastVersionPublishedAt: liveVersionStats.lastVersionPublishedAt,
         lastLocalUpdateAt: versionStats.lastLocalUpdateAt,
     })
         .from(versionStats)
         .leftJoin(liveVersionStats, eq(versionStats.seedLocalId, liveVersionStats.seedLocalId))
-        .leftJoin(latestVersionIds, eq(versionStats.seedLocalId, latestVersionIds.seedLocalId))
-        .leftJoin(versions, and(eq(versions.seedLocalId, latestVersionIds.seedLocalId), eq(versions.localId, latestVersionIds.latestVersionLocalId))));
+        .leftJoin(rankedLiveVersions, and(eq(versionStats.seedLocalId, rankedLiveVersions.seedLocalId), eq(rankedLiveVersions.rowNum, 1)))
+        .leftJoin(versions, and(eq(versions.seedLocalId, rankedLiveVersions.seedLocalId), eq(versions.localId, rankedLiveVersions.latestVersionLocalId))));
 };
 
 var versionData = /*#__PURE__*/Object.freeze({
@@ -621,7 +594,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-rIWK7gwJ.js');
+        const _mod_0 = await import('./errors-D1zHAqjr.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)
@@ -639,8 +612,8 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             const schemaNameToTry = schemaName ?? model?.schemaName;
             if (schemaNameToTry) {
                 try {
-                    const _mod_1 = await import('./Schema-CX9CTtho.js');
-                    const _ns_1 = _mod_1.b;
+                    const _mod_1 = await import('./Schema-PFZwG9Nl.js');
+                    const _ns_1 = _mod_1.a;
                     const { Schema } = _ns_1;
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false, hold: false });
                     const schemaContext = schemaInstance.getService().getSnapshot().context;
@@ -655,8 +628,8 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             }
             if (Object.keys(propertySchemas).length === 0) {
                 try {
-                    const _mod_2 = await import('./ClientManager-B1r_8P5Z.js');
-                    const _ns_2 = _mod_2.X;
+                    const _mod_2 = await import('./ClientManager-GZfXErDX.js');
+                    const _ns_2 = _mod_2.S;
                     const { loadAllSchemasFromDb } = _ns_2;
                     const allSchemas = await loadAllSchemasFromDb();
                     for (const { schema: schemaFile } of allSchemas) {
@@ -676,11 +649,11 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             }
             if (Object.keys(propertySchemas).length === 0) {
                 try {
-                    const _mod_3 = await import('./ClientManager-B1r_8P5Z.js');
-                    const _ns_3 = _mod_3.X;
+                    const _mod_3 = await import('./ClientManager-GZfXErDX.js');
+                    const _ns_3 = _mod_3.S;
                     const { listCompleteSchemaFiles } = _ns_3;
-                    const _mod_4 = await import('./index-C0SetTd1.js');
-                    const _ns_4 = _mod_4.bk;
+                    const _mod_4 = await import('./index-Dx_GTdyQ.js');
+                    const _ns_4 = _mod_4.bb;
                     const { BaseFileManager } = _ns_4;
                     const schemaFiles = await listCompleteSchemaFiles();
                     for (const { filePath } of schemaFiles) {
@@ -700,7 +673,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await import('./index-Dp4uyZYx.js');
+                const schemaMod = await import('./index-DJmWkVIK.js');
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
@@ -717,7 +690,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-pcDxNEpy.js');
+        const { normalizePropertyRecordSchema } = await import('./property-BwYtg5Q_.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
@@ -750,7 +723,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-Dp4uyZYx.js');
+                    const schemaMod = await import('./index-DJmWkVIK.js');
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -1031,13 +1004,20 @@ const runPublish = fromCallback(({ sendBack, input: { context, item: itemFromEve
         }
         try {
             // item.publish() sends its own instance; look it up only if startPublish came without one.
-            const item = itemFromEvent ??
-                (await (await Promise.resolve().then(function () { return Item$1; })).Item.find({ seedLocalId }));
+            const loaded = itemFromEvent
+                ? undefined
+                : (await (await Promise.resolve().then(function () { return Item$1; })).Item.find({ seedLocalId }));
+            const item = itemFromEvent ?? loaded;
             if (!item) {
                 sendBack({ type: 'publishError', error: new Error(`Item not found: ${seedLocalId}`) });
                 return;
             }
-            await executor(item, options);
+            try {
+                await executor(item, options);
+            }
+            finally {
+                loaded?.unload();
+            }
             sendBack({ type: 'publishSuccess' });
         }
         catch (error) {
@@ -1253,28 +1233,20 @@ const isPublishedMetadataRow = (row) => isValidEasAttestationUid(row.uid) || row
  *
  * Ops apply in append order (the row id) per item property. A property's run of consecutive
  * value ops (`set`, `storage`) is coalesced: only the newest is applied and the older ones are
- * marked superseded in the same transaction. An op with a `groupId` applies together with the rest of its group.
+ * marked superseded in the same transaction.
  *
  * This module knows nothing about items: appliers are registered per op kind
  * (registerOutboxApplier).
  */
 const logger$9 = debug('seedSdk:outbox');
-/** A failure worth retrying (a file the browser had locked, say). Other errors fail the op at once. */
-class OutboxOpRetryableError extends Error {
-    constructor(message, options) {
-        super(message, options);
-        this.name = 'OutboxOpRetryableError';
-    }
-}
 /** File-system errors that pass (another tab or the OS holding the file). */
 const RETRYABLE_ERROR_NAMES = new Set(['NoModificationAllowedError', 'NotReadableError', 'InvalidStateError']);
 /**
  * Whether an op that failed with `error` may apply later: the database was busy (BaseDb.transaction
- * has already retried for about a second), a file was busy, or the applier said so. Anything else
- * (a broken rule, a missing row, a bug) would fail the same way again.
+ * has already retried for about a second) or a file was busy. Anything else (a broken rule, a
+ * missing row, a bug) would fail the same way again.
  */
-const isRetryable = (error) => error instanceof OutboxOpRetryableError ||
-    isSqliteBusyError(error) ||
+const isRetryable = (error) => isSqliteBusyError(error) ||
     (error instanceof Error && RETRYABLE_ERROR_NAMES.has(error.name));
 /**
  * An op that can't apply yet for a reason that will pass without counting as a failure: an applier's
@@ -1335,43 +1307,28 @@ function registerOutboxApplier(kind, applier) {
 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.
- */
-async function appendOutboxOps(inputs) {
-    if (inputs.length === 0)
-        return [];
-    const groupId = inputs.length > 1 ? generateId() : null;
-    const now = Date.now();
-    const rows = inputs.map((input) => ({
+/** Appends one op and tells the leader to drain. Returns the op id. */
+async function appendOutboxOp(input) {
+    const row = {
         opId: generateId(),
-        groupId: input.groupId ?? groupId,
         seedLocalId: input.seedLocalId,
         propertyName: input.propertyName ?? null,
         kind: input.kind,
         value: input.value === undefined ? null : JSON.stringify(input.value),
-        valueRef: input.valueRef ?? null,
         baseRowId: input.baseRowId ?? null,
-        baseUid: input.baseUid ?? null,
-        createdAt: now,
+        createdAt: Date.now(),
         tabId: TAB_ID,
         status: 'pending',
         attempts: 0,
-    }));
+    };
     appendGeneration += 1;
-    await BaseDb.getAppDb().insert(pendingWrites).values(rows);
+    await BaseDb.getAppDb().insert(pendingWrites).values(row);
     startOutbox();
     if (isLeaderTab())
         scheduleDrain();
     else
         postTabMessage({ type: 'outbox-nudge' });
-    return rows.map((row) => row.opId);
-}
-/** Appends one op; see appendOutboxOps. */
-async function appendOutboxOp(input) {
-    const [opId] = await appendOutboxOps([input]);
-    return opId;
+    return row.opId;
 }
 /**
  * Appends one op and waits until it settles: its applier's result once applied, or `superseded`
@@ -1494,8 +1451,7 @@ const isDue = (op) => (notBefore.get(op.opId) ?? 0) <= Date.now();
  * The units to apply now, oldest first. A property's ops apply in order, so its queue waits
  * behind its oldest pending op, including one waiting for a retry. An op on the seed itself (no
  * property: create, delete) is ordered against all of its seed's ops: it waits for every earlier
- * one, and every later one waits for it. A group waits until none of its ops is behind another op
- * of its property or seed.
+ * one, and every later one waits for it.
  */
 function planUnits(pending) {
     const queues = new Map();
@@ -1504,33 +1460,15 @@ function planUnits(pending) {
         queue.push(op);
         queues.set(keyOf(op), queue);
     }
-    const blockedByOthers = (op) => {
-        const queue = queues.get(keyOf(op));
-        if (queue.slice(0, queue.indexOf(op)).some((earlier) => earlier.groupId !== op.groupId))
-            return true;
-        return blockedBySeed(op);
-    };
-    // Seed-level ordering: an earlier op of the seed this op must wait for (outside its group)
+    // Seed-level ordering: an earlier op of the seed this op must wait for
     const blockedBySeed = (op) => pending.some((earlier) => earlier.id < op.id &&
         earlier.seedLocalId === op.seedLocalId &&
-        (earlier.groupId == null || earlier.groupId !== op.groupId) &&
         (earlier.propertyName == null || op.propertyName == null));
     const units = [];
-    const plannedGroups = new Set();
     for (const queue of queues.values()) {
         const head = queue[0];
         if (!isDue(head))
             continue;
-        if (head.groupId) {
-            if (plannedGroups.has(head.groupId))
-                continue;
-            const members = pending.filter((op) => op.groupId === head.groupId);
-            if (members.some((member) => !isDue(member) || blockedByOthers(member)))
-                continue;
-            plannedGroups.add(head.groupId);
-            units.push({ unit: { groupId: head.groupId }, order: members[0].id });
-            continue;
-        }
         if (blockedBySeed(head))
             continue;
         let end = 0;
@@ -1538,7 +1476,6 @@ function planUnits(pending) {
             // Not across a later seed-level op: the run stops before it
             while (end + 1 < queue.length &&
                 VALUE_KINDS.has(queue[end + 1].kind) &&
-                !queue[end + 1].groupId &&
                 !blockedBySeed(queue[end + 1])) {
                 end++;
             }
@@ -1551,16 +1488,8 @@ function planUnits(pending) {
 class ClaimLostError extends Error {
 }
 async function applyUnit(unit) {
-    const ops = 'groupId' in unit
-        ? await BaseDb.getAppDb()
-            .select()
-            .from(pendingWrites)
-            .where(and(eq(pendingWrites.groupId, unit.groupId), eq(pendingWrites.status, 'pending')))
-            .orderBy(asc(pendingWrites.id))
-        : [unit.op];
-    if (ops.length === 0)
-        return;
-    const superseded = 'groupId' in unit ? [] : unit.superseded;
+    const ops = [unit.op];
+    const superseded = unit.superseded;
     const ids = ops.map((op) => op.opId);
     const supersededIds = superseded.map((op) => op.opId);
     try {
@@ -1995,7 +1924,8 @@ var getSeedData$1 = /*#__PURE__*/Object.freeze({
 });
 
 /**
- * Latest version row for the seed (by createdAt) whose uid is a real EAS attestation id.
+ * Latest version row for the seed (by `LATEST_VERSION_ORDER_SQL`) whose uid is a real EAS
+ * attestation id.
  * Skips legacy 'NULL' / ZERO_BYTES32 placeholders, non-bytes32 strings, and revoked versions
  * (`revoked_at` set): after a full unpublish the seed has no published version.
  */
@@ -2011,7 +1941,7 @@ async function getLatestPublishedVersionRow(seedLocalId) {
     })
         .from(versions)
         .where(and(eq(versions.seedLocalId, seedLocalId), versionNotRevoked()))
-        .orderBy(desc(versions.createdAt), desc(versions.localId));
+        .orderBy(latestVersionOrder());
     for (const vr of vRows) {
         if (vr.uid && isValidEasAttestationUid(vr.uid)) {
             return {
@@ -2118,19 +2048,13 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
             revokedAt: versions.revokedAt,
         })
             .from(versions)
-            .where(eq(versions.seedLocalId, resolvedSeedLocalId));
+            .where(eq(versions.seedLocalId, resolvedSeedLocalId))
+            .orderBy(latestVersionOrder());
         if (allVersions.length > 0) {
             // Revoked versions are never the latest one and don't count as published (same as the
             // getVersionData subquery); versionsCount / lastLocalUpdateAt still cover every row.
             const liveVersions = allVersions.filter((v) => !isVersionRevoked(v.revokedAt));
-            const sorted = [...liveVersions].sort((a, b) => {
-                const ca = a.createdAt ?? 0;
-                const cb = b.createdAt ?? 0;
-                if (cb !== ca)
-                    return cb - ca;
-                return String(b.localId ?? '').localeCompare(String(a.localId ?? ''));
-            });
-            const latest = sorted[0];
+            const latest = liveVersions[0];
             let lastPub = null;
             for (const v of liveVersions) {
                 const t = v.attestationCreatedAt;
@@ -2231,7 +2155,8 @@ const writeInBatches = async (values, write, size = IN_LIST_BATCH) => {
 
 /**
  * One round-trip for list views: for each seed, the same row as {@link getLatestPublishedVersionRow}
- * (newest `created_at` whose `uid` is a valid EAS attestation id and that isn't revoked).
+ * (first by `LATEST_VERSION_ORDER_SQL` whose `uid` is a valid EAS attestation id and that isn't
+ * revoked).
  */
 async function batchLatestPublishedVersionBySeedLocalIds(seedLocalIds) {
     const out = new Map();
@@ -2245,11 +2170,11 @@ async function batchLatestPublishedVersionBySeedLocalIds(seedLocalIds) {
         seedLocalId: versions.seedLocalId,
         localId: versions.localId,
         uid: versions.uid,
-        createdAt: versions.createdAt,
         revokedAt: versions.revokedAt,
     })
         .from(versions)
-        .where(inArray(versions.seedLocalId, chunk)));
+        .where(inArray(versions.seedLocalId, chunk))
+        .orderBy(latestVersionOrder()));
     const bySeed = new Map();
     for (const r of rows) {
         const sid = r.seedLocalId;
@@ -2259,15 +2184,9 @@ async function batchLatestPublishedVersionBySeedLocalIds(seedLocalIds) {
         list.push(r);
         bySeed.set(sid, list);
     }
+    // A seed's rows all come from one chunk, so each list keeps the SQL order.
     for (const [sid, list] of bySeed) {
-        const sorted = [...list].sort((a, b) => {
-            const ca = a.createdAt ?? 0;
-            const cb = b.createdAt ?? 0;
-            if (cb !== ca)
-                return cb - ca;
-            return String(b.localId ?? '').localeCompare(String(a.localId ?? ''));
-        });
-        const hit = sorted.find((r) => r.uid && isValidEasAttestationUid(r.uid) && !isVersionRevoked(r.revokedAt));
+        const hit = list.find((r) => r.uid && isValidEasAttestationUid(r.uid) && !isVersionRevoked(r.revokedAt));
         if (hit?.uid) {
             out.set(sid, { uid: hit.uid, localId: hit.localId ?? null });
         }
@@ -2467,8 +2386,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-C0SetTd1.js');
-        const _ns_5 = _mod_5.bn;
+        const _mod_5 = await import('./index-Dx_GTdyQ.js');
+        const _ns_5 = _mod_5.be;
         const { resolveModelRecord } = _ns_5;
         modelFileId = (await resolveModelRecord(modelName, { schemaName }))?.schemaFileId ?? undefined;
         if (!modelFileId)
@@ -2534,7 +2453,7 @@ const getItemsData = async ({ modelName, modelFileId, schemaName, deleted, inclu
 };
 
 /**
- * The seed's head version row: newest by (created_at DESC, local_id DESC), attested or not, skipping
+ * The seed's head version row: first by `LATEST_VERSION_ORDER_SQL`, attested or not, skipping
  * revoked versions. Null when the seed has no version or every version is revoked (a fully
  * unpublished item). Same choice as `latestVersionLocalId` in the `getVersionData` subquery.
  */
@@ -2551,7 +2470,7 @@ async function getLatestVersionRow(seedLocalId) {
     })
         .from(versions)
         .where(and(eq(versions.seedLocalId, seedLocalId), versionNotRevoked()))
-        .orderBy(desc(versions.createdAt), desc(versions.localId))
+        .orderBy(latestVersionOrder())
         .limit(1);
     return rows[0] ?? null;
 }
@@ -2695,7 +2614,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-Dp4uyZYx.js');
+        const schemaMod = await import('./index-DJmWkVIK.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -3109,7 +3028,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await import('./SchemaValidationService-T5mqnY8q.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-DnGKel4V.js');
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
             ? normalizeDataType(String(propertyRecordSchema.refValueType))
@@ -3317,8 +3236,8 @@ async function readHtmlBodyFromChildStorageArweave(seedLocalId) {
         /* offline / bad tx id */
     }
     try {
-        const _mod_6 = await import('./index-C0SetTd1.js');
-        const _ns_6 = _mod_6.bp;
+        const _mod_6 = await import('./index-Dx_GTdyQ.js');
+        const _ns_6 = _mod_6.bg;
         const { downloadTransactionIdWithDedupe } = _ns_6;
         await downloadTransactionIdWithDedupe(txId);
         const retryFp = BaseFileManager.getFilesPath('html', `${seedLocalId}.html`);
@@ -3378,7 +3297,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-Dp4uyZYx.js');
+        const schemaMod = await import('./index-DJmWkVIK.js');
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -3426,8 +3345,8 @@ 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-B1r_8P5Z.js');
-        const _ns_7 = _mod_7.Z;
+        const _mod_7 = await import('./ClientManager-GZfXErDX.js');
+        const _ns_7 = _mod_7.U;
         const { getPropertyConflict } = _ns_7;
         const conflict = await getPropertyConflict(firstRow.seedLocalId ?? seedLocalId, propertyName);
         const { localId, uid, propertyValue: propertyValueFromDb, seedLocalId: seedLocalIdFromDb, seedUid: seedUidFromDb, schemaUid: schemaUidFromDb, versionLocalId: versionLocalIdFromDb, versionUid: versionUidFromDb, refValueType, } = firstRow;
@@ -3685,12 +3604,12 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
             const modelNameForNew = context.modelName;
             if (modelNameForNew) {
                 try {
-                    const _mod_8 = await import('./errors-rIWK7gwJ.js');
+                    const _mod_8 = await import('./errors-D1zHAqjr.js');
                     const _ns_8 = _mod_8.i;
                     const { Model } = _ns_8;
                     const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
-                    const _mod_9 = await import('./index-C0SetTd1.js');
-                    const _ns_9 = _mod_9.bn;
+                    const _mod_9 = await import('./index-Dx_GTdyQ.js');
+                    const _ns_9 = _mod_9.be;
                     const { resolveItemModelFileId } = _ns_9;
                     const normalizedModelName = upperFirst(camelCase(modelNameForNew));
                     const itemModelFileId = await resolveItemModelFileId({
@@ -3751,8 +3670,8 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
         // It ends up in the context below, and later lookups by name (Model.getByName) can't match it.
         const modelName = context.modelName || (metadataRecord.modelType ? upperFirst(camelCase(metadataRecord.modelType)) : undefined);
         // Model names are only unique per schema: pin lookups to the item's own model row.
-        const _mod_10 = await import('./index-C0SetTd1.js');
-        const _ns_10 = _mod_10.bn;
+        const _mod_10 = await import('./index-Dx_GTdyQ.js');
+        const _ns_10 = _mod_10.be;
         const { resolveItemModelFileId } = _ns_10;
         const modelFileId = await resolveItemModelFileId({
             modelFileId: context.modelFileId,
@@ -3766,7 +3685,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                 // Normalize snake_case to PascalCase: "test_post" -> "TestPost" (startCase gives "Test Post" which fails)
                 const normalizedModelName = upperFirst(camelCase(modelName));
                 // One read for the whole model, shared by the item's other properties loading now
-                const { loadModelPropertyRecordSchemas } = await import('./modelPropertyRecordSchemas-C_lYTzMr.js');
+                const { loadModelPropertyRecordSchemas } = await import('./modelPropertyRecordSchemas-C5lW9aA-.js');
                 const schemas = await loadModelPropertyRecordSchemas(normalizedModelName, modelFileId, db);
                 propertyRecordSchema = schemas.get(propertyName);
                 timing.mark('model schema');
@@ -3779,7 +3698,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-rIWK7gwJ.js');
+                const _mod_11 = await import('./errors-D1zHAqjr.js');
                 const _ns_11 = _mod_11.i;
                 const { Model } = _ns_11;
                 const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
@@ -4239,7 +4158,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-CJK3F_MK.js');
+        const { appendOutboxOp, getOutboxOps, outboxOpResult, startItemOutbox, throwItemWriteError, waitForOutboxOp } = await import('./index-CkYb3wcU.js');
         startItemOutbox();
         // Checked right before appending (no await in between): ops apply in append order
         if (writeTicket && !writeTicket.isLatest())
@@ -4270,9 +4189,9 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
             return false;
         }
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-Dp4uyZYx.js');
+        const schemaMod = await import('./index-DJmWkVIK.js');
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await import('./SchemaValidationService-T5mqnY8q.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-DnGKel4V.js');
         const propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -4531,7 +4450,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-CJK3F_MK.js');
+    const { appendOutboxOp, getOutboxOps, outboxOpResult, startItemOutbox, throwItemWriteError, waitForOutboxOp } = await import('./index-CkYb3wcU.js');
     startItemOutbox();
     // Checked right before appending (no await in between): ops apply in append order
     if (ticket && !ticket.isLatest()) {
@@ -5218,9 +5137,6 @@ const propertyMachine = setup({
         // stateIn return type does not satisfy setup() inference; runtime guard is correct for root state `idle`.
         propertyMachineIsIdle: stateIn('idle'),
     },
-    // actions: {
-    //   updateContext: updateMachineContext,
-    // },
     actors: {
         waitForDb,
         loadOrCreateProperty,
@@ -5523,11 +5439,11 @@ const getPropertyData = async ({ propertyName, seedLocalId, seedUid, modelName,
     let names = [...getMetadataPropertyNamesForQuery(propertyName)];
     if (modelName) {
         try {
-            const _mod_12 = await import('./errors-rIWK7gwJ.js');
+            const _mod_12 = await import('./errors-D1zHAqjr.js');
             const _ns_12 = _mod_12.i;
             const { Model } = _ns_12;
-            const _mod_13 = await import('./index-C0SetTd1.js');
-            const _ns_13 = _mod_13.bn;
+            const _mod_13 = await import('./index-Dx_GTdyQ.js');
+            const _ns_13 = _mod_13.be;
             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 });
@@ -5763,8 +5679,8 @@ 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-B1r_8P5Z.js');
-        const _ns_14 = _mod_14.X;
+        const _mod_14 = await import('./ClientManager-GZfXErDX.js');
+        const _ns_14 = _mod_14.S;
         const { loadAllSchemasFromDb } = _ns_14;
         const allSchemas = await loadAllSchemasFromDb();
         const modelNameAlt = modelType ? upperFirst(camelCase(modelType)) : '';
@@ -5817,12 +5733,12 @@ hints = {}) => {
         return undefined;
     }
     try {
-        const _mod_15 = await import('./errors-rIWK7gwJ.js');
+        const _mod_15 = await import('./errors-D1zHAqjr.js');
         const _ns_15 = _mod_15.i;
         const { Model } = _ns_15;
         const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
-        const _mod_16 = await import('./index-C0SetTd1.js');
-        const _ns_16 = _mod_16.bn;
+        const _mod_16 = await import('./index-Dx_GTdyQ.js');
+        const _ns_16 = _mod_16.be;
         const { resolveItemModelFileId } = _ns_16;
         const modelFileId = await resolveItemModelFileId(hints);
         let model = modelFileId
@@ -6019,7 +5935,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await import('./index-Dp4uyZYx.js');
+            const schemaMod = await import('./index-DJmWkVIK.js');
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -6384,11 +6300,17 @@ class ItemProperty {
                             hasPendingPropertyWrite(propertyWriteKey(context.seedLocalId ?? context.seedUid, context.propertyName))) {
                             return;
                         }
+                        // An ItemStorage row that points at its file holds no content: keep the value shown until
+                        // the pass this update starts reads the file. Taking renderValue from the row showed null
+                        // in between, e.g. when publish moved a legacy verbatim row's content to its file.
+                        const contentInFile = context.propertyRecordSchema?.storageType === 'ItemStorage' &&
+                            metaRow.propertyValue == null &&
+                            !!metaRow.refResolvedValue;
                         // Update context with metadata changes
                         this._service.send({
                             type: 'updateContext',
                             propertyValue: metaRow.propertyValue,
-                            renderValue: metaRow.propertyValue,
+                            ...(contentInFile ? {} : { renderValue: metaRow.propertyValue }),
                             localId: metaRow.localId || undefined,
                             uid: metaRow.uid || undefined,
                             versionLocalId: metaRow.versionLocalId || undefined,
@@ -6465,8 +6387,8 @@ class ItemProperty {
             const ctx = this._service.getSnapshot().context;
             let modelFileId;
             try {
-                const _mod_17 = await import('./index-C0SetTd1.js');
-                const _ns_17 = _mod_17.bn;
+                const _mod_17 = await import('./index-Dx_GTdyQ.js');
+                const _ns_17 = _mod_17.be;
                 const { resolveItemModelFileId } = _ns_17;
                 modelFileId = await resolveItemModelFileId({
                     modelFileId: ctx.modelFileId,
@@ -6816,8 +6738,8 @@ class ItemProperty {
         const propertiesData = await getItemProperties({ seedLocalId, seedUid });
         const instances = [];
         const seenNormalized = new Set();
-        const _mod_18 = await import('./index-C0SetTd1.js');
-        const _ns_18 = _mod_18.bn;
+        const _mod_18 = await import('./index-Dx_GTdyQ.js');
+        const _ns_18 = _mod_18.be;
         const { resolveItemModelFileId } = _ns_18;
         const itemModelFileId = await resolveItemModelFileId({ seedLocalId, seedUid });
         for (const data of propertiesData) {
@@ -6834,7 +6756,7 @@ class ItemProperty {
             }
             else if (baseName) {
                 try {
-                    const _mod_19 = await import('./errors-rIWK7gwJ.js');
+                    const _mod_19 = await import('./errors-D1zHAqjr.js');
                     const _ns_19 = _mod_19.i;
                     const { Model } = _ns_19;
                     const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
@@ -6851,7 +6773,7 @@ class ItemProperty {
             }
             if (modelName && propertyName) {
                 try {
-                    const _mod_20 = await import('./errors-rIWK7gwJ.js');
+                    const _mod_20 = await import('./errors-D1zHAqjr.js');
                     const _ns_20 = _mod_20.i;
                     const { Model } = _ns_20;
                     const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
@@ -7054,7 +6976,7 @@ class ItemProperty {
         const { seedLocalId, propertyName } = this._getSnapshotContext();
         if (!seedLocalId || !propertyName)
             return;
-        const { appendOutboxOpAndWait, markPropertyConflictsResolved, startItemOutbox, throwItemWriteError } = await import('./index-CJK3F_MK.js');
+        const { appendOutboxOpAndWait, markPropertyConflictsResolved, startItemOutbox, throwItemWriteError } = await import('./index-CkYb3wcU.js');
         if (choice === 'remote') {
             startItemOutbox();
             await appendOutboxOpAndWait({
@@ -7301,7 +7223,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-CJK3F_MK.js');
+                    const { appendOutboxOpAndWait, startItemOutbox, throwItemWriteError } = await import('./index-CkYb3wcU.js');
                     startItemOutbox();
                     await appendOutboxOpAndWait({
                         seedLocalId,
@@ -7311,7 +7233,7 @@ class ItemProperty {
                     }).catch(throwItemWriteError);
                 }
                 else if (db) {
-                    const _mod_21 = await import('./index-CZQrNqvq.js');
+                    const _mod_21 = await import('./index-PbnKw2es.js');
                     const _ns_21 = _mod_21.s;
                     const seedSchemaMod = _ns_21;
                     const { metadata } = seedSchemaMod;
@@ -7361,7 +7283,7 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
     }
     const seedType = easName(modelName);
     // Dynamic import to break circular dependency
-    const _mod_22 = await import('./errors-rIWK7gwJ.js');
+    const _mod_22 = await import('./errors-D1zHAqjr.js');
     const _ns_22 = _mod_22.i;
     const modelMod = _ns_22;
     const { Model } = modelMod;
@@ -7417,7 +7339,7 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
             }
             rows.push({ propertyName, propertyValue, propertyRecordSchema, schemaUid: schemaUids.get(propertyName) });
         }
-        const { appendOutboxOpAndWait, startItemOutbox } = await import('./index-CJK3F_MK.js');
+        const { appendOutboxOpAndWait, startItemOutbox } = await import('./index-CkYb3wcU.js');
         startItemOutbox();
         const fields = await timed(`${label} seed fields`, () => resolveNewSeedFields(seedType));
         const applied = await timed(`${label} outbox apply`, () => appendOutboxOpAndWait({
@@ -7436,8 +7358,8 @@ 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-B1r_8P5Z.js');
-        const _ns_23 = _mod_23._;
+        const _mod_23 = await import('./ClientManager-GZfXErDX.js');
+        const _ns_23 = _mod_23.V;
         const { deleteFiles } = _ns_23;
         await deleteFiles(stagedPaths);
         throw error;
@@ -7566,7 +7488,7 @@ const getModel = () => {
         // the fragile `import(...).then(n => n.X)` chunk-namespace pattern.
         if (!modelImportPromise) {
             modelImportPromise = (async () => {
-                const _mod_24 = await import('./errors-rIWK7gwJ.js');
+                const _mod_24 = await import('./errors-D1zHAqjr.js');
                 const _ns_24 = _mod_24.i;
                 const mod = _ns_24;
                 ModelClass = mod.Model;
@@ -7705,8 +7627,8 @@ 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-B1r_8P5Z.js');
-            const _ns_25 = _mod_25.Z;
+            const _mod_25 = await import('./ClientManager-GZfXErDX.js');
+            const _ns_25 = _mod_25.U;
             const { getItemConflicts } = _ns_25;
             return getItemConflicts(this.seedLocalId);
         };
@@ -7800,14 +7722,14 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const _mod_26 = await import('./getPublishUploads-DVsDx6Xf.js');
+            const _mod_26 = await import('./getPublishUploads-BzUIDA2G.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-BGl2SaGK.js');
+            const _mod_27 = await import('./getPublishPayload-DH4rMqXG.js');
             const _ns_27 = _mod_27.g;
             const getPublishPayloadMod = _ns_27;
             const { getPublishPayload } = getPublishPayloadMod;
@@ -8351,8 +8273,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-C0SetTd1.js');
-            const _ns_28 = _mod_28.bn;
+            const _mod_28 = await import('./index-Dx_GTdyQ.js');
+            const _ns_28 = _mod_28.be;
             const { resolveModelRecord } = _ns_28;
             const modelRecord = await resolveModelRecord(props.modelName, {
                 modelFileId: props.modelFileId ?? modelInstance?.id,
@@ -8360,7 +8282,7 @@ class Item {
             });
             const modelRecords = modelRecord ? [modelRecord] : [];
             if (!modelRecord) {
-                const _mod_29 = await import('./errors-rIWK7gwJ.js');
+                const _mod_29 = await import('./errors-D1zHAqjr.js');
                 const _ns_29 = _mod_29.j;
                 const { UnknownModelError } = _ns_29;
                 throw new UnknownModelError(props.modelName, schemaName ?? modelInstance?.schemaName);
@@ -8371,11 +8293,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-C0SetTd1.js');
-                const _ns_30 = _mod_30.bm;
+                const _mod_30 = await import('./index-Dx_GTdyQ.js');
+                const _ns_30 = _mod_30.bd;
                 const { modelSchemas } = _ns_30;
-                const _mod_31 = await import('./index-C0SetTd1.js');
-                const _ns_31 = _mod_31.bl;
+                const _mod_31 = await import('./index-Dx_GTdyQ.js');
+                const _ns_31 = _mod_31.bc;
                 const { schemas: schemasTable } = _ns_31;
                 const schemaRows = await db
                     .select({ schemaName: schemasTable.name })
@@ -8478,7 +8400,7 @@ class Item {
             /* best-effort cache cleanup */
         }
         try {
-            const { appendOutboxOpAndWait, deleteFiles, startItemOutbox } = await import('./index-CJK3F_MK.js');
+            const { appendOutboxOpAndWait, deleteFiles, startItemOutbox } = await import('./index-CkYb3wcU.js');
             startItemOutbox();
             const applied = await appendOutboxOpAndWait({
                 seedLocalId,
@@ -8501,7 +8423,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-rIWK7gwJ.js');
+                const _mod_32 = await import('./errors-D1zHAqjr.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 });
@@ -8513,14 +8435,14 @@ class Item {
             }
             catch (error) {
                 if (error instanceof ItemPropertySaveValidationError) {
-                    const _mod_33 = await import('./errors-rIWK7gwJ.js');
+                    const _mod_33 = await import('./errors-D1zHAqjr.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-rIWK7gwJ.js');
+                const _mod_34 = await import('./errors-D1zHAqjr.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}: ` +
@@ -8688,7 +8610,7 @@ class Item {
         if (!appDb || Item.instanceCache.size === 0) {
             return;
         }
-        const _mod_35 = await import('./index-CZQrNqvq.js');
+        const _mod_35 = await import('./index-PbnKw2es.js');
         const _ns_35 = _mod_35.s;
         const { metadata } = _ns_35;
         const { eq, and } = await import('drizzle-orm');
@@ -8822,11 +8744,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-rIWK7gwJ.js');
+        const _mod_36 = await import('./errors-D1zHAqjr.js');
         const _ns_36 = _mod_36.j;
         const { ItemCreateValidationError } = _ns_36;
-        const { getPropertySchema } = await import('./property-pcDxNEpy.js');
-        const { SchemaValidationService } = await import('./SchemaValidationService-T5mqnY8q.js');
+        const { getPropertySchema } = await import('./property-BwYtg5Q_.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-DnGKel4V.js');
         const validationService = new SchemaValidationService();
         const modelName = props.modelName;
         const known = new Set(propertyNames);
@@ -8863,7 +8785,7 @@ class Item {
                     // Not JSON: validated as given, and rejected as a non-array
                 }
             }
-            const { resolvePropertyValidationRules } = await import('./propertyValidationRules-BEjN0f3-.js');
+            const { resolvePropertyValidationRules } = await import('./propertyValidationRules-CyHdpcPP.js');
             const rules = propertySchema?.validation ??
                 (await resolvePropertyValidationRules(modelName, key, {
                     modelFileId: props.modelFileId,
@@ -9175,7 +9097,7 @@ class Item {
                 itemActor.send(event);
             };
             try {
-                const _mod_37 = await import('./index-CZQrNqvq.js');
+                const _mod_37 = await import('./index-PbnKw2es.js');
                 const _ns_37 = _mod_37.s;
                 const seedSchemaMod = _ns_37;
                 const { seeds, metadata } = seedSchemaMod;
@@ -9272,16 +9194,20 @@ class Item {
                 // Only watch for changes in the browser (the change feed is browser-only)
                 if (isBrowser) {
                     const seedsQuery = (sql) => sql `
-              SELECT local_id as localId, uid, schema_uid as schemaUid, revoked_at as revokedAt, publisher
+              SELECT local_id as localId, uid, schema_uid as schemaUid, revoked_at as revokedAt, publisher,
+                attestation_created_at as attestationCreatedAt
               FROM seeds
               WHERE local_id = ${watchedSeedLocalId}
             `;
-                    const versionsQuery = (sql) => sql `
-              SELECT local_id as localId, uid, seed_local_id as seedLocalId, revoked_at as revokedAt
+                    // The tag binds every interpolation as a parameter, so the order goes in the strings.
+                    const versionsQueryText = [
+                        `SELECT local_id as localId, uid, seed_local_id as seedLocalId, revoked_at as revokedAt,
+                attestation_created_at as attestationCreatedAt
               FROM versions
-              WHERE seed_local_id = ${watchedSeedLocalId}
-              ORDER BY COALESCE(attestation_created_at, created_at) DESC
-            `;
+              WHERE seed_local_id = `,
+                        ` ORDER BY ${LATEST_VERSION_ORDER_SQL}`,
+                    ];
+                    const versionsQuery = (sql) => sql(Object.assign([...versionsQueryText], { raw: versionsQueryText }), watchedSeedLocalId);
                     const instanceState = itemInstanceState.get(this);
                     if (!instanceState) {
                         logger('[Item._setupLiveQuerySubscription] Instance state not found');
@@ -9327,6 +9253,8 @@ class Item {
                             revokedAt: seedRow.revokedAt ?? undefined,
                             // claimUnpublishedDrafts (here or in another tab) stamps drafts' publisher.
                             ...(seedRow.publisher ? { publisher: seedRow.publisher } : {}),
+                            // Written by publish (persistSeedUid) after the item took its uid.
+                            ...(seedRow.attestationCreatedAt ? { attestationCreatedAt: seedRow.attestationCreatedAt } : {}),
                         });
                     }, {
                         immediate: true,
@@ -9350,9 +9278,17 @@ class Item {
                                 type: 'updateContext',
                                 latestVersionLocalId: undefined,
                                 latestVersionUid: undefined,
+                                lastVersionPublishedAt: undefined,
                             });
                             return;
                         }
+                        // As versionData computes it: the newest attestation among the live versions.
+                        let lastVersionPublishedAt;
+                        for (const v of versionRows) {
+                            if (isVersionRevoked(v.revokedAt) || !v.attestationCreatedAt)
+                                continue;
+                            lastVersionPublishedAt = Math.max(lastVersionPublishedAt ?? 0, v.attestationCreatedAt);
+                        }
                         const latestVersionLocalId = latestVersion.localId;
                         logger(`[Item._setupLiveQuerySubscription] Versions updated, latest version: ${latestVersionLocalId}`);
                         // Query metadata for the latest version
@@ -9437,6 +9373,7 @@ class Item {
                             type: 'updateContext',
                             latestVersionLocalId,
                             latestVersionUid: latestVersion.uid || undefined,
+                            lastVersionPublishedAt,
                         });
                     }, {
                         immediate: true,
@@ -9543,7 +9480,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-CJK3F_MK.js');
+                const { appendOutboxOpAndWait, startItemOutbox, throwItemWriteError } = await import('./index-CkYb3wcU.js');
                 startItemOutbox();
                 await appendOutboxOpAndWait({
                     seedLocalId: context.seedLocalId,
@@ -9570,5 +9507,5 @@ var Item$1 = /*#__PURE__*/Object.freeze({
     Item: Item
 });
 
-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-CjTEShfk.js.map
+export { getMetadataLatest as $, getItemData as A, waitForEntityIdle as B, compareMetadataRowsLatestFirst as C, getEasSchemaUidForModel as D, getLatestPublishedVersionRow as E, parseListPropertyValueFromStorage as F, chunkValues as G, rowsPerInsert as H, Item as I, getGetAdditionalSyncAddresses as J, isVersionRevoked as K, isActorStopped as L, METADATA_LATEST_FIRST_ORDER_SQL as M, DEFAULT_READY_TIMEOUT_MS as N, OUTBOX_DEFER_MS as O, createReactiveProxy as P, sameEntity as Q, findEntity as R, forceRemoveFromCaches as S, runDestroyLifecycle as T, latestVersionOrder as U, isPublishedMetadataRow as V, ClientManagerState as W, MachineIds as X, PUBLISH_NOT_CONFIGURED_MESSAGE as Y, createNewItem as Z, getGetPublisherForNewSeeds as _, appendOutboxOpAndWait as a, getPublishExecutor as a0, getRevokeExecutor as a1, getUploadExecutor as a2, getVersionData$1 as a3, isLocalUnsealedDraft as a4, isSeedRowOwned as a5, localUnsealedDraftSql as a6, ownedPublisherSql as a7, ownedSeedsSql as a8, pickLatestMetadataRowPerProperty as a9, placeholderUidSql as aa, propertyMachine as ab, publisherInAddressListSql as ac, publisherIsInOwnedSet as ad, setAdditionalSyncAddresses as ae, setGetPublisherForNewSeeds as af, setPublishExecutor as ag, setRevokeExecutor as ah, setUploadExecutor as ai, ActorKeyedState as aj, clearDestroySubscriptions as ak, unloadEntity as al, ClientManagerEvents as am, getSeedPublisher as an, propertyNameVariants as ao, createSeed as ap, createMetadata as aq, updateItemPropertyValue as ar, resolvePublisherFromSeedRow as as, getPropertyData$1 as at, Item$1 as au, 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, drainOutbox as l, getPendingSetValue as m, outboxOpValue as n, outboxOpResult as o, pruneOutbox as p, ItemProperty as q, registerOutboxApplier as r, startOutbox as s, ItemPropertySaveValidationError as t, OwnershipError as u, assertItemOwned as v, waitForPendingOutboxOps as w, isItemOwned as x, writeInBatches as y, selectInBatches as z };
+//# sourceMappingURL=Item-0oDoTPhi.js.map