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

package/dist/{Item-oPnmIehk.js → Item-BU9wIT7l.js}

@@ -1,12 +1,13 @@
-import { b0 as PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, n as normalizeDataType, v as INTERNAL_DATA_TYPES, af as MachineIds, O as resolveItemModelFileId, l as resolveModelRecordByNameOrType, A as AmbiguousModelError, m as generateId, b1 as TAB_ID, aN as onTabMessage, ax as whenLeaderTab, ap as isLeaderTab, aM as postTabMessage, j as findSeedRow, b2 as getModelSchemaName, K as selectInBatches, aY as getOwnedAddressesFromDb, Z as ZERO_BYTES32, ar as normalizeAddressList, J as normalizeHexAddress, am as getAddressesForItemsFilter, a0 as INTERNAL_PROPERTY_NAMES, a7 as convertTxIdToImage, i as isDataType, R as getExtensionForMimeType, b3 as normalizeMimeType, aA as sniffMimeType, Y as getItemStorageSubdir, ad as ImageSize, b4 as findFileInDir, b5 as getStorageSubdirForDataType, g as normalizePropertyRecordSchema, h as eventEmitter, b6 as timingMarks, a4 as getPropertyDefinition, aU as tryWithTabLock, b7 as withTabLock, M as ModelPropertyDataTypes, aC as createSessionObjectUrl, U as INTERNAL_STORAGE_MODEL_FILE_IDS, b8 as revokeSessionObjectUrl, b9 as getPropertyDefinitionsByFileId, aw as whenDbReady, ba as timed, av as watchEntityRows, a5 as propertyDefinitionFromRow, bb as isSessionObjectUrl, a6 as addCachedPropertyRefresher, x as normalizePublisher, _ as getItemStorageLocalFileName, bc as timingNow, bd as timingSince, be as timingLogger, bf as timedDb } from './tabEvents-DT5ez6io.js';
-import { fromCallback, setup, assign, and as and$1, stateIn, createActor, waitFor, isMachineSnapshot } from 'xstate';
+import { Z as ZERO_BYTES32, ad as PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, n as normalizeDataType, m as INTERNAL_DATA_TYPES, M as ModelPropertyDataTypes, g as normalizePropertyRecordSchema, k as generateId, ae as TAB_ID, a3 as onTabMessage, O as whenLeaderTab, H as isLeaderTab, a2 as postTabMessage, r as INTERNAL_PROPERTY_NAMES, u as convertTxIdToImage, i as isDataType, aa as getExtensionForMimeType, af as normalizeMimeType, U as sniffMimeType, I as ImageSize, h as eventEmitter, ag as timingMarks, a6 as tryWithTabLock, ah as withTabLock, X as createSessionObjectUrl, ab as INTERNAL_STORAGE_MODEL_FILE_IDS, ai as revokeSessionObjectUrl, aj as timed, N as watchEntityRows, ak as isSessionObjectUrl, al as timingNow, am as timingSince, an as timingLogger, ao as timedDb } from './arweaveContentTags-iW_HcWJA.js';
+import { waitFor, fromCallback, setup, assign, and as and$1, stateIn, createActor, isMachineSnapshot } from 'xstate';
 import debug from 'debug';
 import pluralize from 'pluralize';
-import { easName, isValidEasAttestationUid, isPlaceholderUid, getEasSchemaUidForSchemaDefinition, getSchemaUidForModelFromCache, setSchemaUidForModel, cachedSchemaLookup, getEasModelSchemasForNames, getEasSchemaUidForExactDefinition } from '@seedprotocol/eas';
-import { sql, inArray, or, eq, and, isNull, getTableColumns, asc, lt, isNotNull, max, count, gt, desc, ne } from 'drizzle-orm';
-import { m as metadata, l as properties, B as BaseDb, d as models, p as pendingWrites, x as isSqliteBusyError, v as versions, s as seeds, w as BaseFileManager, b as modelUids, r as publishProcesses, e as arweaveL1FinalizeJobs, h as htmlEmbeddedImageCoPublish } from './BaseFileManager-DLou1TZS.js';
+import { DEFAULT_NAME_MATCH_LEVEL, isNameMatchLevel, compareNameMatchTiers, localNamesInBestMatchTier, easName, isValidEasAttestationUid, isPlaceholderUid, getEasSchemaUidForExactDefinition, getSchemaUidForModelFromCache, setSchemaUidForModel, cachedSchemaLookup, getEasModelSchemasForNames } from '@seedprotocol/eas';
+import { eq, getTableColumns, and, inArray, isNotNull, desc, sql, or, isNull, asc, lt, max, count, gt, ne } from 'drizzle-orm';
+import { B as BaseDb, q as schemas, d as models, j as modelSchemas, v as versions, s as seeds, l as properties, p as pendingWrites, a as appState, m as metadata, t as isSqliteBusyError, r as BaseFileManager, b as modelUids, o as publishProcesses, e as arweaveL1FinalizeJobs, h as htmlEmbeddedImageCoPublish } from './BaseFileManager-D-pLXQAp.js';
 import { BehaviorSubject } from 'rxjs';
 import { orderBy } from 'lodash-es';
+import { alias } from 'drizzle-orm/sqlite-core';
 import { normalizeRelationPropertyValue, resolveSeedIdsFromRefString, BaseArweaveClient } from '@seedprotocol/arweave';
 
 /**
@@ -66,6 +67,663 @@ function differsFromOriginals(originals, next, event, ignore = []) {
     });
 }
 
+var MachineIds;
+(function (MachineIds) {
+    MachineIds["CLIENT_MANAGER"] = "@seedSdk/clientManager";
+    MachineIds["EAS_SYNC_MANAGER"] = "@seedSdk/easSyncManager";
+    MachineIds["GLOBAL"] = "@seedSdk/global";
+    MachineIds["INTERNAL"] = "@seedSdk/internal";
+    MachineIds["EAS"] = "@seedSdk/eas";
+    MachineIds["ITEM"] = "@seedSdk/item";
+    MachineIds["ALL_ITEMS"] = "@seedSdk/allItems";
+    MachineIds["MODEL"] = "@seedSdk/model";
+    MachineIds["FILE_SYSTEM"] = "@seedSdk/fileSystem";
+})(MachineIds || (MachineIds = {}));
+var ClientManagerState;
+(function (ClientManagerState) {
+    ClientManagerState["UNINITIALIZED"] = "uninitialized";
+    ClientManagerState["PLATFORM_CLASSES_INIT"] = "platformClassesInit";
+    ClientManagerState["FILE_SYSTEM_INIT"] = "fileSystemInit";
+    ClientManagerState["DB_INIT"] = "dbInit";
+    ClientManagerState["SAVE_CONFIG"] = "saveConfig";
+    ClientManagerState["ADD_MODELS_TO_DB"] = "addModelsToDb";
+    ClientManagerState["PROCESS_SCHEMA_FILES"] = "processSchemaFiles";
+    ClientManagerState["IDLE"] = "idle";
+    ClientManagerState["INIT_FAILED"] = "initFailed";
+})(ClientManagerState || (ClientManagerState = {}));
+var ClientManagerEvents;
+(function (ClientManagerEvents) {
+    ClientManagerEvents["UPDATE_CONTEXT"] = "updateContext";
+    ClientManagerEvents["SAVE_APP_STATE_SUCCESS"] = "saveAppStateSuccess";
+    ClientManagerEvents["SAVE_APP_STATE_ERROR"] = "saveAppStateError";
+    ClientManagerEvents["SET_ADDRESSES"] = "setAddresses";
+})(ClientManagerEvents || (ClientManagerEvents = {}));
+
+// Set by ClientManager when it loads. Importing it here would pull in most of the SDK, and
+// readiness is read from inside that graph (entity loads, downloads).
+let getClientActor;
+/** @internal ClientManager registers the getter for its current actor (init after stop replaces it). */
+function registerClientActor(getter) {
+    getClientActor = getter;
+}
+// Client states in which the app database is open: dbInit finishes before saveConfig starts.
+const DB_OPEN_STATES = new Set([
+    ClientManagerState.SAVE_CONFIG,
+    ClientManagerState.PROCESS_SCHEMA_FILES,
+    ClientManagerState.ADD_MODELS_TO_DB,
+    ClientManagerState.IDLE,
+]);
+/** Whether a clientManager snapshot is a running client that finished init. */
+function isClientReadySnapshot(snapshot) {
+    return snapshot.status === 'active' && snapshot.value === ClientManagerState.IDLE;
+}
+/**
+ * Whether `client.init` finished and the app database is open. False before init, while it runs,
+ * and after `client.stop()`.
+ */
+function isClientReady() {
+    const actor = getClientActor?.();
+    return !!actor && isClientReadySnapshot(actor.getSnapshot()) && BaseDb.isAppDbReady();
+}
+/**
+ * The app database, once client init has opened it. Waits up to `timeoutMs` for init to get that
+ * far; returns undefined when it doesn't (no init, a failed or stopped client).
+ */
+async function whenDbReady(timeoutMs = 30000) {
+    if (BaseDb.isAppDbReady())
+        return BaseDb.getAppDb();
+    const actor = getClientActor?.();
+    if (!actor)
+        return undefined;
+    try {
+        await waitFor(actor, (snapshot) => DB_OPEN_STATES.has(snapshot.value), {
+            timeout: timeoutMs,
+        });
+    }
+    catch {
+        return undefined;
+    }
+    return BaseDb.isAppDbReady() ? BaseDb.getAppDb() : undefined;
+}
+
+const refreshers = new Set();
+function addCachedPropertyRefresher(fn) {
+    refreshers.add(fn);
+}
+/** Give cached instances of these properties their rows' current definitions. */
+async function refreshCachedProperties(propertyFileIds) {
+    if (propertyFileIds.length === 0)
+        return;
+    for (const refresher of refreshers)
+        await refresher(propertyFileIds);
+}
+
+const level = (value) => (isNameMatchLevel(value) ? value : undefined);
+const tighter = (a, b) => a === undefined || compareNameMatchTiers(b, a) < 0 ? b : a;
+/** The levels in one schema file for one of its models, or undefined when the file lacks the model. */
+const modelLevelsFromFile = (file, modelName) => {
+    const modelDef = file.models?.[modelName];
+    if (!modelDef)
+        return undefined;
+    const model = level(modelDef.nameMatch) ?? level(file.nameMatch) ?? DEFAULT_NAME_MATCH_LEVEL;
+    const properties = new Map();
+    for (const [propertyName, def] of Object.entries(modelDef.properties ?? {})) {
+        properties.set(propertyName, level(def?.nameMatch) ?? model);
+    }
+    return { model, properties };
+};
+/**
+ * Builds NameMatchLevels from the schema files that own each model row. Exported for tests;
+ * use {@link nameMatchLevels}.
+ */
+const nameMatchLevelsFromRows = (rows) => {
+    const byFileId = new Map();
+    const byName = new Map();
+    const parsed = new Map();
+    for (const row of rows) {
+        if (!row.schemaData)
+            continue;
+        if (!parsed.has(row.schemaData)) {
+            try {
+                parsed.set(row.schemaData, JSON.parse(row.schemaData));
+            }
+            catch {
+                parsed.set(row.schemaData, undefined);
+            }
+        }
+        const file = parsed.get(row.schemaData);
+        const levels = file && modelLevelsFromFile(file, row.modelName);
+        if (!levels)
+            continue;
+        if (row.modelFileId)
+            byFileId.set(row.modelFileId, levels);
+        const seen = byName.get(row.modelName);
+        if (!seen) {
+            byName.set(row.modelName, { model: levels.model, properties: new Map(levels.properties) });
+            continue;
+        }
+        seen.model = tighter(seen.model, levels.model);
+        for (const [name, value] of levels.properties)
+            seen.properties.set(name, tighter(seen.properties.get(name), value));
+    }
+    return {
+        model: (modelName) => byName.get(modelName)?.model ?? DEFAULT_NAME_MATCH_LEVEL,
+        property: (modelName, propertyName, modelFileId) => {
+            const levels = (modelFileId ? byFileId.get(modelFileId) : undefined) ?? byName.get(modelName);
+            return levels?.properties.get(propertyName) ?? levels?.model ?? DEFAULT_NAME_MATCH_LEVEL;
+        },
+    };
+};
+const DEFAULT_LEVELS = {
+    model: () => DEFAULT_NAME_MATCH_LEVEL,
+    property: () => DEFAULT_NAME_MATCH_LEVEL,
+};
+let current;
+let loading;
+/** Reads the levels from the schema files stored with each model's schema row (schemas.schema_data). */
+const loadNameMatchLevels = async (db = BaseDb.getAppDb()) => {
+    if (!db)
+        return DEFAULT_LEVELS;
+    const load = (async () => {
+        const rows = (await db
+            .select({ modelName: models.name, modelFileId: models.schemaFileId, schemaData: schemas.schemaData })
+            .from(models)
+            .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
+            .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id)));
+        return nameMatchLevelsFromRows(rows);
+    })();
+    loading = load;
+    try {
+        const levels = await load;
+        if (loading === load) {
+            current = levels;
+            previous = undefined;
+        }
+        return levels;
+    }
+    finally {
+        if (loading === load)
+            loading = undefined;
+    }
+};
+/** The levels, loaded once and reused until a schema write clears them. */
+const nameMatchLevels = async (db = BaseDb.getAppDb()) => current ?? loading ?? loadNameMatchLevels(db);
+/**
+ * The last loaded levels, for synchronous callers (Model.findByModelType). Init loads them before
+ * it reports ready. After a schema write clears them, this returns the levels from before the
+ * write until the reload that clear starts finishes.
+ */
+const currentNameMatchLevels = () => current ?? previous ?? DEFAULT_LEVELS;
+let previous;
+let reloadScheduled = false;
+/**
+ * Called when a schema row or its models are written. The next {@link nameMatchLevels} read
+ * reloads, and a reload starts on the next tick (one per burst of writes) for synchronous callers.
+ */
+const clearNameMatchLevels = () => {
+    if (current)
+        previous = current;
+    current = undefined;
+    loading = undefined;
+    if (reloadScheduled)
+        return;
+    reloadScheduled = true;
+    setTimeout(() => {
+        reloadScheduled = false;
+        if (current || loading || !BaseDb.isAppDbReady())
+            return;
+        loadNameMatchLevels().catch(() => {
+            // The next nameMatchLevels() read retries.
+        });
+    }, 0);
+};
+/**
+ * `nameMatch` values in a schema file that aren't a level. They are ignored (the next level up
+ * applies); schema loads warn about them.
+ */
+const invalidNameMatchValues = (file) => {
+    const problems = [];
+    const check = (where, value) => {
+        if (value !== undefined && !isNameMatchLevel(value)) {
+            problems.push(`${where} nameMatch ${JSON.stringify(value)} is not 'exact', 'normalized' or 'fuzzy'`);
+        }
+    };
+    check('schema', file.nameMatch);
+    for (const [modelName, modelDef] of Object.entries(file.models ?? {})) {
+        check(modelName, modelDef?.nameMatch);
+        for (const [propertyName, def] of Object.entries(modelDef?.properties ?? {})) {
+            check(`${modelName}.${propertyName}`, def?.nameMatch);
+        }
+    }
+    return problems;
+};
+/** Warns about {@link invalidNameMatchValues}. */
+const warnOnInvalidNameMatch = (file) => {
+    const problems = invalidNameMatchValues(file);
+    for (const problem of problems) {
+        console.warn(`[seed] schema ${file.metadata?.name ?? ''}: ${problem}; it is ignored.`);
+    }
+    return problems;
+};
+
+/**
+ * SQLite builds before 3.32 (and builds that keep the old default) allow at most 999 bound
+ * parameters per statement (SQLITE_MAX_VARIABLE_NUMBER). sqlite-wasm and libsql allow 32766, but a
+ * statement that binds one parameter per synced item still has to stay under 999 to work everywhere.
+ */
+const SQLITE_DEFAULT_MAX_VARIABLE_NUMBER = 999;
+/**
+ * Values per `IN (...)` list. Leaves room under {@link SQLITE_DEFAULT_MAX_VARIABLE_NUMBER} for the
+ * statement's other parameters (a second list, `SET` values, other conditions).
+ */
+const IN_LIST_BATCH = 400;
+/**
+ * Rows per multi-row INSERT into `table` so the statement binds at most
+ * {@link SQLITE_DEFAULT_MAX_VARIABLE_NUMBER} parameters even with every column set.
+ */
+const rowsPerInsert = (table) => Math.max(1, Math.floor(SQLITE_DEFAULT_MAX_VARIABLE_NUMBER / Object.keys(getTableColumns(table)).length));
+/** Splits `values` into chunks of at most `size` (one empty list gives no chunks). */
+const chunkValues = (values, size = IN_LIST_BATCH) => {
+    if (!Number.isInteger(size) || size < 1) {
+        throw new Error(`chunkValues: size must be a positive integer, got ${size}`);
+    }
+    const chunks = [];
+    for (let i = 0; i < values.length; i += size) {
+        chunks.push(values.slice(i, i + size));
+    }
+    return chunks;
+};
+/**
+ * Runs `query` once per chunk of `values` (see {@link chunkValues}), one after another, and
+ * concatenates the rows. Use it for `inArray(column, values)` reads whose list can be large.
+ */
+const selectInBatches = async (values, query, size = IN_LIST_BATCH) => {
+    const rows = [];
+    for (const chunk of chunkValues(values, size)) {
+        rows.push(...(await query(chunk)));
+    }
+    return rows;
+};
+/** Runs `write` once per chunk of `values`, one after another (deletes / updates with an `IN` list). */
+const writeInBatches = async (values, write, size = IN_LIST_BATCH) => {
+    for (const chunk of chunkValues(values, size)) {
+        await write(chunk);
+    }
+};
+
+/**
+ * The local seed row for each seed attestation uid. A uid recorded on a seed's versions
+ * (`versions.seed_uid`) belongs to that seed: its current uid, or an old one from before it was
+ * unpublished and published again (the seed row then holds the new uid, the old version rows keep
+ * the old one). A uid no version records resolves by `seeds.uid`. Uids with no local seed are left
+ * out of the map.
+ *
+ * Going through versions first also resolves a republished seed's old uid to the item when an
+ * older sync left a second, version-less seed row with that uid (migration 0024 removes those).
+ */
+const findSeedRowsByUid = async (uids, 
+/** The database or transaction to read; the app database by default. */
+db = BaseDb.getAppDb()) => {
+    const result = new Map();
+    const appDb = db;
+    const wanted = [...new Set(uids.filter(Boolean))];
+    if (!appDb || wanted.length === 0)
+        return result;
+    const owners = await selectInBatches(wanted, (chunk) => appDb
+        .selectDistinct({ seedUid: versions.seedUid, seedLocalId: versions.seedLocalId })
+        .from(versions)
+        .where(and(inArray(versions.seedUid, chunk), isNotNull(versions.seedLocalId))));
+    const ownerLocalIds = [...new Set(owners.map((o) => o.seedLocalId))];
+    const ownerRows = await selectInBatches(ownerLocalIds, (chunk) => appDb.select().from(seeds).where(inArray(seeds.localId, chunk)));
+    const ownerByLocalId = new Map(ownerRows.map((row) => [row.localId, row]));
+    for (const { seedUid, seedLocalId } of owners) {
+        const row = ownerByLocalId.get(seedLocalId);
+        if (!seedUid || !row)
+            continue;
+        // Versions of two seeds recording one uid shouldn't happen; the seed that holds it wins.
+        const current = result.get(seedUid);
+        if (!current || (current.uid !== seedUid && row.uid === seedUid))
+            result.set(seedUid, row);
+    }
+    const rest = wanted.filter((uid) => !result.has(uid));
+    const byUid = await selectInBatches(rest, (chunk) => appDb.select().from(seeds).where(inArray(seeds.uid, chunk)));
+    for (const row of byUid) {
+        if (row.uid && !result.has(row.uid))
+            result.set(row.uid, row);
+    }
+    return result;
+};
+
+/**
+ * The local seed row for an item known by local id, seed uid or both. The local id wins: it names
+ * one row, while a uid can be an old one the seed held before it was unpublished and published
+ * again. A uid (when the local id is absent or matches nothing) resolves as
+ * {@link findSeedRowsByUid} resolves it: the seed whose versions record it (`versions.seed_uid`),
+ * else the row with that `seeds.uid`. The zero uid matches nothing.
+ */
+const findSeedRow = async ({ localId, uid }, 
+/** The database or transaction to read; the app database by default. */
+db = BaseDb.getAppDb()) => {
+    if (!db)
+        return undefined;
+    if (localId) {
+        const [row] = await db.select().from(seeds).where(eq(seeds.localId, localId)).limit(1);
+        if (row?.localId)
+            return row;
+    }
+    if (!uid || uid === ZERO_BYTES32)
+        return undefined;
+    const row = (await findSeedRowsByUid([uid], db)).get(uid);
+    return row?.localId ? row : undefined;
+};
+
+var findSeedRow$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    findSeedRow: findSeedRow
+});
+
+/**
+ * Thrown when a model name exists in more than one schema and nothing says which one is meant.
+ * Model names are only unique within a schema; pass `schemaName` (or `modelFileId`) to choose.
+ */
+class AmbiguousModelError extends Error {
+    constructor(modelName, schemaNames) {
+        const names = [...new Set(schemaNames)].sort();
+        super(`Model "${modelName}" exists in schemas ${names.map((n) => `"${n}"`).join(', ')}; ` +
+            `pass schemaName (or modelFileId) to choose one.`);
+        this.name = 'AmbiguousModelError';
+        this.modelName = modelName;
+        this.schemaNames = names;
+    }
+}
+
+const columns = {
+    id: models.id,
+    name: models.name,
+    schemaFileId: models.schemaFileId,
+};
+/**
+ * Resolve a models row from a model name plus whatever scope is known, most specific first:
+ * modelFileId, modelId, propertyFileId, then schemaId/schemaName + name, then the name alone (not
+ * with `strict` and a schema scope). The name alone is only accepted when it is unambiguous;
+ * otherwise this throws AmbiguousModelError.
+ */
+const resolveModelRecord = async (modelName, scope = {}, db = BaseDb.getAppDb()) => {
+    if (!db)
+        return undefined;
+    if (scope.modelFileId) {
+        const rows = await db
+            .select(columns)
+            .from(models)
+            .where(eq(models.schemaFileId, scope.modelFileId))
+            .limit(1);
+        if (rows.length > 0)
+            return rows[0];
+    }
+    if (scope.modelId) {
+        const rows = await db.select(columns).from(models).where(eq(models.id, scope.modelId)).limit(1);
+        if (rows.length > 0)
+            return rows[0];
+    }
+    if (scope.propertyFileId) {
+        const rows = await db
+            .select(columns)
+            .from(properties)
+            .innerJoin(models, eq(properties.modelId, models.id))
+            .where(eq(properties.schemaFileId, scope.propertyFileId))
+            .limit(1);
+        if (rows.length > 0)
+            return rows[0];
+    }
+    if (!modelName)
+        return undefined;
+    if (scope.schemaId || scope.schemaName) {
+        const rows = await db
+            .select(columns)
+            .from(models)
+            .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
+            .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
+            .where(and(eq(models.name, modelName), scope.schemaId ? eq(schemas.id, scope.schemaId) : eq(schemas.name, scope.schemaName)))
+            .limit(1);
+        if (rows.length > 0)
+            return rows[0];
+        if (scope.strict)
+            return undefined;
+    }
+    return resolveModelRecordByNameOnly(modelName, db);
+};
+/**
+ * Name of the schema a models row is linked to (the newest version's when several are), or
+ * undefined for an unlinked stub.
+ */
+const getModelSchemaName = async (modelId, db = BaseDb.getAppDb()) => {
+    if (!db)
+        return undefined;
+    const rows = await db
+        .select({ schemaName: schemas.name })
+        .from(modelSchemas)
+        .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
+        .where(eq(modelSchemas.modelId, modelId))
+        .orderBy(desc(schemas.version))
+        .limit(1);
+    return rows[0]?.schemaName ?? undefined;
+};
+/** The model a property row (by its schemaFileId) belongs to, and the property's data type. */
+const resolvePropertyModelRecord = async (propertyFileId, db = BaseDb.getAppDb()) => {
+    if (!db || !propertyFileId)
+        return undefined;
+    const rows = await db
+        .select({ ...columns, dataType: properties.dataType })
+        .from(properties)
+        .innerJoin(models, eq(properties.modelId, models.id))
+        .where(eq(properties.schemaFileId, propertyFileId))
+        .limit(1);
+    const row = rows[0];
+    return row ? { id: row.id, name: row.name, schemaFileId: row.schemaFileId, dataType: row.dataType ?? '' } : undefined;
+};
+/**
+ * Name-only resolution. Rows linked to a schema win over unlinked stubs (null-schemaFileId rows
+ * from ref resolution); if more than one linked row has the name it is ambiguous and this throws.
+ * `label` names the lookup in the error (defaults to the model name).
+ */
+const resolveModelRecordByNameOnly = async (modelName, db, label = Array.isArray(modelName) ? modelName.join(', ') : modelName) => {
+    const rows = (await db
+        .select({ ...columns, schemaName: schemas.name })
+        .from(models)
+        .leftJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
+        .leftJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
+        .where(Array.isArray(modelName) ? inArray(models.name, modelName) : eq(models.name, modelName))
+        .orderBy(desc(models.id)));
+    if (rows.length === 0)
+        return undefined;
+    const linked = rows.filter((r) => r.schemaName);
+    const linkedIds = new Set(linked.map((r) => r.id));
+    if (linkedIds.size > 1) {
+        throw new AmbiguousModelError(label, linked.map((r) => r.schemaName));
+    }
+    const chosen = linked[0] ?? rows[0];
+    return { id: chosen.id, name: chosen.name, schemaFileId: chosen.schemaFileId };
+};
+/**
+ * The model names a model name or EAS model type can refer to: the name itself, else the names
+ * that match it in the tightest tier (ADR 0008, as Model.findByModelType matches): `new_model` →
+ * "New model", `sync_storage_post` → "SyncStoragePost", `htmlpage` → "HTMLPage". Each name at its
+ * nameMatch level (ADR 0009).
+ */
+const modelNamesForNameOrType = async (nameOrType, db) => {
+    const rows = (await db.selectDistinct({ name: models.name }).from(models));
+    const names = rows.map((r) => r.name);
+    if (names.includes(nameOrType))
+        return [nameOrType];
+    const levels = await nameMatchLevels(db);
+    return [...localNamesInBestMatchTier(nameOrType, names, { level: (name) => levels.model(name) })];
+};
+/**
+ * resolveModelRecord for a model name **or** an EAS model type (snake_case model name, what sync
+ * stores in seeds.type): "New model" resolves from `new_model`. Scope and ambiguity behave as in
+ * resolveModelRecord: modelFileId/modelId first, then the schema, then the name(s) alone, which throws
+ * AmbiguousModelError when models in several schemas match.
+ */
+const resolveModelRecordByNameOrType = async (nameOrType, scope = {}, db = BaseDb.getAppDb()) => {
+    if (!db)
+        return undefined;
+    if (scope.modelFileId || scope.modelId || scope.propertyFileId) {
+        const byId = await resolveModelRecord(undefined, scope, db);
+        if (byId)
+            return byId;
+    }
+    if (!nameOrType)
+        return undefined;
+    const names = await modelNamesForNameOrType(nameOrType, db);
+    if (names.length === 0)
+        return undefined;
+    if (names.length === 1) {
+        return resolveModelRecord(names[0], { ...scope, modelFileId: undefined, modelId: undefined, propertyFileId: undefined }, db);
+    }
+    // Several model names map to this type (e.g. "New model" and "NewModel" in different schemas).
+    if (scope.schemaId || scope.schemaName) {
+        const rows = (await db
+            .select(columns)
+            .from(models)
+            .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
+            .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
+            .where(and(inArray(models.name, names), scope.schemaId ? eq(schemas.id, scope.schemaId) : eq(schemas.name, scope.schemaName))));
+        if (new Set(rows.map((r) => r.id)).size === 1)
+            return rows[0];
+        if (scope.strict && rows.length === 0)
+            return undefined;
+    }
+    return resolveModelRecordByNameOnly(names, db, nameOrType);
+};
+/**
+ * The model name that a model name or EAS model type (`seeds.type`, `metadata.model_type`) refers
+ * to, resolved as {@link resolveModelRecordByNameOrType} resolves it: `blog_post` → "Blog Post"
+ * through the model's easName at its nameMatch level, never by re-casing the type. Undefined when
+ * no model matches; throws AmbiguousModelError when models in several schemas do.
+ */
+const modelNameForType = async (nameOrType, scope = {}, db = BaseDb.getAppDb()) => (await resolveModelRecordByNameOrType(nameOrType, scope, db))?.name;
+/**
+ * Work out which model (schemaFileId) an item belongs to from whatever is at hand: an explicit
+ * modelFileId, the seed's model_file_id, or a metadata row's property_id → properties.model_id.
+ */
+const resolveItemModelFileId = async (hints, db = BaseDb.getAppDb()) => {
+    if (hints.modelFileId)
+        return hints.modelFileId;
+    if (!db)
+        return undefined;
+    if (hints.seedLocalId || hints.seedUid) {
+        const seed = await findSeedRow({ localId: hints.seedLocalId, uid: hints.seedUid }, db);
+        if (seed?.modelFileId)
+            return seed.modelFileId;
+    }
+    if (hints.propertyId) {
+        const rows = await db
+            .select({ modelFileId: models.schemaFileId })
+            .from(properties)
+            .innerJoin(models, eq(properties.modelId, models.id))
+            .where(eq(properties.id, hints.propertyId))
+            .limit(1);
+        if (rows[0]?.modelFileId)
+            return rows[0].modelFileId;
+    }
+    return undefined;
+};
+/**
+ * Resolve a ref (e.g. a Relation's target model) by name from the schema(s) its owning model belongs
+ * to, so "Tag" means the owner schema's Tag rather than any Tag. Falls back to resolveModelRecord.
+ */
+const resolveRefModelRecord = async (refModelName, owner, db = BaseDb.getAppDb()) => {
+    if (!db || !refModelName)
+        return undefined;
+    const ownerRow = owner.modelFileId || owner.modelId ? await resolveModelRecord(undefined, owner, db) : undefined;
+    const schemaFilter = ownerRow
+        ? inArray(modelSchemas.schemaId, 
+        // any schema the owner is linked to
+        db.select({ schemaId: modelSchemas.schemaId }).from(modelSchemas).where(eq(modelSchemas.modelId, ownerRow.id)))
+        : owner.schemaId
+            ? eq(modelSchemas.schemaId, owner.schemaId)
+            : owner.schemaName
+                ? eq(schemas.name, owner.schemaName)
+                : undefined;
+    if (schemaFilter) {
+        const rows = await db
+            .select(columns)
+            .from(models)
+            .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
+            .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
+            .where(and(eq(models.name, refModelName), schemaFilter))
+            .limit(1);
+        if (rows.length > 0)
+            return rows[0];
+    }
+    return resolveModelRecord(refModelName, {}, db);
+};
+
+var resolveModelRecord$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getModelSchemaName: getModelSchemaName,
+    modelNameForType: modelNameForType,
+    resolveItemModelFileId: resolveItemModelFileId,
+    resolveModelRecord: resolveModelRecord,
+    resolveModelRecordByNameOrType: resolveModelRecordByNameOrType,
+    resolvePropertyModelRecord: resolvePropertyModelRecord,
+    resolveRefModelRecord: resolveRefModelRecord
+});
+
+/**
+ * Lowercase + trim an address for persist and compare.
+ * Does not checksum or validate — test and placeholder addresses must keep working.
+ */
+function normalizeHexAddress(addr) {
+    return addr.trim().toLowerCase();
+}
+/**
+ * Lowercase, drop empties, and dedupe (first-seen order).
+ */
+function normalizeAddressList(addrs) {
+    if (!addrs?.length)
+        return [];
+    const seen = new Set();
+    const out = [];
+    for (const addr of addrs) {
+        if (addr == null || addr === '')
+            continue;
+        const normalized = normalizeHexAddress(String(addr));
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out;
+}
+/**
+ * Lowercase a publisher stamp. Empty / null → undefined (omit on write).
+ */
+function normalizePublisher(publisher) {
+    if (publisher == null || publisher === '')
+        return undefined;
+    const normalized = normalizeHexAddress(publisher);
+    return normalized || undefined;
+}
+/**
+ * Normalizes AddressConfiguration to { owned, watched }.
+ * - string[] -> { owned: addresses, watched: [] }
+ * - { owned, watched? } -> { owned, watched: watched ?? [] }
+ * Addresses are lowercased and deduped.
+ */
+function normalizeAddressConfig(addresses) {
+    if (!addresses) {
+        return { owned: [], watched: [] };
+    }
+    if (Array.isArray(addresses)) {
+        return { owned: normalizeAddressList(addresses), watched: [] };
+    }
+    return {
+        owned: normalizeAddressList(addresses.owned),
+        watched: normalizeAddressList(addresses.watched),
+    };
+}
+
 /** Ref model name when propDef is a List of Relation, else undefined. */
 function listRelationRef(propDef) {
     if (!propDef)
@@ -159,123 +817,1205 @@ function metadataStorageName(key, def) {
     return toMetadataPropertyName(key, def?.dataType, def?.refValueType);
 }
 /**
- * Every name a row of this property may be stored under: its storage name, its key, and for an
- * Image, File, Html or Relation (single or List) `<key>Id`, which older writers and sync used.
+ * Every name a row of this property may be stored under: its storage name, its key, and for an
+ * Image, File, Html or Relation (single or List) `<key>Id`, which older writers and sync used.
+ */
+function metadataStoredNameForms(key, def) {
+    const forms = [metadataStorageName(key, def), key];
+    if (!ID_SUFFIX_EXCLUDE.has(key) && needsMetadataIdSuffix(def?.dataType, def?.refValueType))
+        forms.push(`${key}Id`);
+    return [...new Set(forms)];
+}
+/**
+ * The schema key a stored metadata name belongs to among `defs` (keyed by schema key): an exact key
+ * first, then any of a key's stored forms. Undefined when no property matches. For rows without
+ * `property_id`; rows with one take the key from their properties row.
+ */
+function propertyKeyFromStoredName(defs, storedName) {
+    if (!storedName)
+        return undefined;
+    if (Object.prototype.hasOwnProperty.call(defs, storedName))
+        return storedName;
+    for (const [key, def] of Object.entries(defs)) {
+        if (metadataStoredNameForms(key, def).includes(storedName))
+            return key;
+    }
+    return undefined;
+}
+/**
+ * The names a property's rows may be stored under, for matching rows that have no property_id and
+ * outbox ops (which name a property, not its id): the name with and without its `Id` for an Image,
+ * File, Html or Relation, or when `dataType` is unknown.
+ */
+function getMetadataPropertyNamesForQuery(propertyName, dataType, refValueType) {
+    if (ID_SUFFIX_EXCLUDE.has(propertyName))
+        return [propertyName];
+    if (propertyName.endsWith('Ids'))
+        return [propertyName];
+    if (propertyName.endsWith('Id')) {
+        const base = propertyName.slice(0, -2);
+        return [propertyName, base];
+    }
+    const needsId = needsMetadataIdSuffix(dataType, refValueType) ||
+        (dataType === undefined && refValueType === undefined);
+    if (needsId) {
+        return [propertyName, `${propertyName}Id`];
+    }
+    return [propertyName];
+}
+/**
+ * The name an item exposes a property under, from the name it is stored under: its alias when it
+ * has one (List of relation), else `tagIds` → `tags`, `authorId` → `author`. Names in
+ * PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP keep their `Id`.
+ */
+function toItemPropertyKey(storedName, alias) {
+    if (alias)
+        return alias;
+    if (storedName.endsWith('Ids'))
+        return pluralize(storedName.slice(0, -3));
+    if (storedName.endsWith('Id') && !PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP.has(storedName)) {
+        return storedName.slice(0, -2);
+    }
+    return storedName;
+}
+/**
+ * Schema property name from metadata name (strip Id/Ids suffix).
+ */
+function toSchemaPropertyName(propertyName) {
+    if (propertyName.endsWith('Ids'))
+        return propertyName.slice(0, -3);
+    if (propertyName.endsWith('Id'))
+        return propertyName.slice(0, -2);
+    return undefined;
+}
+/**
+ * Alternate property name for instance lookup (base <-> Id variant).
+ */
+function getAlternatePropertyNameForInstanceLookup(propertyName) {
+    if (ID_SUFFIX_EXCLUDE.has(propertyName))
+        return undefined;
+    if (propertyName.endsWith('Id'))
+        return propertyName.slice(0, -2);
+    return `${propertyName}Id`;
+}
+/**
+ * The EAS property name publish writes for an item property (ADR 0008 §3), already in EAS form:
+ *
+ * - List of relations: its `<name><Model>Ids` storage name (`author_identity_ids`).
+ * - Single Relation, Image, File or Html: its schema key (`author`), never the local `<name>Id`
+ *   storage name. The key is `propertyDef.name` when known, else `propertyName` without its `Id`.
+ * - Anything else: the property name.
+ */
+function easPropertyNameForPublish(propertyName, propertyDef) {
+    const listRelationName = listRelationEasPropertyName(propertyName, propertyDef ?? undefined);
+    if (listRelationName)
+        return easName(listRelationName);
+    if (propertyDef &&
+        normalizeDataType(propertyDef.dataType) !== 'List' &&
+        needsMetadataIdSuffix(propertyDef.dataType, propertyDef.refValueType) &&
+        !ID_SUFFIX_EXCLUDE.has(propertyName)) {
+        const key = propertyDef.name ?? (propertyName.endsWith('Id') ? propertyName.slice(0, -2) : propertyName);
+        return easName(key);
+    }
+    return easName(propertyName);
+}
+/**
+ * The EAS schema definition publish attests a property under (`string title`, `bytes32 author`),
+ * or undefined when its data type has no EAS type. Look schemas up by this, not by name: a name
+ * can have schemas of several types (Optimism Sepolia has `bytes32 storage_transaction_id` beside
+ * `string storage_transaction_id`).
+ */
+function easSchemaDefinitionForProperty(propertyName, propertyDef) {
+    if (!propertyDef?.dataType)
+        return undefined;
+    const dataType = normalizeDataType(String(propertyDef.dataType));
+    const easType = INTERNAL_DATA_TYPES[dataType]?.eas;
+    if (!easType)
+        return undefined;
+    return `${easType} ${easPropertyNameForPublish(propertyName, propertyDef)}`;
+}
+
+/** Schema file spellings that normalizePropertyRecordSchema maps to internal fields. */
+const FILE_ALIAS_KEYS = ['type', 'model', 'items', 'storage'];
+/**
+ * Fields an instance or a row carries that aren't part of the definition. Keys starting with `_`
+ * (`_dbId`, `_propertyFileId`, `_originalValues`, ...) are dropped too.
+ */
+const NON_DEFINITION_KEYS = new Set([
+    ...FILE_ALIAS_KEYS,
+    'name',
+    'modelId',
+    'modelName',
+    'refModelId',
+    'refModelName',
+    'schemaName',
+    'isEdited',
+    'TObject',
+]);
+const parseDefinition = (json) => {
+    if (!json)
+        return {};
+    try {
+        const parsed = JSON.parse(json);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+};
+/** A definition in any accepted shape, reduced to what the column stores. */
+const toStoredDefinition = (def) => {
+    const normalized = normalizePropertyRecordSchema(def ?? {});
+    const hasRef = normalized.dataType === ModelPropertyDataTypes.Relation || normalized.dataType === ModelPropertyDataTypes.List;
+    const out = {};
+    for (const [key, value] of Object.entries(normalized)) {
+        if (value === undefined || typeof value === 'function')
+            continue;
+        if (key.startsWith('_') || NON_DEFINITION_KEYS.has(key))
+            continue;
+        if (key === 'ref' && !hasRef)
+            continue;
+        out[key] = value;
+    }
+    return out;
+};
+/**
+ * The `definition` column value for a definition in any accepted shape (schema file property,
+ * Model.create property, ModelProperty context). With `previous` (the row's current value), fields
+ * the new definition doesn't have are kept: a write that only knows the columns (a creation
+ * payload, a row-built instance) must not drop the validation a schema file or code stored.
+ */
+function propertyDefinitionColumn(def, previous) {
+    const stored = toStoredDefinition(def);
+    return JSON.stringify(previous ? { ...toStoredDefinition(parseDefinition(previous)), ...stored } : stored);
+}
+/**
+ * A row as a {@link PropertyDefinition}. `refModelName` is the name of the row's `ref_model_id`
+ * model; without one, a Relation or List keeps the definition's `ref` (a target not stored yet).
+ */
+function propertyDefinitionFromRow(row, refModelName) {
+    const stored = toStoredDefinition(parseDefinition(row.definition));
+    const dataType = normalizeDataType(row.dataType);
+    const hasRef = dataType === ModelPropertyDataTypes.Relation || dataType === ModelPropertyDataTypes.List;
+    const ref = refModelName ?? (hasRef ? stored.ref : undefined);
+    const def = {
+        ...stored,
+        id: row.schemaFileId ?? undefined,
+        _dbId: row.id,
+        name: row.name,
+        modelId: row.modelId,
+        dataType,
+        ref,
+        refModelName: ref,
+        refModelId: row.refModelId ?? undefined,
+        refValueType: row.refValueType ? normalizeDataType(row.refValueType) : undefined,
+        storageType: row.storageType ?? undefined,
+        localStorageDir: row.localStorageDir ?? undefined,
+        filenameSuffix: row.filenameSuffix ?? undefined,
+        required: row.required ?? stored.required ?? undefined,
+    };
+    for (const key of Object.keys(def))
+        if (def[key] === undefined)
+            delete def[key];
+    return def;
+}
+const refModels = alias(models, 'ref_model');
+const selectDefinitionRows = (db) => db
+    .select({ property: properties, refModelName: refModels.name })
+    .from(properties)
+    .leftJoin(refModels, eq(refModels.id, properties.refModelId));
+/**
+ * The complete definition of one property, from its row: by row id (`metadata.property_id`), or by
+ * model row id and property name. Undefined when there's no such row.
+ */
+async function getPropertyDefinition(target, db = BaseDb.getAppDb()) {
+    if (!db)
+        throw new Error('Database not available');
+    const where = typeof target === 'number'
+        ? eq(properties.id, target)
+        : and(eq(properties.modelId, target.modelId), eq(properties.name, target.name));
+    const [row] = await selectDefinitionRows(db).where(where).limit(1);
+    return row ? propertyDefinitionFromRow(row.property, row.refModelName) : undefined;
+}
+/** {@link getPropertyDefinition} for every property of one model, by property name, in one read. */
+async function getPropertyDefinitions(modelId, db = BaseDb.getAppDb()) {
+    if (!db)
+        throw new Error('Database not available');
+    const rows = await selectDefinitionRows(db).where(eq(properties.modelId, modelId));
+    return new Map(rows.map((row) => [
+        row.property.name,
+        propertyDefinitionFromRow(row.property, row.refModelName),
+    ]));
+}
+/** {@link getPropertyDefinition} for each of these property file ids that has a row, by file id. */
+async function getPropertyDefinitionsByFileId(propertyFileIds, db = BaseDb.getAppDb()) {
+    if (!db)
+        throw new Error('Database not available');
+    if (propertyFileIds.length === 0)
+        return new Map();
+    const rows = await selectDefinitionRows(db).where(inArray(properties.schemaFileId, propertyFileIds));
+    return new Map(rows.map((row) => [
+        row.property.schemaFileId,
+        propertyDefinitionFromRow(row.property, row.refModelName),
+    ]));
+}
+/** Fields only a definition holds (no column), which code-defined properties can set. */
+const DEFINITION_ONLY_FIELDS = ['validation', 'htmlEmbeddedDataUriPolicy', 'description'];
+/** The {@link DEFINITION_ONLY_FIELDS} a definition sets. */
+const definitionOnlyFields = (def) => Object.fromEntries(DEFINITION_ONLY_FIELDS.filter((key) => def?.[key] !== undefined).map((key) => [key, def[key]]));
+/**
+ * Stores code-defined fields ({@link definitionOnlyFields}) in the row's definition, when the row
+ * exists and its definition differs. For properties whose row was written before the code that
+ * defines them ran (a schema file's row, an earlier run), so their rules persist at create time.
+ */
+async function persistDefinitionFields(where, fields, db = BaseDb.getAppDb()) {
+    if (!db || Object.keys(fields).length === 0)
+        return;
+    const condition = 'id' in where ? eq(properties.id, where.id) : eq(properties.schemaFileId, where.schemaFileId);
+    const [row] = await db.select({ id: properties.id, definition: properties.definition }).from(properties).where(condition).limit(1);
+    if (!row)
+        return;
+    const next = propertyDefinitionColumn(fields, row.definition);
+    if (row.definition && JSON.stringify(toStoredDefinition(parseDefinition(row.definition))) === next)
+        return;
+    await db.update(properties).set({ definition: next }).where(eq(properties.id, row.id));
+}
+
+var propertyDefinition = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    DEFINITION_ONLY_FIELDS: DEFINITION_ONLY_FIELDS,
+    definitionOnlyFields: definitionOnlyFields,
+    getPropertyDefinition: getPropertyDefinition,
+    getPropertyDefinitions: getPropertyDefinitions,
+    getPropertyDefinitionsByFileId: getPropertyDefinitionsByFileId,
+    persistDefinitionFields: persistDefinitionFields,
+    propertyDefinitionColumn: propertyDefinitionColumn,
+    propertyDefinitionFromRow: propertyDefinitionFromRow
+});
+
+/**
+ * The writers of definition rows: `schemas`, `models`, `properties` and `model_schemas` (SDK audit
+ * T9). One upsert per table. Every function takes the database to write, normally a transaction
+ * from {@link inDefinitionsTransaction}, and reads only through it: in the browser a query on
+ * `BaseDb.getAppDb()` waits for an open transaction to end.
+ *
+ * The lookups here decide which row a definition is (a schema by file id, then by name; a model by
+ * file id, then an adoptable row of that name; a property by file id, then by name in its model).
+ * The unique keys (`schema_file_id` on all three tables, `properties(name, model_id)`,
+ * `model_schemas(model_id, schema_id)`) are enforced by the database, and inserts resolve a
+ * conflict with ON CONFLICT instead of a second lookup.
+ */
+const logger$b = debug('seedSdk:db:write:definitions');
+/**
+ * Runs one user action on definitions (an apply, a save, a rename) in one transaction. `fn` must
+ * write through `tx` only and have no other side effects: it is retried whole when another tab
+ * holds the database.
+ */
+const inDefinitionsTransaction = (fn) => BaseDb.transaction(fn);
+// ---------------------------------------------------------------------------------------------
+// model_schemas
+/** Links a model to a schema. Returns true when this call inserted the link. */
+async function linkModelToSchemaRow(db, modelId, schemaId) {
+    const inserted = await db
+        .insert(modelSchemas)
+        .values({ modelId, schemaId })
+        .onConflictDoNothing()
+        .returning({ id: modelSchemas.id });
+    return inserted.length > 0;
+}
+/**
+ * Writes a schema row and returns it with `inserted` set when it is new.
+ *
+ * The row is the one with `schemaFileId`, else one of that name: a draft write takes a draft of
+ * that name; a published write takes a published row, else a draft (which it publishes). A
+ * published row keeps its schemaFileId against another id of the same version, and keeps its newer
+ * version against an older version's file. With `rowId` that row is written, found by the caller
+ * (a rename finds it by the old name), and takes `schemaFileId`.
+ */
+async function upsertSchemaRow(db, input, options = {}) {
+    // The stored schema file may change its nameMatch levels (ADR 0009).
+    clearNameMatchLevels();
+    const { schemaFileId, schemaData, isDraft, isEdited, contentHash } = input;
+    const update = async (existing, updates) => {
+        if (input.name && existing.name !== input.name)
+            updates.name = input.name;
+        if (schemaData !== undefined)
+            updates.schemaData = schemaData;
+        if (contentHash !== undefined && existing.contentHash !== contentHash)
+            updates.contentHash = contentHash;
+        if (input.version !== undefined && existing.version !== input.version)
+            updates.version = input.version;
+        if (isDraft !== undefined && existing.isDraft !== isDraft)
+            updates.isDraft = isDraft;
+        if (isEdited !== undefined && existing.isEdited !== isEdited)
+            updates.isEdited = isEdited;
+        if (input.updatedAt && existing.updatedAt !== input.updatedAt)
+            updates.updatedAt = input.updatedAt;
+        if (Object.keys(updates).length > 0) {
+            await db.update(schemas).set(updates).where(eq(schemas.id, existing.id));
+        }
+        return { ...existing, ...updates, inserted: false };
+    };
+    if (options.rowId !== undefined) {
+        const [row] = await db.select().from(schemas).where(eq(schemas.id, options.rowId)).limit(1);
+        if (!row)
+            throw new Error(`Schema row ${options.rowId} not found`);
+        return update(row, schemaFileId && row.schemaFileId !== schemaFileId ? { schemaFileId } : {});
+    }
+    if (schemaFileId) {
+        const [byFileId] = await db.select().from(schemas).where(eq(schemas.schemaFileId, schemaFileId)).limit(1);
+        if (byFileId)
+            return update(byFileId, {});
+    }
+    if (isDraft === true) {
+        const [byName] = await db.select().from(schemas).where(eq(schemas.name, input.name)).limit(1);
+        if (byName?.isDraft === true) {
+            const updates = { updatedAt: input.updatedAt || Date.now() };
+            if (schemaFileId && byName.schemaFileId !== schemaFileId)
+                updates.schemaFileId = schemaFileId;
+            return update(byName, updates);
+        }
+    }
+    // By name: a published write prefers a published row, then takes a draft of that name.
+    let [existing] = await db
+        .select()
+        .from(schemas)
+        .where(isDraft === false ? and(eq(schemas.name, input.name), eq(schemas.isDraft, false)) : eq(schemas.name, input.name))
+        .limit(1);
+    if (!existing && isDraft === false) {
+        [existing] = await db
+            .select()
+            .from(schemas)
+            .where(and(eq(schemas.name, input.name), eq(schemas.isDraft, true)))
+            .limit(1);
+    }
+    if (existing) {
+        // A complete schema file can bring a version under its own id (imported files may not keep it).
+        const isOtherVersionFile = !!schemaFileId &&
+            !!existing.schemaFileId &&
+            existing.schemaFileId !== schemaFileId &&
+            existing.isDraft !== true &&
+            input.version !== undefined &&
+            input.version !== existing.version;
+        if (isOtherVersionFile && input.version < existing.version) {
+            // An older version's file: rolling the row back to it would leave the newer version's id
+            // pointing at the older version's data.
+            logger$b(`Keeping schema "${input.name}" at v${existing.version}; not replacing it with older v${input.version}`);
+            return { ...existing, inserted: false };
+        }
+        const updates = {};
+        // A published row keeps its id unless this is a newer version's file; a draft or id-less row
+        // takes the new one.
+        if (schemaFileId &&
+            existing.schemaFileId !== schemaFileId &&
+            (existing.isDraft === true || !existing.schemaFileId || isOtherVersionFile)) {
+            updates.schemaFileId = schemaFileId;
+        }
+        return update(existing, updates);
+    }
+    const [row] = await db
+        .insert(schemas)
+        .values({
+        name: input.name,
+        version: input.version,
+        schemaFileId: schemaFileId || null,
+        schemaData: schemaData || null,
+        contentHash: contentHash ?? null,
+        isDraft: isDraft ?? false,
+        isEdited: isEdited ?? false,
+        createdAt: input.createdAt,
+        updatedAt: input.updatedAt,
+    })
+        .returning();
+    return { ...row, inserted: true };
+}
+// ---------------------------------------------------------------------------------------------
+// models
+/**
+ * Writes the models row with `schemaFileId`, or inserts a name-only row without one. An existing
+ * row takes `name`; `isEdited` is set on insert only.
+ */
+async function upsertModelRow(db, input) {
+    const values = { name: input.name, schemaFileId: input.schemaFileId || null, isEdited: input.isEdited ?? false };
+    if (!values.schemaFileId) {
+        const [row] = await db.insert(models).values(values).returning();
+        return row;
+    }
+    const [row] = await db
+        .insert(models)
+        .values(values)
+        .onConflictDoUpdate({ target: models.schemaFileId, set: { name: input.name } })
+        .returning();
+    return row;
+}
+/** Name-only models rows for the names that have none yet. Returns every row of those names. */
+async function insertModelStubs(db, modelNames) {
+    const columns = { id: models.id, name: models.name, schemaFileId: models.schemaFileId };
+    const rows = modelNames.length
+        ? await db.select(columns).from(models).where(inArray(models.name, modelNames))
+        : [];
+    const missing = [...new Set(modelNames)].filter((name) => !rows.some((row) => row.name === name));
+    if (missing.length > 0) {
+        rows.push(...(await db.insert(models).values(missing.map((name) => ({ name }))).returning(columns)));
+    }
+    return rows;
+}
+const isLinkedTo = async (db, modelId, schemaId) => {
+    const links = await db
+        .select({ schemaId: modelSchemas.schemaId })
+        .from(modelSchemas)
+        .where(eq(modelSchemas.modelId, modelId));
+    return {
+        any: links.length > 0,
+        other: links.some((link) => link.schemaId !== schemaId),
+    };
+};
+/**
+ * Finds or creates the models row for `modelName` in a schema, by `modelFileId` (preferred) or
+ * name. Model names are only unique per schema, so a same-name row is reused only when no other
+ * schema claims it: a null-schemaFileId stub (from ref resolution or init), or for a ref without a
+ * file id, this schema's row. A row with a file id that no schema links is a deleted schema's
+ * leftover and is not adopted. An adopted row takes `modelFileId`.
+ */
+async function findOrCreateModelRow(db, modelName, modelFileId, schemaId) {
+    if (modelFileId) {
+        const [byFileId] = await db.select().from(models).where(eq(models.schemaFileId, modelFileId)).limit(1);
+        if (byFileId) {
+            if (byFileId.name === modelName)
+                return byFileId;
+            await db.update(models).set({ name: modelName }).where(eq(models.id, byFileId.id));
+            return { ...byFileId, name: modelName };
+        }
+    }
+    const byName = await db.select().from(models).where(eq(models.name, modelName));
+    let chosen;
+    if (byName.length > 0) {
+        if (!modelFileId && schemaId && byName.length > 1) {
+            for (const candidate of byName) {
+                const links = await isLinkedTo(db, candidate.id, schemaId);
+                if (links.any && !links.other) {
+                    chosen = candidate;
+                    break;
+                }
+            }
+        }
+        chosen ?? (chosen = byName.find((row) => !row.schemaFileId));
+        if (!chosen && modelFileId) {
+            // Every same-name row has another file id: adopt only one no other schema claims.
+            for (const candidate of byName) {
+                const links = await isLinkedTo(db, candidate.id, schemaId);
+                if (candidate.schemaFileId && !links.any)
+                    continue;
+                if (!links.other) {
+                    chosen = candidate;
+                    break;
+                }
+            }
+        }
+        else if (!chosen) {
+            chosen = (byName.length === 1 ? byName[0] : undefined) || byName.find((row) => !!row.schemaFileId) || byName[0];
+        }
+    }
+    if (chosen && modelFileId && chosen.schemaFileId !== modelFileId) {
+        // Adopt a stub or an unclaimed same-name row by giving it this file id.
+        await db.update(models).set({ schemaFileId: modelFileId, isEdited: false }).where(eq(models.id, chosen.id));
+        logger$b(`Adopted existing model "${modelName}" (id: ${chosen.id}) with schemaFileId "${modelFileId}"`);
+        return { ...chosen, schemaFileId: modelFileId, isEdited: false };
+    }
+    if (chosen)
+        return chosen;
+    return upsertModelRow(db, { name: modelName, schemaFileId: modelFileId });
+}
+/**
+ * Finds or creates the models row a Relation property on `ownerModelId` points to: the ref model
+ * in the owner's schema(s) first, since model names are only unique per schema.
+ */
+async function findOrCreateRefModelRow(db, refModelName, ownerModelId) {
+    try {
+        const ref = await resolveRefModelRecord(refModelName, { modelId: ownerModelId }, db);
+        if (ref)
+            return ref;
+    }
+    catch (error) {
+        // Not in the owner's schema and defined by several others: pick/create like an import does
+        if (!(error instanceof AmbiguousModelError))
+            throw error;
+    }
+    const [ownerLink] = await db
+        .select({ schemaId: modelSchemas.schemaId })
+        .from(modelSchemas)
+        .where(eq(modelSchemas.modelId, ownerModelId))
+        .limit(1);
+    return findOrCreateModelRow(db, refModelName, undefined, ownerLink?.schemaId ?? undefined);
+}
+/**
+ * Renames a model. With `schemaNameOrId` only that schema's model is renamed; without it the name
+ * alone is used, which throws AmbiguousModelError when several schemas define it. When the new
+ * name already exists in the scope that row is returned unchanged. Unscoped, a missing model is
+ * inserted under the new name.
+ */
+async function renameModelRow(db, oldName, newName, schemaNameOrId) {
+    const scope = schemaNameOrId === undefined
+        ? {}
+        : typeof schemaNameOrId === 'number'
+            ? { schemaId: schemaNameOrId, strict: true }
+            : { schemaName: schemaNameOrId, strict: true };
+    const model = await resolveModelRecord(oldName, scope, db);
+    if (!model) {
+        if (schemaNameOrId !== undefined)
+            throw new Error(`Model "${oldName}" not found in schema "${schemaNameOrId}"`);
+        return upsertModelRow(db, { name: newName });
+    }
+    const existingWithNewName = await resolveModelRecord(newName, scope, db);
+    if (existingWithNewName)
+        return existingWithNewName;
+    await db.update(models).set({ name: newName }).where(eq(models.id, model.id));
+    return { ...model, name: newName };
+}
+const propertyRowFields = [
+    'name',
+    'modelId',
+    'dataType',
+    'schemaFileId',
+    'refModelId',
+    'refValueType',
+    'required',
+    'isEdited',
+    'storageType',
+    'localStorageDir',
+    'filenameSuffix',
+    'definition',
+];
+/**
+ * Writes the properties row for a property definition. The row is the one with `schemaFileId`,
+ * else the one named `previousName` or `name` in the model. A row with that schema_file_id on
+ * another model is left alone. The rules for fields the input leaves out are on
+ * {@link PropertyRowInput}; an unchanged row is not written.
+ */
+async function upsertPropertyRow(db, input, options = {}) {
+    let existing;
+    if (input.schemaFileId) {
+        [existing] = await db.select().from(properties).where(eq(properties.schemaFileId, input.schemaFileId)).limit(1);
+        if (existing && existing.modelId !== input.modelId) {
+            logger$b(`Property ${input.name} (${input.schemaFileId}) belongs to model row ${existing.modelId}, not ${input.modelId}; left as is`);
+            return { row: existing, changed: false };
+        }
+    }
+    for (const name of [input.previousName, input.name]) {
+        if (existing || !name)
+            continue;
+        [existing] = await db
+            .select()
+            .from(properties)
+            .where(and(eq(properties.name, name), eq(properties.modelId, input.modelId)))
+            .limit(1);
+    }
+    if (existing && options.keepEditedRow && existing.isEdited === true) {
+        logger$b(`Keeping locally edited property row ${existing.name} (id ${existing.id})`);
+        return { row: existing, changed: false };
+    }
+    let refModelId = input.refModelId ?? null;
+    if (input.refModelName && input.refModelId == null) {
+        refModelId = (await findOrCreateRefModelRow(db, input.refModelName, input.modelId)).id ?? null;
+    }
+    const values = {
+        name: input.name,
+        modelId: input.modelId,
+        dataType: input.dataType ? normalizeDataType(input.dataType) : (existing?.dataType ?? ''),
+        schemaFileId: (options.keepStoredSchemaFileId && existing?.schemaFileId) || input.schemaFileId || existing?.schemaFileId || null,
+        refModelId,
+        refValueType: input.refValueType ? normalizeDataType(input.refValueType) : null,
+        required: input.required ?? existing?.required ?? false,
+        isEdited: input.isEdited ?? existing?.isEdited ?? false,
+        storageType: input.storage ? (input.storage.storageType ?? null) : (existing?.storageType ?? null),
+        localStorageDir: input.storage ? (input.storage.localStorageDir ?? null) : (existing?.localStorageDir ?? null),
+        filenameSuffix: input.storage ? (input.storage.filenameSuffix ?? null) : (existing?.filenameSuffix ?? null),
+        definition: input.definition
+            ? propertyDefinitionColumn(input.definition, input.replaceDefinition ? null : existing?.definition)
+            : (existing?.definition ?? null),
+    };
+    if (existing) {
+        const unchanged = propertyRowFields.every((field) => (existing[field] ?? null) === (values[field] ?? null));
+        if (unchanged)
+            return { row: existing, changed: false };
+        await db.update(properties).set(values).where(eq(properties.id, existing.id));
+        return { row: { ...existing, ...values }, changed: true };
+    }
+    const { name, modelId, ...rest } = values;
+    const [row] = await db
+        .insert(properties)
+        .values(values)
+        .onConflictDoUpdate(values.schemaFileId
+        ? { target: properties.schemaFileId, set: { name, ...rest } }
+        : { target: [properties.name, properties.modelId], set: rest })
+        .returning();
+    return { row, changed: true };
+}
+
+var definitions = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    findOrCreateModelRow: findOrCreateModelRow,
+    findOrCreateRefModelRow: findOrCreateRefModelRow,
+    inDefinitionsTransaction: inDefinitionsTransaction,
+    insertModelStubs: insertModelStubs,
+    linkModelToSchemaRow: linkModelToSchemaRow,
+    renameModelRow: renameModelRow,
+    upsertModelRow: upsertModelRow,
+    upsertPropertyRow: upsertPropertyRow,
+    upsertSchemaRow: upsertSchemaRow
+});
+
+const logger$a = debug('seedSdk:helpers:db');
+/**
+ * Posts one message and closes the channel. A message already posted is still delivered after its
+ * sender closes, and an open BroadcastChannel keeps a Node process alive (each was a MessagePort
+ * handle that stopped scripts exiting).
+ */
+const postBroadcast = (channelName, message) => {
+    const channel = new BroadcastChannel(channelName);
+    try {
+        channel.postMessage(message);
+    }
+    finally {
+        channel.close();
+    }
+};
+/**
+ * The `properties` storage columns for a property definition, in either the internal shape
+ * (`storageType`, `localStorageDir`, `filenameSuffix`) or the schema-file shape
+ * (`storage: { type, path, extension }`). All null when the definition has no storage config.
+ */
+function propertyStorageColumns(def) {
+    const normalized = normalizePropertyRecordSchema((def ?? {}));
+    return {
+        storageType: normalized.storageType ?? null,
+        localStorageDir: normalized.localStorageDir ?? null,
+        filenameSuffix: normalized.filenameSuffix ?? null,
+    };
+}
+/** True when the definition carries any storage setting (so writing its columns can't wipe them by omission). */
+const hasStorageSettings = (columns) => columns.storageType != null || columns.localStorageDir != null || columns.filenameSuffix != null;
+/**
+ * A model's ItemStorage properties as stored in `properties` (storage_type 'ItemStorage'), with
+ * their storage path and extension. Reads the table, not ModelProperty instances, so it doesn't
+ * depend on whether (or from where) the model's property instances have loaded.
+ */
+async function getItemStoragePropertiesForModel(modelNameOrType, scope = {}) {
+    const db = BaseDb.getAppDb();
+    if (!db || !modelNameOrType)
+        return [];
+    const modelRecord = await resolveModelRecordByNameOrType(modelNameOrType, scope, db);
+    if (!modelRecord)
+        return [];
+    return db
+        .select({
+        id: properties.id,
+        name: properties.name,
+        localStorageDir: properties.localStorageDir,
+        filenameSuffix: properties.filenameSuffix,
+    })
+        .from(properties)
+        .where(and(eq(properties.modelId, modelRecord.id), eq(properties.storageType, 'ItemStorage')));
+}
+/**
+ * Moves a renamed property's pending outbox edits (ADR 0019) to its new name, so they apply as the
+ * property's. Its metadata rows need no move: readers match them by property_id (decision D4).
+ * Returns the number of ops renamed.
+ */
+async function renamePendingWritesForProperty(modelName, oldPropertyName, newPropertyName) {
+    const db = BaseDb.getAppDb();
+    if (!db)
+        return 0;
+    const renamed = await db
+        .update(pendingWrites)
+        .set({ propertyName: newPropertyName })
+        .where(and(eq(pendingWrites.propertyName, oldPropertyName), eq(pendingWrites.status, 'pending'), inArray(pendingWrites.seedLocalId, db.select({ localId: seeds.localId }).from(seeds).where(eq(seeds.type, easName(modelName))))))
+        .returning({ opId: pendingWrites.opId });
+    return renamed.length;
+}
+/** Tells React's useSchemas a schemas row was inserted (its live query may not re-run). */
+const broadcastSchemasInvalidate = () => {
+    if (typeof BroadcastChannel === 'undefined')
+        return;
+    try {
+        postBroadcast('seed-schemas-invalidate', {});
+    }
+    catch (_) { }
+};
+/** Tells React's useModels a model was linked to a schema (its live query may not re-run). */
+const broadcastModelsInvalidate = (schema) => {
+    if (typeof BroadcastChannel === 'undefined')
+        return;
+    try {
+        postBroadcast('seed-models-invalidate', {
+            schemaName: schema.name ?? undefined,
+            schemaFileId: schema.schemaFileId ?? undefined,
+        });
+    }
+    catch (_) { }
+};
+/**
+ * Writes a schema row ({@link upsertSchemaRow} has the matching rules) and returns it.
+ * @param schemaFileId - Optional schemaFileId from JSON file for change tracking
+ * @param schemaData - Optional full schema content as JSON string (SchemaFileFormat)
+ * @param isDraft - Optional flag indicating if schema is in draft state (default: false)
+ * @param isEdited - Optional flag indicating if schema has been edited locally (default: false)
+ * @param options.db - Write on this transaction; the caller then tells React after it commits.
+ *   Without it the write runs in its own transaction.
+ * @param options.contentHash - The applied file's hash (applySchemaFile); written with schemaData
+ */
+const addSchemaToDb = async (schema, schemaFileId, schemaData, isDraft, isEdited, options = {}) => {
+    if (!options.db && !BaseDb.getAppDb()) {
+        throw new Error('Database not found');
+    }
+    const input = {
+        name: schema.name,
+        version: schema.version,
+        createdAt: schema.createdAt,
+        updatedAt: schema.updatedAt,
+        schemaFileId,
+        schemaData,
+        isDraft,
+        isEdited,
+        contentHash: options.contentHash,
+    };
+    if (options.db) {
+        const { inserted: _inserted, ...row } = await upsertSchemaRow(options.db, input);
+        return row;
+    }
+    const { inserted, ...row } = await inDefinitionsTransaction((tx) => upsertSchemaRow(tx, input));
+    if (inserted)
+        broadcastSchemasInvalidate();
+    return row;
+};
+/**
+ * Renames a model ({@link renameModelRow}), in its own transaction unless `db` is given.
+ * @param schemaNameOrId - Schema name or id to scope the rename (required when multiple schemas have models with the same name)
  */
-function metadataStoredNameForms(key, def) {
-    const forms = [metadataStorageName(key, def), key];
-    if (!ID_SUFFIX_EXCLUDE.has(key) && needsMetadataIdSuffix(def?.dataType, def?.refValueType))
-        forms.push(`${key}Id`);
-    return [...new Set(forms)];
-}
+const renameModelInDb = async (oldName, newName, schemaNameOrId, db) => {
+    if (db)
+        return renameModelRow(db, oldName, newName, schemaNameOrId);
+    if (!BaseDb.getAppDb())
+        throw new Error('Database not found');
+    return inDefinitionsTransaction((tx) => renameModelRow(tx, oldName, newName, schemaNameOrId));
+};
 /**
- * The schema key a stored metadata name belongs to among `defs` (keyed by schema key): an exact key
- * first, then any of a key's stored forms. Undefined when no property matches. For rows without
- * `property_id`; rows with one take the key from their properties row.
+ * Writes a schema file's models, their property rows and their model_schemas links.
+ * @param models - Models to write besides those in schemaFileData.propertyDefinitions
+ * @param schema - Optional schema to link models to (a row, or written first when it has no id)
+ * @param modelRenames - Optional map of old model names to new model names
+ * @param schemaFileData - The file's ids and property definitions: { schemaFileId, modelFileIds: Map<modelName, id>, propertyFileIds: Map<modelName, Map<propertyName, id>>, propertyDefinitions }
+ * @param options.db - Write on this transaction; the caller refreshes cached ModelProperty
+ *   instances with the returned ids once it has committed. Without it the write runs in its own
+ *   transaction and refreshes them itself.
+ * @returns The schemaFileIds of the property rows this call changed
  */
-function propertyKeyFromStoredName(defs, storedName) {
-    if (!storedName)
-        return undefined;
-    if (Object.prototype.hasOwnProperty.call(defs, storedName))
-        return storedName;
-    for (const [key, def] of Object.entries(defs)) {
-        if (metadataStoredNameForms(key, def).includes(storedName))
-            return key;
+const addModelsToDb = async (models, schema, modelRenames, schemaFileData, options = {}) => {
+    if (!options.db) {
+        if (!BaseDb.getAppDb())
+            throw new Error('Database not found');
+        const changed = await inDefinitionsTransaction((tx) => addModelsToDb(models, schema, modelRenames, schemaFileData, { db: tx }));
+        // A cached instance is otherwise never re-read from its row (createById returns it as is)
+        await refreshCachedProperties(changed);
+        return changed;
+    }
+    const db = options.db;
+    // Model rows and their schema links decide which schema file's nameMatch applies (ADR 0009).
+    clearNameMatchLevels();
+    // The schema may already be a row (with id)
+    let schemaRecord;
+    if (schema) {
+        schemaRecord =
+            schema.id !== null && schema.id !== undefined
+                ? schema
+                : await addSchemaToDb(schema, schemaFileData?.schemaFileId, undefined, undefined, undefined, { db });
+    }
+    if (modelRenames && schemaRecord) {
+        const schemaNameOrId = schemaRecord.name ?? schemaRecord.id;
+        for (const [oldName, newName] of modelRenames.entries()) {
+            await renameModelRow(db, oldName, newName, schemaNameOrId);
+        }
+    }
+    const modelRecords = new Map();
+    const modelProcessingErrors = [];
+    // Property rows this call changed, so cached ModelProperty instances can be given the new values
+    const updatedPropertyFileIds = [];
+    const _mod_0 = await import('./arweaveContentTags-iW_HcWJA.js');
+    const _ns_0 = _mod_0.ap;
+    const { generateId } = _ns_0;
+    const modelNames = [...new Set([...Object.keys(models), ...(schemaFileData?.propertyDefinitions?.keys() ?? [])])];
+    for (const modelName of modelNames) {
+        try {
+            const modelFileId = schemaFileData?.modelFileIds?.get(modelName);
+            const modelRecord = modelRecords.get(modelName) ?? (await findOrCreateModelRow(db, modelName, modelFileId, schemaRecord?.id));
+            modelRecords.set(modelName, modelRecord);
+            const definitions = schemaFileData?.propertyDefinitions?.get(modelName) ?? {};
+            for (const [propertyName, propertyValues] of Object.entries(definitions)) {
+                if (!propertyValues) {
+                    throw new Error(`Property values not found for ${propertyName}`);
+                }
+                // IDs are assigned before this is called; a generated one doesn't replace a stored id.
+                const propertyFileId = schemaFileData?.propertyFileIds?.get(modelName)?.get(propertyName);
+                let refModelId = null;
+                const refModelName = propertyValues.ref || propertyValues.refModelName;
+                if (refModelName) {
+                    let refModel = modelRecords.get(refModelName);
+                    if (!refModel) {
+                        const refModelFileId = schemaFileData?.modelFileIds?.get(refModelName);
+                        refModel = await findOrCreateModelRow(db, refModelName, refModelFileId, schemaRecord?.id);
+                        modelRecords.set(refModelName, refModel);
+                    }
+                    refModelId = refModel.id ?? null;
+                }
+                // ADR 0008: a rename needs the property's id. A name that matches no stored property by id
+                // or name is a new property. The schema file is the source of truth for every column, and
+                // a property edited locally keeps its row.
+                const { row, changed } = await upsertPropertyRow(db, {
+                    modelId: modelRecord.id,
+                    name: propertyName,
+                    dataType: propertyValues.dataType,
+                    schemaFileId: propertyFileId ?? generateId(),
+                    refModelId,
+                    refValueType: propertyValues.refValueType ?? null,
+                    required: propertyValues.required ?? false,
+                    storage: propertyStorageColumns(propertyValues),
+                    isEdited: false,
+                    definition: schemaFileData?.propertyFileDefinitions?.get(modelName)?.[propertyName] ?? propertyValues,
+                    replaceDefinition: true,
+                }, { keepStoredSchemaFileId: !propertyFileId, keepEditedRow: true });
+                if (changed && row?.schemaFileId)
+                    updatedPropertyFileIds.push(row.schemaFileId);
+            }
+        }
+        catch (error) {
+            const errorMessage = error?.message || String(error);
+            logger$a(`Error processing model "${modelName}": ${errorMessage}`);
+            modelProcessingErrors.push({ modelName, error: errorMessage });
+            // Continue processing other models even if one fails
+        }
     }
-    return undefined;
-}
+    if (modelProcessingErrors.length > 0) {
+        console.warn(`[addModelsToDb] Errors occurred while processing ${modelProcessingErrors.length} model(s):`, modelProcessingErrors.map(e => `${e.modelName}: ${e.error}`).join('; '));
+    }
+    if (schemaRecord?.id) {
+        for (const [modelName, record] of modelRecords) {
+            if (!record.id)
+                continue;
+            if (await linkModelToSchemaRow(db, record.id, schemaRecord.id)) {
+                logger$a(`Linked model ${modelName} (id: ${record.id}) to schema (id: ${schemaRecord.id})`);
+            }
+        }
+    }
+    return updatedPropertyFileIds;
+};
 /**
- * The names a property's rows may be stored under, for matching rows that have no property_id and
- * outbox ops (which name a property, not its id): the name with and without its `Id` for an Image,
- * File, Html or Relation, or when `dataType` is unknown.
+ * The models linked to a schema row (model_schemas) with their property rows, in schema-file
+ * shape: `{ [modelName]: { id, properties: { [name]: { dataType, schemaFileId, ref, ... } } } }`.
+ * Properties carry their row's definition (validation, description, ...); model-level fields only a
+ * schema file holds aren't here, see {@link mergeDbModelsIntoSchemaModels}.
+ * @param schemaId - The ID of the schema record in the database
  */
-function getMetadataPropertyNamesForQuery(propertyName, dataType, refValueType) {
-    if (ID_SUFFIX_EXCLUDE.has(propertyName))
-        return [propertyName];
-    if (propertyName.endsWith('Ids'))
-        return [propertyName];
-    if (propertyName.endsWith('Id')) {
-        const base = propertyName.slice(0, -2);
-        return [propertyName, base];
+const loadModelsFromDbForSchema = async (schemaId, db = BaseDb.getAppDb()) => {
+    if (!db) {
+        logger$a('Database not found, cannot load models from DB');
+        return {};
     }
-    const needsId = needsMetadataIdSuffix(dataType, refValueType) ||
-        (dataType === undefined && refValueType === undefined);
-    if (needsId) {
-        return [propertyName, `${propertyName}Id`];
+    try {
+        const linked = await db
+            .select({ modelId: modelSchemas.modelId, modelName: models.name, schemaFileId: models.schemaFileId })
+            .from(modelSchemas)
+            .innerJoin(models, eq(modelSchemas.modelId, models.id))
+            .where(eq(modelSchemas.schemaId, schemaId));
+        const modelIds = linked.map((row) => row.modelId).filter((id) => id != null);
+        if (modelIds.length === 0)
+            return {};
+        const refModels = alias(models, 'ref_models');
+        const propertyRows = await db
+            .select({ property: properties, refName: refModels.name })
+            .from(properties)
+            .leftJoin(refModels, eq(properties.refModelId, refModels.id))
+            .where(inArray(properties.modelId, modelIds));
+        const models$1 = {};
+        const nameById = new Map();
+        for (const { modelId, modelName, schemaFileId } of linked) {
+            if (!modelId || !modelName)
+                continue;
+            nameById.set(modelId, modelName);
+            // The id (schemaFileId) lets Model.create find the existing row instead of adding a "Post 1".
+            models$1[modelName] = { properties: {}, ...(schemaFileId ? { id: schemaFileId } : {}) };
+        }
+        for (const { property: prop, refName } of propertyRows) {
+            const modelName = nameById.get(prop.modelId);
+            if (!modelName)
+                continue;
+            // The row's definition without its row keys; `required` stays the file's
+            const { id: _id, _dbId, name: _name, modelId: _modelId, refModelId: _refModelId, refModelName: _refModelName, required: _required, ...definition } = propertyDefinitionFromRow(prop, refName);
+            models$1[modelName].properties[prop.name] = {
+                ...definition,
+                ...(prop.schemaFileId ? { schemaFileId: prop.schemaFileId } : {}),
+            };
+        }
+        logger$a(`Loaded ${Object.keys(models$1).length} models from database for schema ${schemaId}`);
+        return models$1;
     }
-    return [propertyName];
-}
+    catch (error) {
+        logger$a(`Error loading models from database for schema ${schemaId}:`, error);
+        return {};
+    }
+};
 /**
- * The name an item exposes a property under, from the name it is stored under: its alias when it
- * has one (List of relation), else `tagIds` → `tags`, `authorId` → `author`. Names in
- * PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP keep their `Id`.
+ * Merges the models {@link loadModelsFromDbForSchema} read from the database into a schema's
+ * models. The database decides which models and properties exist and their stored fields; the
+ * schema keeps what only it holds (nameMatch, description, validation, ...), found by id first so
+ * a property renamed in the database keeps them. A schema property whose id a database property
+ * has is dropped under its old name.
  */
-function toItemPropertyKey(storedName, alias) {
-    if (alias)
-        return alias;
-    if (storedName.endsWith('Ids'))
-        return pluralize(storedName.slice(0, -3));
-    if (storedName.endsWith('Id') && !PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP.has(storedName)) {
-        return storedName.slice(0, -2);
+const mergeDbModelsIntoSchemaModels = (schemaModels, dbModels) => {
+    const merged = { ...(schemaModels ?? {}) };
+    for (const [modelName, dbModel] of Object.entries(dbModels)) {
+        const schemaModel = schemaModels?.[modelName];
+        if (!schemaModel) {
+            merged[modelName] = dbModel;
+            continue;
+        }
+        const schemaProps = schemaModel.properties ?? {};
+        const dbProps = dbModel.properties ?? {};
+        const schemaNameById = new Map();
+        for (const [name, prop] of Object.entries(schemaProps)) {
+            const id = prop?.id ?? prop?.schemaFileId;
+            if (id)
+                schemaNameById.set(id, name);
+        }
+        const properties = {};
+        const matched = new Set();
+        for (const [name, dbProp] of Object.entries(dbProps)) {
+            const byId = dbProp?.schemaFileId ? schemaNameById.get(dbProp.schemaFileId) : undefined;
+            const byName = schemaProps[name];
+            const byNameId = byName?.id ?? byName?.schemaFileId;
+            // By name only when the ids don't say it's another property.
+            const schemaName = byId ?? (byName && !(byNameId && dbProp?.schemaFileId && byNameId !== dbProp.schemaFileId) ? name : undefined);
+            const schemaProp = schemaName ? schemaProps[schemaName] : undefined;
+            if (schemaName && schemaProp)
+                matched.add(schemaName);
+            // The database's dataType and ref replace the file's type and model.
+            const { type, model, ...fromSchema } = schemaProp ?? {};
+            properties[name] = {
+                ...fromSchema,
+                ...(dbProp?.dataType === undefined && type !== undefined ? { type } : {}),
+                ...(dbProp?.ref === undefined && model !== undefined ? { model } : {}),
+                ...dbProp,
+            };
+        }
+        const unmatched = Object.fromEntries(Object.entries(schemaProps).filter(([name]) => !matched.has(name)));
+        merged[modelName] = { ...schemaModel, ...dbModel, properties: { ...unmatched, ...properties } };
     }
-    return storedName;
-}
+    return merged;
+};
 /**
- * Schema property name from metadata name (strip Id/Ids suffix).
+ * Saves a ModelProperty's edit to its properties row (is_edited true) without updating the schema
+ * file, in one transaction. A context without `required` or storage settings leaves the row's.
+ * @param property - The ModelPropertyMachineContext with updated values
  */
-function toSchemaPropertyName(propertyName) {
-    if (propertyName.endsWith('Ids'))
-        return propertyName.slice(0, -3);
-    if (propertyName.endsWith('Id'))
-        return propertyName.slice(0, -2);
-    return undefined;
+const savePropertyToDb = async (property) => {
+    if (!BaseDb.getAppDb()) {
+        throw new Error('Database not found');
+    }
+    const name = property.name;
+    if (!name) {
+        throw new Error('Property name is required');
+    }
+    const schemaFileId = property._propertyFileId || (typeof property.id === 'string' ? property.id : undefined);
+    const storage = propertyStorageColumns(property);
+    await inDefinitionsTransaction(async (tx) => {
+        // modelId, then the model of the property row (by its schemaFileId), then modelName in the
+        // property's schema. context.modelName can also hold the model's schemaFileId.
+        const modelRecord = await resolveModelRecord(property.modelName, {
+            modelId: typeof property.modelId === 'number' ? property.modelId : undefined,
+            propertyFileId: schemaFileId,
+            modelFileId: property.modelName,
+            schemaName: property._schemaName,
+        }, tx);
+        if (!modelRecord) {
+            throw new Error(`Model not found in database (modelId=${property.modelId}, modelName=${property.modelName})`);
+        }
+        await upsertPropertyRow(tx, {
+            modelId: modelRecord.id,
+            name,
+            dataType: property.dataType,
+            schemaFileId,
+            previousName: property._originalValues?.name,
+            refModelName: property.refModelName,
+            refModelId: property.refModelName ? undefined : (property.refModelId ?? null),
+            refValueType: property.refValueType ?? null,
+            required: property.required,
+            storage: hasStorageSettings(storage) ? storage : undefined,
+            isEdited: true,
+            definition: property,
+        });
+    });
+    logger$a(`Saved property ${property.modelName}:${property.name}`);
+};
+function parseAddressConfig(value) {
+    if (!value)
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        if (Array.isArray(parsed)) {
+            return normalizeAddressConfig(parsed);
+        }
+        if (parsed && typeof parsed === 'object' && Array.isArray(parsed.owned)) {
+            return normalizeAddressConfig({
+                owned: parsed.owned,
+                watched: Array.isArray(parsed.watched) ? parsed.watched : [],
+            });
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
 }
+const getOwnedAddressesFromDb = async () => {
+    const config = await getAddressConfigFromDb();
+    return config?.owned ?? [];
+};
+const getWatchedAddressesFromDb = async () => {
+    const config = await getAddressConfigFromDb();
+    return config?.watched ?? [];
+};
 /**
- * Alternate property name for instance lookup (base <-> Id variant).
+ * Returns persisted owned or watched addresses for list filters.
+ * Does not include `getAdditionalSyncAddresses` (those are extra EAS indexers).
  */
-function getAlternatePropertyNameForInstanceLookup(propertyName) {
-    if (ID_SUFFIX_EXCLUDE.has(propertyName))
-        return undefined;
-    if (propertyName.endsWith('Id'))
-        return propertyName.slice(0, -2);
-    return `${propertyName}Id`;
-}
+const getAddressesForItemsFilter = async (addressFilter) => {
+    if (addressFilter === 'owned') {
+        return getOwnedAddressesFromDb();
+    }
+    return getWatchedAddressesFromDb();
+};
 /**
- * The EAS property name publish writes for an item property (ADR 0008 §3), already in EAS form:
- *
- * - List of relations: its `<name><Model>Ids` storage name (`author_identity_ids`).
- * - Single Relation, Image, File or Html: its schema key (`author`), never the local `<name>Id`
- *   storage name. The key is `propertyDef.name` when known, else `propertyName` without its `Id`.
- * - Anything else: the property name.
+ * Returns owned + watched addresses. Use for EAS sync and file download.
  */
-function easPropertyNameForPublish(propertyName, propertyDef) {
-    const listRelationName = listRelationEasPropertyName(propertyName, propertyDef ?? undefined);
-    if (listRelationName)
-        return easName(listRelationName);
-    if (propertyDef &&
-        normalizeDataType(propertyDef.dataType) !== 'List' &&
-        needsMetadataIdSuffix(propertyDef.dataType, propertyDef.refValueType) &&
-        !ID_SUFFIX_EXCLUDE.has(propertyName)) {
-        const key = propertyDef.name ?? (propertyName.endsWith('Id') ? propertyName.slice(0, -2) : propertyName);
-        return easName(key);
+const getAllAddressesFromDb = async () => {
+    const config = await getAddressConfigFromDb();
+    if (!config)
+        return [];
+    return [...config.owned, ...config.watched];
+};
+async function getAddressConfigFromDb() {
+    // Before init opens the database (or with no init) there are no stored addresses to read
+    const appDb = await whenDbReady();
+    if (!appDb)
+        return null;
+    const appStatesRecords = await appDb
+        .select()
+        .from(appState)
+        .where(eq(appState.key, 'addresses'))
+        .limit(1);
+    if (!appStatesRecords || appStatesRecords.length === 0) {
+        return null;
     }
-    return easName(propertyName);
+    const addressArrayString = appStatesRecords[0].value;
+    return parseAddressConfig(addressArrayString);
 }
 /**
- * The EAS schema definition publish attests a property under (`string title`, `bytes32 author`),
- * or undefined when its data type has no EAS type. Look schemas up by this, not by name: a name
- * can have schemas of several types (Optimism Sepolia has `bytes32 storage_transaction_id` beside
- * `string storage_transaction_id`).
+ * Writes a runtime-created model: its models row (is_edited true when new), its model_schemas link
+ * and the properties given, in one transaction. Returns the model's row id.
+ * @param modelFileId - The model file ID (schema_file_id)
+ * @param data - Model data including modelName, schemaId, and optional properties
  */
-function easSchemaDefinitionForProperty(propertyName, propertyDef) {
-    if (!propertyDef?.dataType)
-        return undefined;
-    const dataType = normalizeDataType(String(propertyDef.dataType));
-    const easType = INTERNAL_DATA_TYPES[dataType]?.eas;
-    if (!easType)
-        return undefined;
-    return `${easType} ${easPropertyNameForPublish(propertyName, propertyDef)}`;
+async function writeModelToDb(modelFileId, data) {
+    if (!BaseDb.getAppDb())
+        throw new Error('Database not available');
+    if (!data.schemaId || !Number.isInteger(data.schemaId) || data.schemaId <= 0) {
+        throw new Error(`Invalid schemaId: ${data.schemaId}. Schema record must exist before creating join entry.`);
+    }
+    const _mod_1 = await import('./arweaveContentTags-iW_HcWJA.js');
+    const _ns_1 = _mod_1.ap;
+    const { generateId } = _ns_1;
+    const { linked, schema, modelId } = await inDefinitionsTransaction(async (tx) => {
+        const [schema] = await tx
+            .select({ id: schemas.id, name: schemas.name, schemaFileId: schemas.schemaFileId })
+            .from(schemas)
+            .where(eq(schemas.id, data.schemaId))
+            .limit(1);
+        if (!schema) {
+            throw new Error(`Schema with id ${data.schemaId} does not exist in database. Cannot create join record.`);
+        }
+        const model = await upsertModelRow(tx, { name: data.modelName, schemaFileId: modelFileId, isEdited: true });
+        const linked = await linkModelToSchemaRow(tx, model.id, data.schemaId);
+        for (const [propName, propData] of Object.entries(data.properties ?? {})) {
+            const refModelName = propData.refModelName || propData.ref;
+            const storage = propertyStorageColumns(propData);
+            // A stored row keeps its id; the given or a generated one is for a new row.
+            await upsertPropertyRow(tx, {
+                modelId: model.id,
+                name: propName,
+                dataType: propData.dataType,
+                schemaFileId: propData.id ?? generateId(),
+                refModelName,
+                refModelId: refModelName ? undefined : (propData.refModelId ?? null),
+                refValueType: propData.refValueType ?? null,
+                required: propData.required,
+                storage: hasStorageSettings(storage) ? storage : undefined,
+                definition: propData,
+            }, { keepStoredSchemaFileId: true });
+        }
+        return { linked, schema, modelId: model.id };
+    });
+    if (linked)
+        broadcastModelsInvalidate(schema);
+    logger$a(`Wrote model ${data.modelName} (${modelFileId}) to database`);
+    return modelId;
 }
+/**
+ * Writes a property's row by its file id ({@link upsertPropertyRow}), in its own transaction.
+ * `required` and storage settings the data leaves out keep the row's.
+ * @param propertyFileId - The property file ID (schema_file_id)
+ * @param data - Property data including modelId, name, dataType, and other property fields
+ * @param isEdited - Optional flag indicating if property has been edited locally. Left unset, an update
+ *   keeps the row's flag (a load or creation write must not clear an unsaved edit) and an insert stores false.
+ */
+async function writePropertyToDb(propertyFileId, data, isEdited) {
+    if (!BaseDb.getAppDb())
+        throw new Error('Database not available');
+    const refModelName = data.refModelName || data.ref;
+    const storage = propertyStorageColumns(data);
+    await inDefinitionsTransaction((tx) => upsertPropertyRow(tx, {
+        modelId: data.modelId,
+        name: data.name,
+        dataType: data.dataType,
+        schemaFileId: propertyFileId,
+        refModelName,
+        refModelId: refModelName ? undefined : (data.refModelId ?? null),
+        refValueType: data.refValueType ?? null,
+        required: data.required,
+        storage: hasStorageSettings(storage) ? storage : undefined,
+        isEdited,
+        definition: data,
+    }));
+    logger$a(`Wrote property ${data.name} (${propertyFileId})`);
+}
+
+var db = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    addModelsToDb: addModelsToDb,
+    addSchemaToDb: addSchemaToDb,
+    broadcastSchemasInvalidate: broadcastSchemasInvalidate,
+    getAddressesForItemsFilter: getAddressesForItemsFilter,
+    getAllAddressesFromDb: getAllAddressesFromDb,
+    getItemStoragePropertiesForModel: getItemStoragePropertiesForModel,
+    getOwnedAddressesFromDb: getOwnedAddressesFromDb,
+    getWatchedAddressesFromDb: getWatchedAddressesFromDb,
+    loadModelsFromDbForSchema: loadModelsFromDbForSchema,
+    mergeDbModelsIntoSchemaModels: mergeDbModelsIntoSchemaModels,
+    propertyStorageColumns: propertyStorageColumns,
+    renameModelInDb: renameModelInDb,
+    renamePendingWritesForProperty: renamePendingWritesForProperty,
+    savePropertyToDb: savePropertyToDb,
+    writeModelToDb: writeModelToDb,
+    writePropertyToDb: writePropertyToDb
+});
 
 /**
  * Proxy [[GetOwnProperty]] that stays compatible with the target.
@@ -896,7 +2636,6 @@ var metadataProperty = /*#__PURE__*/Object.freeze({
     METADATA_PROPERTY_GROUP_KEY_SQL: METADATA_PROPERTY_GROUP_KEY_SQL,
     findMetadataPropertyByName: findMetadataPropertyByName,
     matchMetadataProperty: matchMetadataProperty,
-    metadataPropertyGroupKeys: metadataPropertyGroupKeys,
     metadataPropertyKeyColumn: metadataPropertyKeyColumn,
     metadataPropertyNameForms: metadataPropertyNameForms,
     metadataRowsOfProperty: metadataRowsOfProperty,
@@ -2235,9 +3974,7 @@ const getItemsData = async ({ modelName, modelFileId, schemaName, deleted, inclu
         conditions.push(eq(seeds.type, easName(modelName)));
     }
     if (!modelFileId && schemaName && modelName) {
-        const _mod_0 = await import('./tabEvents-DT5ez6io.js');
-        const _ns_0 = _mod_0.bh;
-        const { resolveModelRecord } = _ns_0;
+        const { resolveModelRecord } = await Promise.resolve().then(function () { return resolveModelRecord$1; });
         modelFileId = (await resolveModelRecord(modelName, { schemaName }))?.schemaFileId ?? undefined;
         if (!modelFileId)
             return []; // that schema has no such model
@@ -2324,6 +4061,33 @@ async function getLatestVersionRow(seedLocalId) {
     return rows[0] ?? null;
 }
 
+const logger$6 = debug('seedSdk:helpers:propertySchemaUid');
+/**
+ * UID of the EAS schema a property publishes under, or undefined when EAS has none, the property's
+ * type has no EAS type, or the lookup fails. Reads `getEasSchemaUidForExactDefinition`, which
+ * answers with a UID publish registered in this session before the indexer has it, and caches
+ * found UIDs and misses, so creating an item and then saving its properties asks EAS once per
+ * definition. May call EAS, so run it before a transaction, not inside one. Callers store the UID
+ * on the metadata row; publish resolves schemas itself, so a missing one costs nothing there.
+ */
+async function lookupPropertySchemaUid(propertyName, propertyDef) {
+    const definition = easSchemaDefinitionForProperty(propertyName, propertyDef);
+    if (!definition)
+        return undefined;
+    try {
+        return await getEasSchemaUidForExactDefinition(definition);
+    }
+    catch (error) {
+        logger$6(`EAS schema lookup for "${definition}" failed (offline?): ${error}`);
+        return undefined;
+    }
+}
+
+var propertySchemaUid = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    lookupPropertySchemaUid: lookupPropertySchemaUid
+});
+
 const initialize = fromCallback(({ sendBack, input: { context } }) => {
     const { isRelation, propertyName, storageTransactionId, propertyRecordSchema, } = context;
     let { schemaUid } = context;
@@ -2334,21 +4098,10 @@ const initialize = fromCallback(({ sendBack, input: { context } }) => {
             (!propertyRecordSchema ||
                 !propertyRecordSchema.storageType ||
                 propertyRecordSchema.storageType !== 'ItemStorage')) {
-            try {
-                // A name alone matches schemas of any type (`bytes32 storage_transaction_id` beside
-                // `string storage_transaction_id`), so look up the exact definition when the type is known.
-                const schemaText = easSchemaDefinitionForProperty(propertyName, propertyRecordSchema) ?? propertyName;
-                schemaUid = await getEasSchemaUidForSchemaDefinition({ schemaText });
-                if (schemaUid) {
-                    sendBack({ type: 'updateContext', schemaUid });
-                }
-            }
-            catch (error) {
-                // If schema fetch fails, continue without schemaUid - it's not required for local metadata
-                // Log error in development but don't throw
-                if (process.env.NODE_ENV === 'development') {
-                    console.warn(`Failed to fetch schemaUid for property ${propertyName}:`, error);
-                }
+            // Undefined when the lookup fails: local metadata doesn't need it.
+            schemaUid = await lookupPropertySchemaUid(propertyName, propertyRecordSchema);
+            if (schemaUid) {
+                sendBack({ type: 'updateContext', schemaUid });
             }
         }
         if (isRelation) {
@@ -2483,7 +4236,7 @@ const getRelationValueData = async (propertyValue) => {
 
 // Dynamic import to break circular dependency: schema/index -> ... -> resolveRelatedValue -> schema/index
 // import { ModelPropertyDataTypes } from '@/schema'
-const logger$6 = debug('seedSdk:property:actors:resolveRelatedValue');
+const logger$5 = debug('seedSdk:property:actors:resolveRelatedValue');
 const storageTransactionIdToContentUrl = new Map();
 const refResolvedValueToContentUrl = new Map();
 const seedUidToContentUrl = new Map();
@@ -2491,14 +4244,14 @@ 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-DXRhFg1N.js');
+        const schemaMod = await import('./index-CmNqUKQN.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
         }
         if (Array.isArray(propertyValue)) {
             // TODO: Handle array of seedUids
-            logger$6(`${propertyName} value is an array of seedUids`);
+            logger$5(`${propertyName} value is an array of seedUids`);
             return;
         }
         if (typeof propertyValue === 'object') {
@@ -2510,7 +4263,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
             parsedValue = JSON.parse(relationKey);
         }
         catch {
-            logger$6(`${propertyName} value is not a JSON string.`);
+            logger$5(`${propertyName} value is not a JSON string.`);
         }
         if (!parsedValue && seedUidToContentUrl.has(relationKey)) {
             const contentUrl = seedUidToContentUrl.get(relationKey);
@@ -2525,7 +4278,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
             return true;
         }
         if (Array.isArray(parsedValue)) {
-            logger$6(`${propertyName} value is a stringified array of seedUids`);
+            logger$5(`${propertyName} value is a stringified array of seedUids`);
             return;
         }
         const storageTransactionId = await getStorageTransactionIdForSeedUid(relationKey);
@@ -2823,6 +4576,33 @@ function parseListPropertyValueFromStorage(raw) {
     return trimmed.split(',').map((s) => s.trim()).filter(Boolean);
 }
 
+/** Subdirectory of the files root that holds a storage seed's file, by its data type. */
+const getStorageSubdirForDataType = (dataType) => {
+    switch (normalizeDataType(dataType ?? undefined)) {
+        case 'Image':
+            return 'images';
+        case 'Html':
+            return 'html';
+        case 'Json':
+            return 'json';
+        case 'File':
+        default:
+            // Unknown types are generic files; `images/` is only for what the SDK knows is an image.
+            return 'files';
+    }
+};
+/**
+ * Subdirectory (relative to the files root, no leading slash) for an ItemStorage property's file:
+ * its model's `storage.path` (`localStorageDir`), else `files`.
+ */
+const getItemStorageSubdir = (localStorageDir) => (localStorageDir ?? '').replace(/^\/+/, '').replace(/\/+$/, '') || 'files';
+/**
+ * File name a local save gives an ItemStorage property: `<seedUid or seedLocalId><extension>`
+ * (see saveItemStorage). Downloaded content is named after its transaction instead
+ * (`<txId><extension>`, see syncDbWithEas), which is what the metadata row's refResolvedValue says.
+ */
+const getItemStorageLocalFileName = (seedId, filenameSuffix) => `${seedId}${filenameSuffix ?? ''}`;
+
 /**
  * Name of a new Image or File seed's file in the shared `images/` or `files/` folder. Uploads keep
  * their own name (and so their extension, which publish reads for the content type), prefixed with
@@ -2946,6 +4726,52 @@ function storageFileName(kind, seedLocalId, content) {
     return extension ? `${seedLocalId}.${extension}` : seedLocalId;
 }
 
+const isFile = async (path) => {
+    try {
+        const fs = await BaseFileManager.getFs();
+        return (await fs.promises.stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * A file in `subdir` (relative to the files root) for a stored reference: the file of that exact
+ * name, else the first whose name contains one of `needles` (a downloaded file is named after its
+ * transaction id, sometimes with an extension). Folders (an image's size variants) don't count.
+ */
+async function findFileInDir(subdir, needles) {
+    const wanted = needles.filter((n) => !!n);
+    if (wanted.length === 0)
+        return undefined;
+    for (const needle of wanted) {
+        const exact = BaseFileManager.getFilesPath(subdir, needle);
+        if ((await BaseFileManager.pathExists(exact)) && (await isFile(exact)))
+            return exact;
+    }
+    const dirPath = BaseFileManager.getFilesPath(subdir);
+    if (!(await BaseFileManager.pathExists(dirPath)))
+        return undefined;
+    const fs = await BaseFileManager.getFs();
+    const path = BaseFileManager.getPathModule();
+    const names = await fs.promises.readdir(dirPath);
+    for (const needle of wanted) {
+        for (const name of names) {
+            if (!path.basename(name).includes(needle))
+                continue;
+            const candidate = BaseFileManager.getFilesPath(subdir, name);
+            if (await isFile(candidate))
+                return candidate;
+        }
+    }
+    return undefined;
+}
+
+var findFile = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    findFileInDir: findFileInDir
+});
+
 /** Which kind of file holds a property's value, from its definition, else the row's `refSeedType`. */
 function storedValueKind(def, row) {
     if (def?.storageType === 'ItemStorage')
@@ -3005,7 +4831,7 @@ async function resolveStorageRef(kind, row) {
     }
     if (kind === 'html') {
         if (!out.refResolvedValue && out.propertyValue) {
-            const { resolveHtmlStorageSeedLocalId } = await import('./readHtmlBodyForStorageSeed-B7HgPmq6.js');
+            const { resolveHtmlStorageSeedLocalId } = await import('./readHtmlBodyForStorageSeed-Cva1DPzE.js');
             const localId = await resolveHtmlStorageSeedLocalId(out.propertyValue);
             if (localId)
                 out.refResolvedValue = `${localId}.html`;
@@ -3054,7 +4880,7 @@ async function resolveStorageDisplay(kind, row, options = {}) {
             }
         }
         if (!renderValue && options.fetch && ref.propertyValue) {
-            const { readHtmlBodyForStorageSeedPropertyValue } = await import('./readHtmlBodyForStorageSeed-B7HgPmq6.js');
+            const { readHtmlBodyForStorageSeedPropertyValue } = await import('./readHtmlBodyForStorageSeed-Cva1DPzE.js');
             renderValue = await readHtmlBodyForStorageSeedPropertyValue(ref.propertyValue);
         }
         return { ref, filePath, renderValue };
@@ -3066,16 +4892,12 @@ async function resolveStorageDisplay(kind, row, options = {}) {
         : BaseFileManager.pathExists(BaseFileManager.getFilesPath(dir, name)).then((exists) => exists ? BaseFileManager.getFilesPath(dir, name) : undefined);
     // ensureImageLocal also makes the smallest size variant when the original is already there
     if (kind === 'image' && options.fetch) {
-        const _mod_1 = await import('./tabEvents-DT5ez6io.js');
-        const _ns_1 = _mod_1.bo;
-        const { ensureImageLocal } = _ns_1;
+        const { ensureImageLocal } = await import('./ensureImageLocal-B6suz6FC.js');
         await ensureImageLocal({ transactionId: name, fileName: name, widths: [ImageSize.EXTRA_SMALL] });
     }
     let filePath = await find();
     if (!filePath && kind === 'file' && options.fetch) {
-        const _mod_2 = await import('./tabEvents-DT5ez6io.js');
-        const _ns_2 = _mod_2.bm;
-        const { downloadTransactionIdWithDedupe } = _ns_2;
+        const { downloadTransactionIdWithDedupe } = await import('./download-DHWUPLlK.js');
         await downloadTransactionIdWithDedupe(name);
         filePath = await find();
     }
@@ -3094,7 +4916,7 @@ var resolve = /*#__PURE__*/Object.freeze({
     storedValueKind: storedValueKind
 });
 
-const logger$5 = debug('seedSdk:property:actors:hydrateFromDb');
+const logger$4 = debug('seedSdk:property:actors:hydrateFromDb');
 /**
  * Re-reads a loaded property (the `rehydrateFromDb` event): its current row with the pending
  * outbox value over it (currentPropertyRow), its recorded conflict, and an Image, File or Html
@@ -3147,7 +4969,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
                 }
             }
             catch (e) {
-                logger$5(`[hydrateFromDb] ${kind} file resolution error`, e);
+                logger$4(`[hydrateFromDb] ${kind} file resolution error`, e);
             }
         }
         const propertyValue = propertyRecordSchema && normalizedDataType === 'List' && typeof row.propertyValue === 'string'
@@ -4070,14 +5892,14 @@ const evictionLog = {
     },
 };
 
-const logger$4 = debug('seedSdk:itemProperty:loadProperty');
+const logger$3 = debug('seedSdk:itemProperty:loadProperty');
 /**
  * Load a property's value and definition: its current row (with a pending outbox value over it,
  * ADR 0019), else only its definition, for a property with no row yet.
  */
 async function loadProperty(context) {
     const { seedLocalId, seedUid, propertyName, versionLocalId } = context;
-    logger$4(`loadOrCreateProperty called for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
+    logger$3(`loadOrCreateProperty called for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
     if (!seedLocalId && !seedUid) {
         throw new Error('seedLocalId or seedUid is required');
     }
@@ -4106,9 +5928,7 @@ async function loadProperty(context) {
         const modelNameForNew = context.modelName;
         if (modelNameForNew) {
             try {
-                const _mod_3 = await import('./tabEvents-DT5ez6io.js');
-                const _ns_3 = _mod_3.bh;
-                const { resolveItemModelFileId, modelNameForType } = _ns_3;
+                const { resolveItemModelFileId, modelNameForType } = await Promise.resolve().then(function () { return resolveModelRecord$1; });
                 const itemModelFileId = await resolveItemModelFileId({
                     modelFileId: context.modelFileId,
                     seedLocalId,
@@ -4123,10 +5943,10 @@ async function loadProperty(context) {
                 });
             }
             catch (error) {
-                logger$4(`Metadata not found: no definition for propertyName "${propertyName}": ${error}`);
+                logger$3(`Metadata not found: no definition for propertyName "${propertyName}": ${error}`);
             }
         }
-        logger$4(`Metadata not found in database for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}`);
+        logger$3(`Metadata not found in database for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}`);
         return {
             propertyName,
             propertyValue: context.propertyValue,
@@ -4146,9 +5966,7 @@ async function loadProperty(context) {
     // Load propertyRecordSchema from database to make ItemProperty independent from Model
     let propertyRecordSchema = undefined;
     // Model names are only unique per schema: pin lookups to the item's own model row.
-    const _mod_4 = await import('./tabEvents-DT5ez6io.js');
-    const _ns_4 = _mod_4.bh;
-    const { resolveItemModelFileId, modelNameForType } = _ns_4;
+    const { resolveItemModelFileId, modelNameForType } = await Promise.resolve().then(function () { return resolveModelRecord$1; });
     const modelFileId = await resolveItemModelFileId({
         modelFileId: context.modelFileId,
         seedLocalId: seedLocalId ?? metadataRecord.seedLocalId,
@@ -4172,7 +5990,7 @@ async function loadProperty(context) {
         timing.mark('model schema');
     }
     catch (error) {
-        logger$4(`Error loading the definition of "${propertyName}": ${error}`);
+        logger$3(`Error loading the definition of "${propertyName}": ${error}`);
         // Continue without propertyRecordSchema
     }
     // A file's display: a session URL for an Image or File, the text of an Html body, fetched when
@@ -4204,7 +6022,7 @@ async function loadProperty(context) {
             }
         }
         catch (e) {
-            logger$4(`Failed to resolve the ${kind} file for ${propertyName}: ${e}`);
+            logger$3(`Failed to resolve the ${kind} file for ${propertyName}: ${e}`);
         }
     }
     let propertyValueOut = metadataRecord.propertyValue || undefined;
@@ -4251,13 +6069,13 @@ async function loadPropertyDefinition(db, { propertyId, modelName, modelFileId,
     }
     if (!modelName)
         return undefined;
-    const { loadModelPropertyRecordSchemas } = await import('./modelPropertyRecordSchemas-DEe-lYhn.js');
+    const { loadModelPropertyRecordSchemas } = await import('./modelPropertyRecordSchemas-CEac3FB8.js');
     const definition = (await loadModelPropertyRecordSchemas(modelName, modelFileId, db)).get(propertyName);
     if (definition)
         return definition;
-    const _mod_5 = await import('./errors-CnT0fSMK.js');
-    const _ns_5 = _mod_5.a4;
-    const { Model } = _ns_5;
+    const _mod_2 = await import('./publishErrors-DZXDX3B6.js');
+    const _ns_2 = _mod_2.am;
+    const { Model } = _ns_2;
     const { modelPropertiesToObject } = await Promise.resolve().then(function () { return model; });
     // Try the name first ("post" -> "Post"); then findByModelType for names with spaces ("new_model" -> "New model")
     let model$1 = Model.resolve(modelName, { modelFileId });
@@ -4266,7 +6084,7 @@ async function loadPropertyDefinition(db, { propertyId, modelName, modelFileId,
     }
     const unwritten = model$1?.properties?.length ? modelPropertiesToObject(model$1.properties)[propertyName] : undefined;
     if (unwritten)
-        logger$4(`No row yet: in-memory definition of "${propertyName}" from Model ${modelName}`);
+        logger$3(`No row yet: in-memory definition of "${propertyName}" from Model ${modelName}`);
     return unwritten;
 }
 
@@ -4365,7 +6183,7 @@ function whenValidationLoaded() {
     // neutralizes the minified chunk-export read (`.then(n => n._)`) in this form
     validationLoading ?? (validationLoading = (async () => {
         try {
-            const { SchemaValidationService } = await import('./SchemaValidationService-CieGrj5c.js');
+            const { SchemaValidationService } = await import('./SchemaValidationService-Dc-lpFQX.js');
             validationService = new SchemaValidationService();
         }
         finally {
@@ -4600,17 +6418,13 @@ hints = {}) => {
     }
     try {
         if (hints.propertyId != null) {
-            const _mod_6 = await import('./tabEvents-DT5ez6io.js');
-            const _ns_6 = _mod_6.bi;
-            const { getPropertyDefinition } = _ns_6;
+            const { getPropertyDefinition } = await Promise.resolve().then(function () { return propertyDefinition; });
             const definition = await getPropertyDefinition(hints.propertyId);
             if (definition)
                 return definition;
         }
-        const _mod_7 = await import('./tabEvents-DT5ez6io.js');
-        const _ns_7 = _mod_7.bh;
-        const { resolveItemModelFileId } = _ns_7;
-        const { getModelPropertyDefinitions, resolvePropertyKey } = await import('./property-iNW1N3vm.js');
+        const { resolveItemModelFileId } = await Promise.resolve().then(function () { return resolveModelRecord$1; });
+        const { getModelPropertyDefinitions, resolvePropertyKey } = await import('./property-4jSqHieb.js');
         const modelFileId = (await resolveItemModelFileId(hints)) ?? undefined;
         const name = modelName || ((await modelTypeToModelName(modelType)) ?? '');
         // An ambiguous bare name reads nothing here; the in-memory model below may still know it
@@ -4618,9 +6432,9 @@ hints = {}) => {
         const key = resolvePropertyKey(definitions, propertyName);
         if (key)
             return definitions[key];
-        const _mod_8 = await import('./errors-CnT0fSMK.js');
-        const _ns_8 = _mod_8.a4;
-        const { Model } = _ns_8;
+        const _mod_3 = await import('./publishErrors-DZXDX3B6.js');
+        const _ns_3 = _mod_3.am;
+        const { Model } = _ns_3;
         const { modelPropertiesToObject } = await Promise.resolve().then(function () { return model; });
         let model$1 = modelName ? Model.peekByName(modelName) : undefined;
         if (!model$1?.properties?.length && modelType)
@@ -4639,12 +6453,10 @@ hints = {}) => {
 const modelTypeToModelName = async (modelType) => {
     if (!modelType)
         return undefined;
-    const _mod_9 = await import('./tabEvents-DT5ez6io.js');
-    const _ns_9 = _mod_9.bh;
-    const { modelNameForType } = _ns_9;
+    const { modelNameForType } = await Promise.resolve().then(function () { return resolveModelRecord$1; });
     return modelNameForType(modelType).catch(() => undefined);
 };
-const logger$3 = debug('seedSdk:property:class');
+const logger$2 = debug('seedSdk:property:class');
 // Define tracked properties for the Proxy
 // These properties will be read from/written to the actor context
 const TRACKED_PROPERTIES$1 = [
@@ -4776,7 +6588,7 @@ class ItemProperty {
                         serviceInput.propertyValue = JSON.parse(propertyValue);
                     }
                     catch (e) {
-                        logger$3('List property value is not JSON', e);
+                        logger$2('List property value is not JSON', e);
                     }
                 }
             }
@@ -4803,7 +6615,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await import('./index-DXRhFg1N.js');
+            const schemaMod = await import('./index-CmNqUKQN.js');
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -4909,7 +6721,7 @@ class ItemProperty {
                     }
                 }
                 catch (e) {
-                    logger$3(`[ItemProperty] [${context.seedLocalId}] [${context.propertyName}] [storageType] error`, e);
+                    logger$2(`[ItemProperty] [${context.seedLocalId}] [${context.propertyName}] [storageType] error`, e);
                     renderValue = isHtml ? undefined : 'No file found';
                 }
             }
@@ -4959,7 +6771,7 @@ class ItemProperty {
         });
         this._service.start();
         // Assignments check values synchronously (planPropertyWrite)
-        whenValidationLoaded().catch((error) => logger$3('[ItemProperty] loading validation', error));
+        whenValidationLoaded().catch((error) => logger$2('[ItemProperty] loading validation', error));
         onEntityTeardown(this, () => {
             this._subscription?.unsubscribe();
             revokeHeldObjectUrls(this._service);
@@ -5016,9 +6828,9 @@ class ItemProperty {
                 // The change feed reports writes by stored name: watch every name this property's rows have
                 const propertyNames = [...property.names];
                 if (propertyId != null) {
-                    const _mod_10 = await import('./index-BjWk0x4-.js');
-                    const _ns_10 = _mod_10.s;
-                    const { metadata } = _ns_10;
+                    const _mod_4 = await import('./index-2PaIhvOU.js');
+                    const _ns_4 = _mod_4.s;
+                    const { metadata } = _ns_4;
                     const { eq: eqOp } = await import('drizzle-orm');
                     const stored = await db
                         .selectDistinct({ propertyName: metadata.propertyName })
@@ -5242,9 +7054,7 @@ class ItemProperty {
             const ctx = this._service.getSnapshot().context;
             let modelFileId;
             try {
-                const _mod_11 = await import('./tabEvents-DT5ez6io.js');
-                const _ns_11 = _mod_11.bh;
-                const { resolveItemModelFileId } = _ns_11;
+                const { resolveItemModelFileId } = await Promise.resolve().then(function () { return resolveModelRecord$1; });
                 modelFileId = await resolveItemModelFileId({
                     modelFileId: ctx.modelFileId,
                     seedLocalId: ctx.seedLocalId,
@@ -5561,9 +7371,7 @@ class ItemProperty {
         const propertiesData = await getItemProperties({ seedLocalId, seedUid });
         const instances = [];
         const seenNormalized = new Set();
-        const _mod_12 = await import('./tabEvents-DT5ez6io.js');
-        const _ns_12 = _mod_12.bh;
-        const { resolveItemModelFileId } = _ns_12;
+        const { resolveItemModelFileId } = await Promise.resolve().then(function () { return resolveModelRecord$1; });
         const itemModelFileId = await resolveItemModelFileId({ seedLocalId, seedUid });
         // One lookup per model type, not per property
         const modelNameByType = new Map();
@@ -5583,7 +7391,7 @@ class ItemProperty {
             // (`textId` → `text`, `authorIdentityIds` → `authors`)
             const definitionsKey = JSON.stringify([modelName, modelFileId ?? null]);
             if (modelName && !definitionsByModel.has(definitionsKey)) {
-                const { getModelPropertyDefinitions } = await import('./property-iNW1N3vm.js');
+                const { getModelPropertyDefinitions } = await import('./property-4jSqHieb.js');
                 definitionsByModel.set(definitionsKey, 
                 // No model row: the stored name decides
                 getModelPropertyDefinitions(modelName, { modelFileId }).then(Object.fromEntries, () => ({})));
@@ -5757,7 +7565,7 @@ class ItemProperty {
         const { seedLocalId, propertyName } = this._getSnapshotContext();
         if (!seedLocalId || !propertyName)
             return;
-        const { appendOutboxOpAndWait, markPropertyConflictsResolved, startItemOutbox, throwItemWriteError } = await import('./index-CZMWKXLM.js');
+        const { appendOutboxOpAndWait, markPropertyConflictsResolved, startItemOutbox, throwItemWriteError } = await import('./index-BXTyvnKb.js');
         if (choice === 'remote') {
             startItemOutbox();
             await appendOutboxOpAndWait({
@@ -5821,8 +7629,10 @@ class ItemProperty {
      *   Versions stop showing the value too. Revocation is permanent.
      * @throws ClearNotSupportedError for a Boolean or Date property without `retract`: their EAS types
      *   have no empty value.
+     * @throws EntityUnloadedError when this instance was unloaded; nothing is written.
      */
     async clear(options = {}) {
+        this._assertLoaded('clear');
         const retract = options.retract === true;
         const context = this._getSnapshotContext();
         const dataType = normalizeDataType(this._dataType ?? context.propertyRecordSchema?.dataType);
@@ -5905,9 +7715,7 @@ class ItemProperty {
         context = this._getSnapshotContext();
         if (!context.seedLocalId) {
             // An item known only by its seed uid: its local seed, if it has one
-            const _mod_13 = await import('./tabEvents-DT5ez6io.js');
-            const _ns_13 = _mod_13.bg;
-            const { findSeedRow } = _ns_13;
+            const { findSeedRow } = await Promise.resolve().then(function () { return findSeedRow$1; });
             const seedLocalId = context.seedUid ? (await findSeedRow({ uid: context.seedUid }))?.localId : undefined;
             if (!seedLocalId)
                 throw new Error(`No local seed for the item to save ${context.propertyName} to`);
@@ -5945,7 +7753,7 @@ class ItemProperty {
     /** Waits for an appended op to settle, then shows its row, or the current value if it failed. */
     async _followWrite(write, appended, plan) {
         try {
-            const { getOutboxOps, outboxOpResult, startItemOutbox, waitForOutboxOp } = await import('./index-CZMWKXLM.js');
+            const { getOutboxOps, outboxOpResult, startItemOutbox, waitForOutboxOp } = await import('./index-BXTyvnKb.js');
             startItemOutbox();
             const opId = await appended;
             await waitForOutboxOp(opId);
@@ -6004,7 +7812,7 @@ class ItemProperty {
             this._service.send({ type: 'updateContext', ...outcome.applied, isSaving: false });
             return;
         }
-        const { throwItemWriteError } = await import('./index-CZMWKXLM.js');
+        const { throwItemWriteError } = await import('./index-BXTyvnKb.js');
         let error = outcome.error;
         try {
             throwItemWriteError(outcome.error);
@@ -6012,7 +7820,7 @@ class ItemProperty {
         catch (mapped) {
             error = mapped;
         }
-        await this._showCurrentValue().catch((readError) => logger$3(`[ItemProperty] reading ${this.propertyName} after a failed write`, readError));
+        await this._showCurrentValue().catch((readError) => logger$2(`[ItemProperty] reading ${this.propertyName} after a failed write`, readError));
         if (this._latestWrite !== write || isActorStopped(this._service))
             return;
         this._service.send({
@@ -6139,7 +7947,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-CZMWKXLM.js');
+            const { appendOutboxOpAndWait, startItemOutbox, throwItemWriteError } = await import('./index-BXTyvnKb.js');
             startItemOutbox();
             await appendOutboxOpAndWait({
                 seedLocalId,
@@ -6149,9 +7957,9 @@ class ItemProperty {
             }).catch(throwItemWriteError);
         }
         else if (db) {
-            const _mod_14 = await import('./index-BjWk0x4-.js');
-            const _ns_14 = _mod_14.s;
-            const seedSchemaMod = _ns_14;
+            const _mod_5 = await import('./index-2PaIhvOU.js');
+            const _ns_5 = _mod_5.s;
+            const seedSchemaMod = _ns_5;
             const { metadata } = seedSchemaMod;
             const drizzleMod = await import('drizzle-orm');
             const { and, eq } = drizzleMod;
@@ -6187,7 +7995,7 @@ var ItemProperty$1 = /*#__PURE__*/Object.freeze({
     ItemPropertySaveValidationError: ItemPropertySaveValidationError
 });
 
-const logger$2 = debug('seedSdk:db:read:getSchemaUidForModel');
+const logger$1 = debug('seedSdk:db:read:getSchemaUidForModel');
 /**
  * EAS schema UID of a model's seeds: the in-memory cache, then `model_uids` (written from EAS by
  * startup and sync), then EAS itself. The DB comes before EAS so creating items and saving
@@ -6224,7 +8032,7 @@ const getEasSchemaUidForModel = async (modelName) => {
         });
     }
     catch (error) {
-        logger$2(`EAS schema lookup for model ${modelName} failed (offline?): ${error}`);
+        logger$1(`EAS schema lookup for model ${modelName} failed (offline?): ${error}`);
         return undefined;
     }
     if (easSchemaUid) {
@@ -6270,165 +8078,6 @@ const createSeed = async ({ type, seedUid, modelFileId }, options = {}) => {
     return newSeedLocalId;
 };
 
-/**
- * The publisher a seed's version and property rows take: the seed's own (its `publisher`, else the
- * attester of its stored attestation). Undefined for a draft that belongs to no wallet yet; those
- * rows are then claimed together with their seed (claimUnpublishedDrafts).
- */
-async function getSeedPublisher(seedLocalId, 
-/** The database or transaction to read; the app database by default. */
-db = BaseDb.getAppDb()) {
-    if (!seedLocalId)
-        return undefined;
-    const row = await findSeedRow({ localId: seedLocalId }, db);
-    if (!row)
-        return undefined;
-    return normalizePublisher(resolvePublisherFromSeedRow(row));
-}
-
-const logger$1 = debug('seedSdk:helpers:propertySchemaUid');
-/**
- * UID of the EAS schema a property publishes under, or undefined when EAS has none, the property's
- * type has no EAS type, or the lookup fails. Found UIDs and misses are cached
- * (`getEasSchemaUidForExactDefinition`), so creating an item and then saving its properties asks
- * EAS once per definition. Callers store the UID on the metadata row; publish resolves schemas
- * itself, so a missing one costs nothing there.
- */
-async function lookupPropertySchemaUid(propertyName, propertyDef) {
-    const definition = easSchemaDefinitionForProperty(propertyName, propertyDef);
-    if (!definition)
-        return undefined;
-    try {
-        return await getEasSchemaUidForExactDefinition(definition);
-    }
-    catch (error) {
-        logger$1(`EAS schema lookup for "${definition}" failed (offline?): ${error}`);
-        return undefined;
-    }
-}
-
-var propertySchemaUid = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    lookupPropertySchemaUid: lookupPropertySchemaUid
-});
-
-/** Error thrown when metadata validation fails (e.g. enum violation). */
-class MetadataValidationError extends Error {
-    constructor(message, validationErrors) {
-        super(message);
-        this.validationErrors = validationErrors;
-        this.name = 'MetadataValidationError';
-    }
-}
-/**
- * The EAS schema uid a metadata row of this property takes, from the property's data type and EAS
- * name. Undefined for a data type with no EAS type or when the lookup fails. May call EAS, so run
- * it before a transaction, not inside one.
- */
-/** The property's EAS schema UID from the shared lookup cache (lookupPropertySchemaUid). */
-const resolveMetadataSchemaUid = async (propertyName, propertyRecordSchema) => lookupPropertySchemaUid(propertyName, propertyRecordSchema);
-const createMetadata = async (metadataValues, propertyRecordSchema, options) => {
-    const appDb = options?.db ?? BaseDb.getAppDb();
-    metadataValues.localId = generateId();
-    // A property row belongs to its seed's wallet (none yet for a draft made with no wallet connected).
-    const publisher = await getSeedPublisher(metadataValues.seedLocalId, appDb);
-    if (publisher) {
-        metadataValues.publisher = publisher;
-    }
-    if (!metadataValues.modelType && metadataValues.modelName) {
-        metadataValues.modelType = easName(metadataValues.modelName);
-    }
-    // property_id is the match key (decision D4); the row is written under the property's storage name.
-    const property = await resolveMetadataProperty({
-        propertyId: metadataValues.propertyId,
-        definitionId: propertyRecordSchema?.id,
-        propertyName: metadataValues.propertyName,
-        modelName: metadataValues.modelName ?? metadataValues.modelType,
-        modelFileId: options?.modelFileId,
-        seedLocalId: metadataValues.seedLocalId,
-        seedUid: metadataValues.seedUid,
-    }, appDb, { onAmbiguousModel: 'none' });
-    if (property) {
-        metadataValues.propertyId = property.id;
-        metadataValues.propertyName = property.storageName;
-    }
-    else if (metadataValues.propertyName && propertyRecordSchema) {
-        metadataValues.propertyName = metadataStorageName(metadataValues.propertyName, propertyRecordSchema);
-    }
-    const isItemStorage = propertyRecordSchema && propertyRecordSchema.storageType === 'ItemStorage';
-    // if (
-    //   propertyRecordSchema &&
-    //   propertyRecordSchema.localStorageDir &&
-    //   isItemStorage
-    // ) {
-    //   const filename = `${metadataValues.seedUid || metadataValues.seedLocalId}${propertyRecordSchema.filenameSuffix}`
-    //   const filePath = path.join(propertyRecordSchema.localStorageDir, filename)
-    //   await fs.promises.writeFile(filePath, metadataValues.propertyValue)
-    //   metadataValues.propertyValue = filename
-    //   metadataValues.refValueType = 'file'
-    // }
-    // Convert propertyValue to string if it's not already (metadata table expects text)
-    if (metadataValues.propertyValue !== undefined && metadataValues.propertyValue !== null) {
-        if (Array.isArray(metadataValues.propertyValue)) {
-            // List values: JSON array is the storage format (String() would give legacy comma-separated ids)
-            metadataValues.propertyValue = JSON.stringify(metadataValues.propertyValue);
-        }
-        else if (typeof metadataValues.propertyValue !== 'string') {
-            metadataValues.propertyValue = String(metadataValues.propertyValue);
-        }
-    }
-    // Validate against property validation rules (enum, pattern, minLength, maxLength) unless skipped
-    if (!options?.skipValidation &&
-        propertyRecordSchema?.validation &&
-        metadataValues.propertyValue != null &&
-        metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await import('./SchemaValidationService-CieGrj5c.js');
-        const validationService = new SchemaValidationService();
-        const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
-            ? normalizeDataType(String(propertyRecordSchema.refValueType))
-            : undefined);
-        if (!validationResult.isValid && validationResult.errors.length > 0) {
-            const validationErrors = validationResult.errors.map((e) => ({
-                field: e.field,
-                message: e.message,
-                code: e.code,
-            }));
-            const message = validationErrors.map((e) => e.message).join('; ');
-            throw new MetadataValidationError(message, validationErrors);
-        }
-    }
-    // With a given db (a transaction), the caller resolves schemaUid first: the lookup may call EAS.
-    // Without one it isn't required for metadata insertion, so a failed lookup leaves it unset.
-    if (!options?.db && !isItemStorage && !metadataValues.schemaUid && metadataValues.propertyName) {
-        const schemaUid = await resolveMetadataSchemaUid(metadataValues.propertyName, propertyRecordSchema);
-        if (schemaUid)
-            metadataValues.schemaUid = schemaUid;
-    }
-    let inserted;
-    try {
-        inserted = await appDb
-            .insert(metadata)
-            .values({
-            ...metadataValues,
-            // Stamped here: a value carried in metadataValues would otherwise win over the column default.
-            createdAt: Date.now(),
-            updatedAt: Date.now(),
-        })
-            .returning();
-    }
-    catch (error) {
-        // Drizzle's message is the full SQL; the driver error that explains it is only on `cause`.
-        const cause = error?.cause;
-        const reason = cause instanceof Error ? cause.message : cause != null ? String(cause) : undefined;
-        throw new Error(`Failed to insert metadata for property ${metadataValues.propertyName}` +
-            (reason ? `: ${reason}` : `: ${error instanceof Error ? error.message : String(error)}`), { cause: error });
-    }
-    if (!inserted || inserted.length === 0) {
-        throw new Error(`Failed to insert metadata record for property ${metadataValues.propertyName}`);
-    }
-    return inserted[0];
-};
-
 /**
  * Convert Model.properties array to object format (for backward compatibility)
  * This replaces the old model.schema getter
@@ -6476,9 +8125,9 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
     }
     const seedType = easName(modelName);
     // Dynamic import to break circular dependency
-    const _mod_15 = await import('./errors-CnT0fSMK.js');
-    const _ns_15 = _mod_15.a4;
-    const modelMod = _ns_15;
+    const _mod_6 = await import('./publishErrors-DZXDX3B6.js');
+    const _ns_6 = _mod_6.am;
+    const modelMod = _ns_6;
     const { Model } = modelMod;
     const label = `createNewItem ${modelName}`;
     const model = await timed(`${label} model`, () => Model.resolveAsync(modelName, { modelFileId }));
@@ -6504,7 +8153,7 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
         const propertyRecordSchema = propertySchemas?.[propertyName];
         if (!propertyRecordSchema || propertyRecordSchema.storageType === 'ItemStorage')
             return;
-        schemaUids.set(propertyName, await resolveMetadataSchemaUid(listRelationEasPropertyName(propertyName, propertyRecordSchema) ?? propertyName, propertyRecordSchema));
+        schemaUids.set(propertyName, await lookupPropertySchemaUid(listRelationEasPropertyName(propertyName, propertyRecordSchema) ?? propertyName, propertyRecordSchema));
     })));
     const rows = [];
     const stagedPaths = [];
@@ -6534,7 +8183,7 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
             }
             rows.push({ propertyName, propertyValue, propertyRecordSchema, schemaUid: schemaUids.get(propertyName) });
         }
-        const { appendOutboxOpAndWait, startItemOutbox } = await import('./index-CZMWKXLM.js');
+        const { appendOutboxOpAndWait, startItemOutbox } = await import('./index-BXTyvnKb.js');
         startItemOutbox();
         const fields = await timed(`${label} seed fields`, () => resolveNewSeedFields(seedType));
         const applied = await timed(`${label} outbox apply`, () => appendOutboxOpAndWait({
@@ -6553,9 +8202,9 @@ 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_16 = await import('./errors-CnT0fSMK.js');
-        const _ns_16 = _mod_16.a7;
-        const { deleteFiles } = _ns_16;
+        const _mod_7 = await import('./publishErrors-DZXDX3B6.js');
+        const _ns_7 = _mod_7.ap;
+        const { deleteFiles } = _ns_7;
         await deleteFiles(stagedPaths);
         throw error;
     }
@@ -6629,16 +8278,16 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
         };
         // The model's property definitions from their rows; a model created in this session whose
         // rows aren't written yet gives its in-memory ones
-        const { getModelPropertyDefinitions } = await import('./property-iNW1N3vm.js');
+        const { getModelPropertyDefinitions } = await import('./property-4jSqHieb.js');
         let propertySchemas = Object.fromEntries(await getModelPropertyDefinitions(modelName, modelScope).catch((err) => {
             logger(`No property definitions for ${modelName}: ${err}`);
             return [];
         }));
         if (Object.keys(propertySchemas).length === 0) {
             const { modelPropertiesToObject } = await Promise.resolve().then(function () { return model; });
-            const _mod_17 = await import('./errors-CnT0fSMK.js');
-            const _ns_17 = _mod_17.a4;
-            const { Model } = _ns_17;
+            const _mod_8 = await import('./publishErrors-DZXDX3B6.js');
+            const _ns_8 = _mod_8.am;
+            const { Model } = _ns_8;
             const model$1 = Model.resolve(modelName, modelScope);
             if (model$1?.properties?.length)
                 propertySchemas = modelPropertiesToObject(model$1.properties);
@@ -6664,7 +8313,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-DXRhFg1N.js');
+                    const schemaMod = await import('./index-CmNqUKQN.js');
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -7047,9 +8696,9 @@ const getModel = () => {
         // the fragile `import(...).then(n => n.X)` chunk-namespace pattern.
         if (!modelImportPromise) {
             modelImportPromise = (async () => {
-                const _mod_18 = await import('./errors-CnT0fSMK.js');
-                const _ns_18 = _mod_18.a4;
-                const mod = _ns_18;
+                const _mod_9 = await import('./publishErrors-DZXDX3B6.js');
+                const _ns_9 = _mod_9.am;
+                const mod = _ns_9;
                 ModelClass = mod.Model;
                 return mod;
             })();
@@ -7248,16 +8897,16 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const _mod_19 = await import('./getPublishUploads-DivYpgNw.js');
-            const _ns_19 = _mod_19.q;
-            const getPublishUploadsMod = _ns_19;
+            const _mod_10 = await import('./publishErrors-DZXDX3B6.js');
+            const _ns_10 = _mod_10.aq;
+            const getPublishUploadsMod = _ns_10;
             const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this, options);
         };
         this.getPublishPayload = async (uploadedTransactions, options) => {
-            const _mod_20 = await import('./getPublishPayload-DKuEaq96.js');
-            const _ns_20 = _mod_20.c;
-            const getPublishPayloadMod = _ns_20;
+            const _mod_11 = await import('./getPublishPayload-Dd3HCYeI.js');
+            const _ns_11 = _mod_11.b;
+            const getPublishPayloadMod = _ns_11;
             const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions, options);
         };
@@ -7585,9 +9234,7 @@ class Item {
         if (!props.modelName && props.type) {
             // The model the seed's type names (its easName, at the model's nameMatch level): `blog_post`
             // finds "Blog Post". No match leaves the type, which then fails as an unknown model.
-            const _mod_21 = await import('./tabEvents-DT5ez6io.js');
-            const _ns_21 = _mod_21.bh;
-            const { resolveModelRecordByNameOrType } = _ns_21;
+            const { resolveModelRecordByNameOrType } = await Promise.resolve().then(function () { return resolveModelRecord$1; });
             const model = await resolveModelRecordByNameOrType(props.type, {
                 modelFileId: props.modelFileId,
                 schemaName: props.schemaName,
@@ -7649,18 +9296,16 @@ 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_22 = await import('./tabEvents-DT5ez6io.js');
-            const _ns_22 = _mod_22.bh;
-            const { resolveModelRecord } = _ns_22;
+            const { resolveModelRecord } = await Promise.resolve().then(function () { return resolveModelRecord$1; });
             const modelRecord = await resolveModelRecord(props.modelName, {
                 modelFileId: props.modelFileId ?? modelInstance?.id,
                 schemaName: schemaName ?? modelInstance?.schemaName,
             });
             const modelRecords = modelRecord ? [modelRecord] : [];
             if (!modelRecord) {
-                const _mod_23 = await import('./errors-CnT0fSMK.js');
-                const _ns_23 = _mod_23.a8;
-                const { UnknownModelError } = _ns_23;
+                const _mod_12 = await import('./publishErrors-DZXDX3B6.js');
+                const _ns_12 = _mod_12.ar;
+                const { UnknownModelError } = _ns_12;
                 throw new UnknownModelError(props.modelName, schemaName ?? modelInstance?.schemaName);
             }
             if (modelRecord?.schemaFileId) {
@@ -7669,9 +9314,7 @@ 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_24 = await import('./tabEvents-DT5ez6io.js');
-                const _ns_24 = _mod_24.bh;
-                const { getModelSchemaName } = _ns_24;
+                const { getModelSchemaName } = await Promise.resolve().then(function () { return resolveModelRecord$1; });
                 const modelSchemaName = await getModelSchemaName(modelRecord.id, db);
                 if (modelSchemaName) {
                     props.schemaName = modelSchemaName;
@@ -7774,7 +9417,7 @@ class Item {
             /* best-effort cache cleanup */
         }
         try {
-            const { appendOutboxOpAndWait, deleteFiles, startItemOutbox } = await import('./index-CZMWKXLM.js');
+            const { appendOutboxOpAndWait, deleteFiles, startItemOutbox } = await import('./index-BXTyvnKb.js');
             startItemOutbox();
             const applied = await appendOutboxOpAndWait({
                 seedLocalId,
@@ -7797,9 +9440,9 @@ class Item {
         for (const [propertyName, value] of pipelineValues) {
             const property = await this.waitForPropertyInstance(item, propertyName, timeout);
             if (!property) {
-                const _mod_25 = await import('./errors-CnT0fSMK.js');
-                const _ns_25 = _mod_25.a8;
-                const { ItemCreateError } = _ns_25;
+                const _mod_13 = await import('./publishErrors-DZXDX3B6.js');
+                const _ns_13 = _mod_13.ar;
+                const { ItemCreateError } = _ns_13;
                 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 });
             }
             // setValue, not the setter: the setter skips the save when the value is already in context.
@@ -7809,16 +9452,16 @@ class Item {
             }
             catch (error) {
                 if (error instanceof ItemPropertySaveValidationError) {
-                    const _mod_26 = await import('./errors-CnT0fSMK.js');
-                    const _ns_26 = _mod_26.a8;
-                    const { ItemCreateValidationError } = _ns_26;
+                    const _mod_14 = await import('./publishErrors-DZXDX3B6.js');
+                    const _ns_14 = _mod_14.ar;
+                    const { ItemCreateValidationError } = _ns_14;
                     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_27 = await import('./errors-CnT0fSMK.js');
-                const _ns_27 = _mod_27.a8;
-                const { ItemCreateError } = _ns_27;
+                const _mod_15 = await import('./publishErrors-DZXDX3B6.js');
+                const _ns_15 = _mod_15.ar;
+                const { ItemCreateError } = _ns_15;
                 throw new ItemCreateError(`Item.create: failed to save ${item.modelName}.${propertyName} for item ${item.seedLocalId}: ` +
                     (error instanceof Error ? error.message : String(error)), { code: 'save_failed', modelName: item.modelName, property: propertyName, seedLocalId: item.seedLocalId, cause: error });
             }
@@ -7994,9 +9637,9 @@ class Item {
         if (!appDb || Item.cache.size === 0) {
             return;
         }
-        const _mod_28 = await import('./index-BjWk0x4-.js');
-        const _ns_28 = _mod_28.s;
-        const { metadata } = _ns_28;
+        const _mod_16 = await import('./index-2PaIhvOU.js');
+        const _ns_16 = _mod_16.s;
+        const { metadata } = _ns_16;
         const { eq, and } = await import('drizzle-orm');
         await Promise.all(Item.cache.instances().map(async (instance) => {
             try {
@@ -8106,11 +9749,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_29 = await import('./errors-CnT0fSMK.js');
-        const _ns_29 = _mod_29.a8;
-        const { ItemCreateValidationError } = _ns_29;
-        const { getModelPropertyDefinitions, resolvePropertyKey } = await import('./property-iNW1N3vm.js');
-        const { SchemaValidationService } = await import('./SchemaValidationService-CieGrj5c.js');
+        const _mod_17 = await import('./publishErrors-DZXDX3B6.js');
+        const _ns_17 = _mod_17.ar;
+        const { ItemCreateValidationError } = _ns_17;
+        const { getModelPropertyDefinitions, resolvePropertyKey } = await import('./property-4jSqHieb.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-Dc-lpFQX.js');
         const validationService = new SchemaValidationService();
         const modelName = props.modelName;
         const known = new Set(propertyNames);
@@ -8464,9 +10107,9 @@ class Item {
                 itemActor.send(event);
             };
             try {
-                const _mod_30 = await import('./index-BjWk0x4-.js');
-                const _ns_30 = _mod_30.s;
-                const seedSchemaMod = _ns_30;
+                const _mod_18 = await import('./index-2PaIhvOU.js');
+                const _ns_18 = _mod_18.s;
+                const seedSchemaMod = _ns_18;
                 const { seeds, metadata } = seedSchemaMod;
                 const drizzleMod = await import('drizzle-orm');
                 const { eq, and } = drizzleMod;
@@ -8478,9 +10121,7 @@ class Item {
                     return;
                 }
                 // Query initial seed and version data
-                const _mod_31 = await import('./tabEvents-DT5ez6io.js');
-                const _ns_31 = _mod_31.bg;
-                const { findSeedRow } = _ns_31;
+                const { findSeedRow } = await Promise.resolve().then(function () { return findSeedRow$1; });
                 const seed = await findSeedRow({ localId: seedLocalId, uid: seedUid }, db);
                 if (!seed) {
                     logger(`[Item._setupLiveQuerySubscription] Seed not found for seedLocalId: ${seedLocalId}`);
@@ -8779,7 +10420,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-CZMWKXLM.js');
+            const { appendOutboxOpAndWait, startItemOutbox, throwItemWriteError } = await import('./index-BXTyvnKb.js');
             startItemOutbox();
             await appendOutboxOpAndWait({
                 seedLocalId: context.seedLocalId,
@@ -8806,5 +10447,5 @@ var Item$1 = /*#__PURE__*/Object.freeze({
     Item: Item
 });
 
-export { runEntityLoad as $, getCorrectId as A, isItemOwned as B, ClearNotSupportedError as C, isPublishedSeedRef as D, propertyKeyFromStoredName as E, currentPropertyRows as F, metadataPropertyGroupKeys as G, compareMetadataRowsLatestFirst as H, Item as I, readMetadataPropertiesById as J, isPublishedMetadataRow as K, getLatestPublishedVersionRow as L, isVersionRevoked as M, readModelMetadataProperties as N, OUTBOX_DEFER_MS as O, metadataPropertyNameForms as P, currentPropertyRow as Q, getLatestVersionRow as R, parseListPropertyValueFromStorage as S, applyContextUpdate as T, isInternalUpdate as U, evictionLog as V, holdChild as W, isEntityTornDown as X, sameEntity as Y, DEFAULT_READY_TIMEOUT_MS as Z, createReactiveProxy as _, appendOutboxOpAndWait as a, createSeed as a$, waitForEntityReady as a0, evictEntities as a1, EntityUnloadedError as a2, entityStatus as a3, releaseEntity as a4, destroyEntity as a5, EntityCache as a6, getGetAdditionalSyncAddresses as a7, modelPropertiesToObject as a8, listRelationEasPropertyName as a9, getPublishExecutor as aA, getRevokeExecutor as aB, getUploadExecutor as aC, getVersionData as aD, isLocalUnsealedDraft as aE, isSeedRowOwned as aF, localUnsealedDraftSql as aG, ownedPublisherSql as aH, ownedSeedsSql as aI, pickLatestMetadataRowPerProperty as aJ, placeholderUidSql as aK, propertyMachine as aL, publisherInAddressListSql as aM, publisherIsInOwnedSet as aN, setAdditionalSyncAddresses as aO, setGetPublisherForNewSeeds as aP, setPublishExecutor as aQ, setRevokeExecutor as aR, setUploadExecutor as aS, getSeedPublisher as aT, deleteStagedFile as aU, storageFileName as aV, STORAGE_SUBDIR as aW, resolveNewSeedFields as aX, lookupPropertySchemaUid as aY, stageStorageContent as aZ, requireStagedFile as a_, easPropertyNameForPublish as aa, metadataStorageName as ab, resolveMetadataPropertyId as ac, storageSeedTransactionId as ad, storageUploadPath as ae, matchMetadataProperty as af, metadataRowsOfProperty as ag, METADATA_LATEST_FIRST_ORDER_SQL as ah, getEasSchemaUidForModel as ai, isStorageSeedRef as aj, isActorStopped as ak, differsFromOriginals as al, onEntityTeardown as am, getStorageTransactionIdForSeedUid as an, latestVersionOrder as ao, otherVersionRowsWithUid as ap, mergeVersionRowInto as aq, findMetadataPropertyByName as ar, storedValueKind as as, resolveStorageDisplay as at, resolvePublisherFromSeedRow as au, PUBLISH_NOT_CONFIGURED_MESSAGE as av, createNewItem as aw, getArweaveUrlForTransaction as ax, getGetPublisherForNewSeeds as ay, getMetadataLatest as az, waitForPendingOutboxOps as b, createMetadata as b0, storageValueRowOf as b1, findSetConflict as b2, recordPropertyEdit as b3, setEntityUnloadGraceMs as b4, stopOutbox as b5, evictAllEntities as b6, currentPropertyRow$1 as b7, resolve as b8, conflicts as b9, propertySchemaUid as ba, Item$1 as bb, OUTBOX_MAX_ATTEMPTS as c, OUTBOX_PRUNE_AFTER_MS as d, OUTBOX_PRUNE_FAILED_AFTER_MS as e, OUTBOX_RETRY_DELAYS_MS as f, getOutboxOps as g, OutboxOpDeferredError as h, OutboxOpFailedError as i, OutboxOpRejectedError as j, appendOutboxOp as k, drainOutbox as l, markPropertyConflictsResolved as m, getItemConflicts as n, outboxOpResult as o, getPendingSetValue as p, getPropertyConflict as q, outboxOpValue as r, pruneOutbox as s, registerOutboxApplier as t, startOutbox as u, ItemProperty as v, waitForOutboxOp as w, ItemPropertySaveValidationError as x, OwnershipError as y, assertItemOwned as z };
-//# sourceMappingURL=Item-oPnmIehk.js.map
+export { entityStatus as $, AmbiguousModelError as A, metadataPropertyGroupKeys as B, ClearNotSupportedError as C, compareMetadataRowsLatestFirst as D, EntityUnloadedError as E, readMetadataPropertiesById as F, isPublishedMetadataRow as G, getLatestPublishedVersionRow as H, Item as I, writeInBatches as J, getItemStorageSubdir as K, getAllAddressesFromDb as L, whenDbReady as M, applyContextUpdate as N, OUTBOX_PRUNE_AFTER_MS as O, isInternalUpdate as P, evictionLog as Q, addSchemaToDb as R, StagedValueMissingError as S, holdChild as T, isEntityTornDown as U, sameEntity as V, DEFAULT_READY_TIMEOUT_MS as W, createReactiveProxy as X, runEntityLoad as Y, waitForEntityReady as Z, evictEntities as _, appendOutboxOpAndWait as a, normalizeAddressConfig as a$, inDefinitionsTransaction as a0, releaseEntity as a1, destroyEntity as a2, isClientReady as a3, upsertSchemaRow as a4, broadcastSchemasInvalidate as a5, EntityCache as a6, normalizePublisher as a7, chunkValues as a8, rowsPerInsert as a9, addCachedPropertyRefresher as aA, getStorageTransactionIdForSeedUid as aB, latestVersionOrder as aC, otherVersionRowsWithUid as aD, mergeVersionRowInto as aE, isVersionRevoked as aF, findMetadataPropertyByName as aG, readModelMetadataProperties as aH, parseListPropertyValueFromStorage as aI, findSeedRow as aJ, resolvePublisherFromSeedRow as aK, ClientManagerState as aL, MachineIds as aM, PUBLISH_NOT_CONFIGURED_MESSAGE as aN, createNewItem as aO, getAddressesForItemsFilter as aP, getArweaveUrlForTransaction as aQ, getGetPublisherForNewSeeds as aR, getMetadataLatest as aS, getPublishExecutor as aT, getRevokeExecutor as aU, getUploadExecutor as aV, getVersionData as aW, isClientReadySnapshot as aX, isLocalUnsealedDraft as aY, isSeedRowOwned as aZ, localUnsealedDraftSql as a_, loadNameMatchLevels as aa, getGetAdditionalSyncAddresses as ab, findSeedRowsByUid as ac, normalizeHexAddress as ad, selectInBatches as ae, nameMatchLevels as af, modelPropertiesToObject as ag, listRelationEasPropertyName as ah, easPropertyNameForPublish as ai, metadataStorageName as aj, resolveMetadataPropertyId as ak, getItemStoragePropertiesForModel as al, resolveItemModelFileId as am, matchMetadataProperty as an, metadataRowsOfProperty as ao, METADATA_LATEST_FIRST_ORDER_SQL as ap, getEasSchemaUidForModel as aq, isStorageSeedRef as ar, isActorStopped as as, differsFromOriginals as at, resolveModelRecord as au, definitionOnlyFields as av, persistDefinitionFields as aw, onEntityTeardown as ax, getPropertyDefinition as ay, propertyDefinitionFromRow as az, waitForPendingOutboxOps as b, normalizeAddressList as b0, ownedPublisherSql as b1, ownedSeedsSql as b2, pickLatestMetadataRowPerProperty as b3, placeholderUidSql as b4, propertyMachine as b5, publisherInAddressListSql as b6, publisherIsInOwnedSet as b7, setAdditionalSyncAddresses as b8, setGetPublisherForNewSeeds as b9, getWatchedAddressesFromDb as bA, getOwnedAddressesFromDb as bB, setEntityUnloadGraceMs as bC, stopOutbox as bD, evictAllEntities as bE, registerClientActor as bF, getPropertyDefinitions as bG, metadataPropertyNameForms as bH, currentPropertyRow as bI, resolveModelRecordByNameOrType as bJ, storageSeedTransactionId as bK, storageUploadPath as bL, storedValueKind as bM, resolveStorageDisplay as bN, findSeedRow$1 as bO, resolveModelRecord$1 as bP, propertyDefinition as bQ, definitions as bR, db as bS, currentPropertyRow$1 as bT, propertySchemaUid as bU, findFile as bV, resolve as bW, conflicts as bX, Item$1 as bY, setPublishExecutor as ba, setRevokeExecutor as bb, setUploadExecutor as bc, writeModelToDb as bd, writePropertyToDb as be, currentNameMatchLevels as bf, renameModelInDb as bg, insertModelStubs as bh, warnOnInvalidNameMatch as bi, refreshCachedProperties as bj, resolveMetadataProperty as bk, lookupPropertySchemaUid as bl, getItemStorageLocalFileName as bm, deleteStagedFile as bn, storageFileName as bo, STORAGE_SUBDIR as bp, resolveNewSeedFields as bq, stageStorageContent as br, requireStagedFile as bs, findSetConflict as bt, recordPropertyEdit as bu, startOutbox as bv, createSeed as bw, storageValueRowOf as bx, getLatestVersionRow as by, ClientManagerEvents as bz, OUTBOX_PRUNE_FAILED_AFTER_MS as c, OutboxOpDeferredError as d, OutboxOpFailedError as e, OutboxOpRejectedError as f, getOutboxOps as g, appendOutboxOp as h, drainOutbox as i, getPendingSetValue as j, outboxOpValue as k, ItemProperty as l, markPropertyConflictsResolved as m, ItemPropertySaveValidationError as n, outboxOpResult as o, pruneOutbox as p, OwnershipError as q, registerOutboxApplier as r, assertItemOwned as s, getCorrectId as t, isItemOwned as u, isPublishedSeedRef as v, waitForOutboxOp as w, propertyKeyFromStoredName as x, findFileInDir as y, currentPropertyRows as z };
+//# sourceMappingURL=Item-BU9wIT7l.js.map