@seedprotocol/sdk 0.6.9 → 0.7.0

package/dist/{db-WbrzEf7c.js → db-BJZN0a0a.js}

@@ -1,8 +1,8 @@
-import { a as BaseDb, c as appState, m as models, i as modelSchemas, p as properties, s as schemas, b as metadata } from './BasePathResolver-B6CKqoKw.js';
+import { m as models, i as modelSchemas, s as schemas, B as BaseDb, r as seeds, p as properties, c as appState, b as metadata } from './BasePathResolver-ndE8XTpw.js';
 import { toSnakeCase } from 'drizzle-orm/casing';
-import { eq, and, isNull } from 'drizzle-orm';
-import { upperFirst, camelCase } from 'lodash-es';
+import { eq, and, inArray, desc, isNull } from 'drizzle-orm';
 import debug from 'debug';
+import { upperFirst, camelCase } from 'lodash-es';
 import 'pluralize';
 import { Type } from '@sinclair/typebox';
 
@@ -214,6 +214,58 @@ const Boolean = () => PropertyConstructor(Property.Boolean());
 const Date$1 = () => PropertyConstructor(Property.Date());
 const Html = (opts) => PropertyConstructor(htmlPropertyFactory(opts));
 
+class SeedEventEmitter {
+    constructor() {
+        this.listeners = new Map();
+    }
+    on(event, listener) {
+        const set = this.listeners.get(event) ?? new Set();
+        set.add(listener);
+        this.listeners.set(event, set);
+        return this;
+    }
+    addListener(event, listener) {
+        return this.on(event, listener);
+    }
+    once(event, listener) {
+        const wrapped = (...args) => {
+            this.off(event, wrapped);
+            listener(...args);
+        };
+        return this.on(event, wrapped);
+    }
+    off(event, listener) {
+        const set = this.listeners.get(event);
+        if (!set)
+            return this;
+        set.delete(listener);
+        if (set.size === 0)
+            this.listeners.delete(event);
+        return this;
+    }
+    removeListener(event, listener) {
+        return this.off(event, listener);
+    }
+    removeAllListeners(event) {
+        if (typeof event === 'undefined') {
+            this.listeners.clear();
+            return this;
+        }
+        this.listeners.delete(event);
+        return this;
+    }
+    emit(event, ...args) {
+        const set = this.listeners.get(event);
+        if (!set || set.size === 0)
+            return false;
+        for (const listener of [...set]) {
+            listener(...args);
+        }
+        return true;
+    }
+}
+const eventEmitter = new SeedEventEmitter();
+
 /**
  * Detect SQLite UNIQUE constraint failures across better-sqlite3 and drizzle/wasm wrappers.
  * Drizzle often surfaces `Failed query: insert into...` without "UNIQUE constraint" on message,
@@ -264,6 +316,219 @@ function matchesUniqueConstraintText(text) {
         (text.includes('2067') && lower.includes('constraint')));
 }
 
+/**
+ * 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, then schemaId/schemaName + name, then the name alone. 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 (!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];
+    }
+    return resolveModelRecordByNameOnly(modelName, db);
+};
+/**
+ * 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, names whose
+ * snake_case form is the type (`new_model` → "New model", as Model.findByModelType matches), and
+ * the PascalCase form older callers relied on (`sync_storage_post` → "SyncStoragePost").
+ */
+const modelNamesForNameOrType = async (nameOrType, db) => {
+    const pascal = upperFirst(camelCase(nameOrType));
+    const rows = (await db.selectDistinct({ name: models.name }).from(models));
+    return rows
+        .map((r) => r.name)
+        .filter((name) => name === nameOrType || name === pascal || toSnakeCase(name) === nameOrType);
+};
+/**
+ * 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) {
+        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 }, 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];
+    }
+    return resolveModelRecordByNameOnly(names, db, nameOrType);
+};
+/**
+ * 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 rows = await db
+            .select({ modelFileId: seeds.modelFileId })
+            .from(seeds)
+            .where(hints.seedLocalId ? eq(seeds.localId, hints.seedLocalId) : eq(seeds.uid, hints.seedUid))
+            .limit(1);
+        if (rows[0]?.modelFileId)
+            return rows[0].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;
+};
+/** ModelScope for an Item (or ItemProperty) instance: its recorded modelFileId (context or seed row) and schemaName. */
+const getItemModelScope = async (item) => {
+    let context;
+    try {
+        context = item.getService?.().getSnapshot().context;
+    }
+    catch {
+        context = undefined;
+    }
+    const modelFileId = await resolveItemModelFileId({
+        modelFileId: context?.modelFileId,
+        seedLocalId: item.seedLocalId ?? context?.seedLocalId,
+        seedUid: item.seedUid ?? context?.seedUid,
+        propertyId: context?.propertyId,
+    });
+    return { modelFileId, schemaName: context?.schemaName };
+};
+/**
+ * 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,
+    getItemModelScope: getItemModelScope,
+    resolveItemModelFileId: resolveItemModelFileId,
+    resolveModelRecord: resolveModelRecord,
+    resolveModelRecordByNameOrType: resolveModelRecordByNameOrType,
+    resolveRefModelRecord: resolveRefModelRecord
+});
+
 /**
  * Lowercase + trim an address for persist and compare.
  * Does not checksum or validate — test and placeholder addresses must keep working.
@@ -318,21 +583,74 @@ function normalizeAddressConfig(addresses) {
     };
 }
 
+const pendingLinks = new Map();
+/**
+ * Insert the `model_schemas` row linking a model to a schema, unless it already exists.
+ *
+ * `model_schemas` has no unique constraint, and several writers link the same model during one
+ * import (importJsonSchema's addModelsToDb and the write service's writeModelToDb). Each used to
+ * check-then-insert on its own, so concurrent writers inserted the link twice. The check and insert
+ * run serialized per (model, schema) here.
+ *
+ * @returns true when this call inserted the link
+ */
+function linkModelToSchema(db, modelId, schemaId) {
+    const key = `${modelId}:${schemaId}`;
+    const previous = pendingLinks.get(key) ?? Promise.resolve(false);
+    const current = previous
+        .catch(() => false)
+        .then(async () => {
+        const existing = await db
+            .select({ id: modelSchemas.id })
+            .from(modelSchemas)
+            .where(and(eq(modelSchemas.modelId, modelId), eq(modelSchemas.schemaId, schemaId)))
+            .limit(1);
+        if (existing.length > 0)
+            return false;
+        await db.insert(modelSchemas).values({ modelId, schemaId });
+        return true;
+    });
+    pendingLinks.set(key, current);
+    const cleanup = () => {
+        if (pendingLinks.get(key) === current)
+            pendingLinks.delete(key);
+    };
+    current.then(cleanup, cleanup);
+    return current;
+}
+
 const logger = debug('seedSdk:helpers:db');
+/**
+ * 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;
 /**
  * Resolve property_id (integer properties.id) from a property's schemaFileId (the string `id` in
  * schema files and propertyRecordSchema). Scoped to the model since schemaFileIds are per schema file.
  * @returns properties.id or null if not found
  */
-async function getPropertyIdForSchemaFileId(modelNameOrType, schemaFileId) {
+async function getPropertyIdForSchemaFileId(modelNameOrType, schemaFileId, scope = {}) {
     const db = BaseDb.getAppDb();
     if (!db || !modelNameOrType || !schemaFileId)
         return null;
+    const modelRecord = await resolveModelRecordByNameOrType(modelNameOrType, scope, db);
+    if (!modelRecord)
+        return null;
     const rows = await db
         .select({ id: properties.id })
         .from(properties)
-        .innerJoin(models, eq(properties.modelId, models.id))
-        .where(and(eq(models.name, upperFirst(camelCase(modelNameOrType))), eq(properties.schemaFileId, schemaFileId)))
+        .where(and(eq(properties.modelId, modelRecord.id), eq(properties.schemaFileId, schemaFileId)))
         .limit(1);
     return rows[0]?.id ?? null;
 }
@@ -341,15 +659,18 @@ async function getPropertyIdForSchemaFileId(modelNameOrType, schemaFileId) {
  * Handles property name variants (e.g. htmlId -> html, avatarImageIds -> avatarImages).
  * @param modelNameOrType - Model name (PascalCase) or model type (snake_case)
  * @param propertyName - Property name as stored in metadata (may have Id/Ids suffix)
+ * @param scope - Which model is meant when several schemas define one with this name
  * @returns properties.id or null if not found
  */
-async function getPropertyIdForModelAndName(modelNameOrType, propertyName) {
+async function getPropertyIdForModelAndName(modelNameOrType, propertyName, scope = {}) {
     const db = BaseDb.getAppDb();
     if (!db)
         return null;
     if (!modelNameOrType || !propertyName)
         return null;
-    const normalizedModelName = upperFirst(camelCase(modelNameOrType));
+    const modelRecord = await resolveModelRecordByNameOrType(modelNameOrType, scope, db);
+    if (!modelRecord)
+        return null;
     const propertyNamesToTry = [propertyName];
     if (propertyName.endsWith('Ids')) {
         propertyNamesToTry.push(propertyName.slice(0, -3));
@@ -361,8 +682,7 @@ async function getPropertyIdForModelAndName(modelNameOrType, propertyName) {
         const rows = await db
             .select({ id: properties.id })
             .from(properties)
-            .innerJoin(models, eq(properties.modelId, models.id))
-            .where(and(eq(models.name, normalizedModelName), eq(properties.name, pName)))
+            .where(and(eq(properties.modelId, modelRecord.id), eq(properties.name, pName)))
             .limit(1);
         if (rows.length > 0 && rows[0].id != null) {
             return rows[0].id;
@@ -370,6 +690,28 @@ async function getPropertyIdForModelAndName(modelNameOrType, propertyName) {
     }
     return 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')));
+}
 /**
  * Migrate metadata rows when a property is renamed.
  * Updates metadata.propertyName from old to new for all rows that reference the renamed property.
@@ -380,7 +722,7 @@ async function getPropertyIdForModelAndName(modelNameOrType, propertyName) {
  * @param propertySchemaFileId - Optional schema file ID for the property (most reliable lookup)
  * @returns Count of metadata rows updated
  */
-async function migrateMetadataForPropertyRename(modelName, oldPropertyName, newPropertyName, propertySchemaFileId) {
+async function migrateMetadataForPropertyRename(modelName, oldPropertyName, newPropertyName, propertySchemaFileId, scope = {}) {
     const db = BaseDb.getAppDb();
     if (!db) {
         logger('[migrateMetadataForPropertyRename] Database not available, skipping');
@@ -389,10 +731,10 @@ async function migrateMetadataForPropertyRename(modelName, oldPropertyName, newP
     // Find the property row by schemaFileId (preferred) or by name
     let propertyId = null;
     if (propertySchemaFileId) {
-        propertyId = await getPropertyIdForSchemaFileId(modelName, propertySchemaFileId);
+        propertyId = await getPropertyIdForSchemaFileId(modelName, propertySchemaFileId, scope);
     }
     if (propertyId == null) {
-        propertyId = await getPropertyIdForModelAndName(modelName, oldPropertyName);
+        propertyId = await getPropertyIdForModelAndName(modelName, oldPropertyName, scope);
     }
     if (propertyId == null) {
         logger(`[migrateMetadataForPropertyRename] Property not found: ${modelName}.${oldPropertyName}, skipping`);
@@ -432,12 +774,6 @@ async function migrateMetadataForPropertyRename(modelName, oldPropertyName, newP
     }
     return total;
 }
-const escapeSqliteString = (value) => {
-    if (typeof value !== 'string') {
-        throw new Error(`Value must be a string, instead got: ${JSON.stringify(value)}`);
-    }
-    return value.replace(/'/g, "''");
-};
 const getObjectForRow = (row) => {
     const obj = {};
     row.columnNames.forEach((colName, index) => {
@@ -474,13 +810,37 @@ const getSqlResultObject = (queryResult) => {
     }
     return obj;
 };
+/**
+ * True when the models row is linked (model_schemas) to any schema other than schemaId.
+ */
+const isModelLinkedToOtherSchema = async (db, modelId, schemaId) => {
+    const links = await db
+        .select({ schemaId: modelSchemas.schemaId })
+        .from(modelSchemas)
+        .where(eq(modelSchemas.modelId, modelId));
+    return links.some((l) => l.schemaId !== schemaId);
+};
+const isModelLinkedToAnySchema = async (db, modelId) => {
+    const links = await db
+        .select({ id: modelSchemas.id })
+        .from(modelSchemas)
+        .where(eq(modelSchemas.modelId, modelId))
+        .limit(1);
+    return links.length > 0;
+};
 /**
  * Find or create a models row by schemaFileId (preferred) or name.
  * Reuses an existing same-name row (especially schemaFileId=null stubs created via
  * ref resolution) instead of inserting a second row — models.name is not unique,
  * and duplicate names break createOrUpdate lookups (e.g. Resource.tags → Tag).
+ *
+ * When modelFileId is given, a same-name row that already carries a *different*
+ * non-null schemaFileId is only adopted if no other schema is linked to it via
+ * model_schemas. Otherwise it belongs to another schema (e.g. two schemas that each
+ * define "Post"), and re-id'ing it would strand that schema's cached Model instance,
+ * so a new row is inserted instead.
  */
-const findOrCreateModelRecord = async (db, modelName, modelFileId) => {
+const findOrCreateModelRecord = async (db, modelName, modelFileId, schemaId) => {
     if (modelFileId) {
         const byFileId = await db
             .select()
@@ -504,15 +864,47 @@ const findOrCreateModelRecord = async (db, modelName, modelFileId) => {
         .from(models)
         .where(eq(models.name, modelName)));
     if (byName.length > 0) {
-        // Prefer exact file-id match, then adoptable null schemaFileId stub, then any single row.
-        let chosen = (modelFileId
+        // Prefer exact file-id match, then (for refs without a file id) this schema's row, then an
+        // adoptable null schemaFileId stub, then any single row.
+        let chosen = modelFileId
             ? byName.find((r) => r.schemaFileId === modelFileId)
-            : undefined) ||
-            byName.find((r) => !r.schemaFileId) ||
-            (byName.length === 1 ? byName[0] : undefined) ||
-            byName.find((r) => !!r.schemaFileId) ||
-            byName[0];
-        if (modelFileId && chosen.schemaFileId !== modelFileId) {
+            : undefined;
+        if (!chosen && !modelFileId && schemaId && byName.length > 1) {
+            for (const candidate of byName) {
+                if (!(await isModelLinkedToOtherSchema(db, candidate.id, schemaId))) {
+                    const links = await db
+                        .select({ schemaId: modelSchemas.schemaId })
+                        .from(modelSchemas)
+                        .where(eq(modelSchemas.modelId, candidate.id));
+                    if (links.length > 0) {
+                        chosen = candidate;
+                        break;
+                    }
+                }
+            }
+        }
+        chosen ?? (chosen = byName.find((r) => !r.schemaFileId));
+        if (!chosen && modelFileId) {
+            // Every same-name row has a different file id. Only adopt one that no other
+            // schema claims; otherwise fall through and insert a row for this file id.
+            // A row with a file id that no schema links is a deleted schema's leftover (its old
+            // properties are still attached), not an unclaimed row: don't adopt it either.
+            for (const candidate of byName) {
+                if (candidate.schemaFileId && !(await isModelLinkedToAnySchema(db, candidate.id)))
+                    continue;
+                if (!(await isModelLinkedToOtherSchema(db, candidate.id, schemaId))) {
+                    chosen = candidate;
+                    break;
+                }
+            }
+        }
+        else if (!chosen) {
+            chosen =
+                (byName.length === 1 ? byName[0] : undefined) ||
+                    byName.find((r) => !!r.schemaFileId) ||
+                    byName[0];
+        }
+        if (chosen && modelFileId && chosen.schemaFileId !== modelFileId) {
             const conflict = await db
                 .select()
                 .from(models)
@@ -521,17 +913,17 @@ const findOrCreateModelRecord = async (db, modelName, modelFileId) => {
             if (conflict.length > 0) {
                 return conflict[0];
             }
-            // Adopt stub (null schemaFileId) or sole same-name row by attaching this file id.
-            if (!chosen.schemaFileId || byName.length === 1) {
-                await db
-                    .update(models)
-                    .set({ schemaFileId: modelFileId, isEdited: false })
-                    .where(eq(models.id, chosen.id));
-                chosen = { ...chosen, schemaFileId: modelFileId, isEdited: false };
-                logger(`Adopted existing model "${modelName}" (id: ${chosen.id}) with schemaFileId "${modelFileId}"`);
-            }
+            // Adopt stub (null schemaFileId) or an unclaimed same-name row by attaching this file id.
+            await db
+                .update(models)
+                .set({ schemaFileId: modelFileId, isEdited: false })
+                .where(eq(models.id, chosen.id));
+            chosen = { ...chosen, schemaFileId: modelFileId, isEdited: false };
+            logger(`Adopted existing model "${modelName}" (id: ${chosen.id}) with schemaFileId "${modelFileId}"`);
+        }
+        if (chosen) {
+            return chosen;
         }
-        return chosen;
     }
     try {
         const inserted = await db
@@ -570,6 +962,29 @@ const findOrCreateModelRecord = async (db, modelName, modelFileId) => {
         throw error;
     }
 };
+/**
+ * Find or create the models row a Relation property on ownerModelId points to. Model names are only
+ * unique per schema, so the ref is looked up in the owner's schema(s) first; a global name lookup
+ * (createOrUpdate by name) threw "Multiple records found" once two schemas defined the ref model.
+ */
+const findOrCreateRefModelRecord = async (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 findOrCreateModelRecord(db, refModelName, undefined, ownerLink?.schemaId ?? undefined);
+};
 const createOrUpdate = async (db, table, values) => {
     const valueFilters = [];
     const propertiesToExcludeFromDb = ['ref'];
@@ -871,8 +1286,8 @@ const renameModelInDb = async (oldName, newName, schemaNameOrId) => {
     if (!db) {
         throw new Error('Database not found');
     }
-    const _mod_0 = await import('./BasePathResolver-B6CKqoKw.js');
-    const _ns_0 = _mod_0.O;
+    const _mod_0 = await import('./BasePathResolver-ndE8XTpw.js');
+    const _ns_0 = _mod_0.Q;
     const { schemas: schemasTable } = _ns_0;
     // Find the model by old name, optionally scoped by schema
     let existingModels;
@@ -916,8 +1331,11 @@ const renameModelInDb = async (oldName, newName, schemaNameOrId) => {
             isEdited: models.isEdited,
         })
             .from(models)
-            .where(eq(models.name, oldName))
-            .limit(1);
+            .where(eq(models.name, oldName));
+        // Model names are only unique per schema: an unscoped rename must not pick one arbitrarily.
+        if (existingModels.length > 1) {
+            throw new Error(`Model "${oldName}" exists in more than one schema; pass the schema name or id to rename it`);
+        }
     }
     if (existingModels.length === 0) {
         if (schemaNameOrId !== undefined) {
@@ -991,7 +1409,9 @@ const renameModelInDb = async (oldName, newName, schemaNameOrId) => {
  * @param schemaFileValue - Optional schema file value to compare against database
  * @returns true if the property is marked as edited, false otherwise
  */
-async function checkIfPropertyIsEdited(modelName, propertyName, schemaFileValue) {
+async function checkIfPropertyIsEdited(modelName, propertyName, schemaFileValue, 
+/** The property's models row (model names are only unique per schema). */
+modelId) {
     try {
         // When schemaFileValue is provided (schema sync path), do database check FIRST.
         // This avoids the ModelProperty dynamic import which can hang due to circular
@@ -1000,11 +1420,8 @@ async function checkIfPropertyIsEdited(modelName, propertyName, schemaFileValue)
             const db = BaseDb.getAppDb();
             if (db) {
                 // Find the model
-                const modelRecords = await db
-                    .select()
-                    .from(models)
-                    .where(eq(models.name, modelName))
-                    .limit(1);
+                const resolvedModel = await resolveModelRecord(modelName, { modelId }, db);
+                const modelRecords = resolvedModel ? [resolvedModel] : [];
                 if (modelRecords.length > 0) {
                     const modelRecord = modelRecords[0];
                     // Find the property in the database
@@ -1023,13 +1440,9 @@ async function checkIfPropertyIsEdited(modelName, propertyName, schemaFileValue)
                         }
                         // Check refModelId if it's a relation
                         if (schemaFileValue.ref) {
-                            const refModelRecords = await db
-                                .select()
-                                .from(models)
-                                .where(eq(models.name, schemaFileValue.ref))
-                                .limit(1);
-                            if (refModelRecords.length > 0) {
-                                const expectedRefModelId = refModelRecords[0].id;
+                            const refModelRecord = await resolveRefModelRecord(schemaFileValue.ref, { modelId: modelRecord.id }, db);
+                            if (refModelRecord) {
+                                const expectedRefModelId = refModelRecord.id;
                                 if (dbProperty.refModelId !== expectedRefModelId) {
                                     logger(`Property ${modelName}:${propertyName} has been edited (refModelId differs)`);
                                     return true;
@@ -1055,6 +1468,22 @@ async function checkIfPropertyIsEdited(modelName, propertyName, schemaFileValue)
                                 return true;
                             }
                         }
+                        // Storage settings. Rows written before they were stored (all null) aren't edits: the
+                        // schema file's values fill them in on this load.
+                        const dbStorage = {
+                            storageType: dbProperty.storageType ?? null,
+                            localStorageDir: dbProperty.localStorageDir ?? null,
+                            filenameSuffix: dbProperty.filenameSuffix ?? null,
+                        };
+                        if (hasStorageSettings(dbStorage)) {
+                            const fileStorage = propertyStorageColumns(schemaFileValue);
+                            if (dbStorage.storageType !== fileStorage.storageType ||
+                                dbStorage.localStorageDir !== fileStorage.localStorageDir ||
+                                dbStorage.filenameSuffix !== fileStorage.filenameSuffix) {
+                                logger(`Property ${modelName}:${propertyName} has been edited (storage settings differ)`);
+                                return true;
+                            }
+                        }
                     }
                 }
             }
@@ -1108,9 +1537,9 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
     for (const [modelName, modelClass] of Object.entries(models$1)) {
         try {
             const modelFileId = schemaFileData?.modelFileIds?.get(modelName);
-            let modelRecord = await findOrCreateModelRecord(db, modelName, modelFileId);
+            let modelRecord = await findOrCreateModelRecord(db, modelName, modelFileId, schemaRecord?.id);
             // Keep schemaFileId aligned when findOrCreate returned a row that still needs adoption
-            // (e.g. sole same-name row that already had a different non-null id — rare).
+            // (rare: findOrCreate handles stubs and unclaimed same-name rows itself).
             if (modelFileId && modelRecord.schemaFileId !== modelFileId) {
                 const existingWithFileId = await db
                     .select()
@@ -1194,6 +1623,8 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
                     dataType: normalizeDataType(propertyValues.dataType),
                     schemaFileId: propertyFileId || null,
                     required: propertyValues.required ?? false,
+                    // The schema file is the source of truth here: no storage config means none.
+                    ...propertyStorageColumns(propertyValues),
                 };
                 // Handle ref property - create ref model if needed
                 // Check both ref and refModelName (refModelName is set by createModelFromJson)
@@ -1205,7 +1636,7 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
                     const refModelFileId = schemaFileData?.modelFileIds?.get(refModelName);
                     const refModel = cachedRef
                         ? cachedRef
-                        : await findOrCreateModelRecord(db, refModelName, refModelFileId);
+                        : await findOrCreateModelRecord(db, refModelName, refModelFileId, schemaRecord?.id);
                     if (!cachedRef) {
                         modelRecords.set(refModelName, refModel);
                     }
@@ -1258,7 +1689,8 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
                             ref: propertyValues.ref,
                             refValueType: propertyValues.refValueType,
                             required: propertyValues.required,
-                        });
+                            ...propertyStorageColumns(propertyValues),
+                        }, modelRecord.id);
                     if (isPropertyEdited) {
                         // Property has been locally edited - skip update to preserve local changes
                         logger(`Skipping update for property ${modelName}:${existingProperty.name} -> ${propertyName} - it has been locally edited and will be preserved`);
@@ -1283,6 +1715,9 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
                         existingProperty.required === (updateData.required ?? false) &&
                         existingProperty.refModelId === (updateData.refModelId ?? null) &&
                         existingProperty.refValueType === (updateData.refValueType ?? null) &&
+                        (existingProperty.storageType ?? null) === (updateData.storageType ?? null) &&
+                        (existingProperty.localStorageDir ?? null) === (updateData.localStorageDir ?? null) &&
+                        (existingProperty.filenameSuffix ?? null) === (updateData.filenameSuffix ?? null) &&
                         existingProperty.isEdited === (updateData.isEdited ?? false);
                     if (!unchanged) {
                         await db
@@ -1358,10 +1793,8 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
             const toInsert = modelIds.filter(({ modelId }) => !existingSet.has(modelId));
             if (toInsert.length > 0) {
                 for (const { modelName, modelId } of toInsert) {
-                    await db.insert(modelSchemas).values({
-                        modelId,
-                        schemaId: schemaRecord.id,
-                    });
+                    if (!(await linkModelToSchema(db, modelId, schemaRecord.id)))
+                        continue;
                     logger(`Created join table entry for model ${modelName} (id: ${modelId}) to schema (id: ${schemaRecord.id})`);
                 }
             }
@@ -1432,6 +1865,12 @@ const loadModelsFromDbForSchema = async (schemaId) => {
                 if (prop.refValueType) {
                     propertyData.refValueType = normalizeDataType(prop.refValueType ?? undefined);
                 }
+                if (prop.storageType)
+                    propertyData.storageType = prop.storageType;
+                if (prop.localStorageDir)
+                    propertyData.localStorageDir = prop.localStorageDir;
+                if (prop.filenameSuffix)
+                    propertyData.filenameSuffix = prop.filenameSuffix;
                 modelProperties[prop.name] = propertyData;
             }
             // Create model structure. Include id (schemaFileId) so processSchemaFiles can populate
@@ -1531,12 +1970,8 @@ const savePropertyToDb = async (property) => {
         modelRecord = byId[0];
     }
     if (!modelRecord && property.modelName) {
-        const byName = await db
-            .select()
-            .from(models)
-            .where(eq(models.name, property.modelName))
-            .limit(1);
-        modelRecord = byName[0];
+        // Model names are only unique per schema: scope by the property's schema when known
+        modelRecord = await resolveModelRecord(property.modelName, { schemaName: property._schemaName }, db);
     }
     if (!modelRecord && property.modelName) {
         const bySchemaFileId = await db
@@ -1610,9 +2045,7 @@ const savePropertyToDb = async (property) => {
     }
     // Handle ref property - create ref model if needed
     if (property.refModelName) {
-        const refModel = await createOrUpdate(db, models, {
-            name: property.refModelName,
-        });
+        const refModel = await findOrCreateRefModelRecord(db, property.refModelName, modelRecord.id);
         propertyData.refModelId = refModel.id;
     }
     else if (property.refModelId) {
@@ -1630,6 +2063,12 @@ const savePropertyToDb = async (property) => {
         propertyData.refValueType = null;
     }
     propertyData.required = property.required ?? false;
+    // Only when the context has storage settings: a context built without them (e.g. loaded before
+    // they were stored) must not clear the row's.
+    const storage = propertyStorageColumns(property);
+    if (hasStorageSettings(storage)) {
+        Object.assign(propertyData, storage);
+    }
     if (existingProperties.length > 0) {
         // Property exists, update it with new values (including new name)
         // Set isEdited = true when property is edited
@@ -1851,8 +2290,8 @@ async function writeModelToDb(modelFileId, data) {
                 throw new Error(`Model with id ${modelId} does not exist in database. Cannot create join record.`);
             }
             // Verify schemaId exists and get name/fileId for invalidation broadcast
-            const _mod_1 = await import('./BasePathResolver-B6CKqoKw.js');
-            const _ns_1 = _mod_1.O;
+            const _mod_1 = await import('./BasePathResolver-ndE8XTpw.js');
+            const _ns_1 = _mod_1.Q;
             const schemaSchemaMod = _ns_1;
             const { schemas: schemasTable } = schemaSchemaMod;
             const schemaCheck = await db
@@ -1868,10 +2307,7 @@ async function writeModelToDb(modelFileId, data) {
                 throw new Error(`Schema with id ${data.schemaId} does not exist in database. Cannot create join record.`);
             }
             logger(`Creating join record: modelId=${modelId}, schemaId=${data.schemaId} (both verified to exist)`);
-            await db.insert(modelSchemas).values({
-                modelId,
-                schemaId: data.schemaId,
-            });
+            await linkModelToSchema(db, modelId, data.schemaId);
             // Notify React useModels so it can invalidate; live query over join often doesn't re-run when model_schemas is inserted.
             // Yield so the insert is visible to the refetch that will run when the broadcast is received.
             if (typeof BroadcastChannel !== 'undefined') {
@@ -1969,9 +2405,7 @@ async function writePropertyToDb(propertyFileId, data, isEdited = false) {
     // Check refModelName first, then ref (for backwards compatibility with schema files)
     const refModelName = data.refModelName || data.ref;
     if (refModelName) {
-        const refModel = await createOrUpdate(db, models, {
-            name: refModelName,
-        });
+        const refModel = await findOrCreateRefModelRecord(db, refModelName, data.modelId);
         propertyData.refModelId = refModel.id;
     }
     else if (data.refModelId) {
@@ -1988,9 +2422,17 @@ async function writePropertyToDb(propertyFileId, data, isEdited = false) {
         // If refValueType is not set, ensure it's null
         propertyData.refValueType = null;
     }
-    propertyData.required = data.required ?? false;
-    // Note: Additional property fields like storageType, localStorageDir, filenameSuffix
-    // are not stored in the properties table but may be in the schema JSON
+    // Only overwrite `required` when the caller knows it. The creation write's payload can lack it, and
+    // defaulting to false here cleared the flag the schema import set (required relations became optional).
+    if (data.required !== undefined) {
+        propertyData.required = data.required;
+    }
+    // Storage settings, like `required`, only when the caller has them: the creation write's payload
+    // can lack them, and writing nulls would clear what the schema import stored.
+    const storage = propertyStorageColumns(data);
+    if (hasStorageSettings(storage)) {
+        Object.assign(propertyData, storage);
+    }
     if (existingProperties.length > 0) {
         // Property exists, update it with new values.
         // Use existing row id for WHERE (not name+modelId) so renames work: the row
@@ -2020,7 +2462,7 @@ async function writePropertyToDb(propertyFileId, data, isEdited = false) {
         }
         else {
             try {
-                await db.insert(properties).values(propertyData);
+                await db.insert(properties).values({ required: false, ...propertyData });
                 logger(`Created property ${data.name} (${propertyFileId}) in database`);
             }
             catch (error) {
@@ -2061,8 +2503,8 @@ async function getSchemaId(schemaNameOrFileId) {
     if (!db) {
         throw new Error('Database not available');
     }
-    const _mod_2 = await import('./BasePathResolver-B6CKqoKw.js');
-    const _ns_2 = _mod_2.O;
+    const _mod_2 = await import('./BasePathResolver-ndE8XTpw.js');
+    const _ns_2 = _mod_2.Q;
     const schemaSchemaMod = _ns_2;
     const { schemas: schemasTable } = schemaSchemaMod;
     const drizzleMod = await import('drizzle-orm');
@@ -2099,8 +2541,8 @@ async function getSchemaIdByFileId(schemaFileId) {
     if (!db) {
         throw new Error('Database not available');
     }
-    const _mod_3 = await import('./BasePathResolver-B6CKqoKw.js');
-    const _ns_3 = _mod_3.O;
+    const _mod_3 = await import('./BasePathResolver-ndE8XTpw.js');
+    const _ns_3 = _mod_3.Q;
     const schemaSchemaMod = _ns_3;
     const { schemas: schemasTable } = schemaSchemaMod;
     const drizzleMod = await import('drizzle-orm');
@@ -2128,8 +2570,8 @@ async function getModelId(modelNameOrFileId, schemaNameOrId) {
     if (!db) {
         throw new Error('Database not available');
     }
-    const _mod_4 = await import('./BasePathResolver-B6CKqoKw.js');
-    const _ns_4 = _mod_4.M;
+    const _mod_4 = await import('./BasePathResolver-ndE8XTpw.js');
+    const _ns_4 = _mod_4.N;
     const modelSchemaMod = _ns_4;
     const { models: modelsTable } = modelSchemaMod;
     const drizzleMod = await import('drizzle-orm');
@@ -2145,12 +2587,12 @@ async function getModelId(modelNameOrFileId, schemaNameOrId) {
         [eq(modelsTable.name, modelNameOrFileId)];
         // If schema is provided, narrow the search
         if (schemaNameOrId !== undefined) {
-            const _mod_5 = await import('./BasePathResolver-B6CKqoKw.js');
-            const _ns_5 = _mod_5.Q;
+            const _mod_5 = await import('./BasePathResolver-ndE8XTpw.js');
+            const _ns_5 = _mod_5.R;
             const modelSchemaSchemaMod = _ns_5;
             const { modelSchemas } = modelSchemaSchemaMod;
-            const _mod_6 = await import('./BasePathResolver-B6CKqoKw.js');
-            const _ns_6 = _mod_6.O;
+            const _mod_6 = await import('./BasePathResolver-ndE8XTpw.js');
+            const _ns_6 = _mod_6.Q;
             const schemaSchemaMod = _ns_6;
             const { schemas: schemasTable } = schemaSchemaMod;
             if (typeof schemaNameOrId === 'number') {
@@ -2174,12 +2616,9 @@ async function getModelId(modelNameOrFileId, schemaNameOrId) {
             }
         }
         else {
-            // No schema filter, just search by name
-            records = await db
-                .select()
-                .from(modelsTable)
-                .where(eq(modelsTable.name, modelNameOrFileId))
-                .limit(1);
+            // No schema filter: name-only (newest row, warns when the name is ambiguous)
+            const byName = await resolveModelRecord(modelNameOrFileId, {}, db);
+            records = byName ? [byName] : [];
         }
     }
     if (records.length === 0) {
@@ -2199,8 +2638,8 @@ async function getModelIdByFileId(modelFileId) {
     if (!db) {
         throw new Error('Database not available');
     }
-    const _mod_7 = await import('./BasePathResolver-B6CKqoKw.js');
-    const _ns_7 = _mod_7.M;
+    const _mod_7 = await import('./BasePathResolver-ndE8XTpw.js');
+    const _ns_7 = _mod_7.N;
     const modelSchemaMod = _ns_7;
     const { models: modelsTable } = modelSchemaMod;
     const drizzleMod = await import('drizzle-orm');
@@ -2221,11 +2660,11 @@ var db = /*#__PURE__*/Object.freeze({
     addModelsToDb: addModelsToDb,
     addSchemaToDb: addSchemaToDb,
     createOrUpdate: createOrUpdate,
-    escapeSqliteString: escapeSqliteString,
     getAddressesForItemsFilter: getAddressesForItemsFilter,
     getAddressesFromDb: getAddressesFromDb,
     getAddressesFromDbOptional: getAddressesFromDbOptional,
     getAllAddressesFromDb: getAllAddressesFromDb,
+    getItemStoragePropertiesForModel: getItemStoragePropertiesForModel,
     getModelId: getModelId,
     getModelIdByFileId: getModelIdByFileId,
     getModelNameByModelId: getModelNameByModelId,
@@ -2240,11 +2679,12 @@ var db = /*#__PURE__*/Object.freeze({
     getWatchedAddressesFromDb: getWatchedAddressesFromDb,
     loadModelsFromDbForSchema: loadModelsFromDbForSchema,
     migrateMetadataForPropertyRename: migrateMetadataForPropertyRename,
+    propertyStorageColumns: propertyStorageColumns,
     renameModelInDb: renameModelInDb,
     savePropertyToDb: savePropertyToDb,
     writeModelToDb: writeModelToDb,
     writePropertyToDb: writePropertyToDb
 });
 
-export { addSchemaToDb as A, Boolean as B, renameModelInDb as C, DEFAULT_TEXT_MAX_LENGTH as D, loadModelsFromDbForSchema as E, File as F, getOwnedAddressesFromDb as G, Html as H, Image as I, Json as J, getPropertyIdForSchemaFileId as K, List as L, ModelPropertyDataTypes as M, Number$1 as N, getWatchedAddressesFromDb as O, Property as P, db as Q, Relation as R, THtmlEmbeddedDataUriPolicy as T, Date$1 as a, PropertyConstructor as b, PropertyMetadataKey as c, TProperty as d, TPropertyConstructor as e, TPropertyDataType as f, TPropertyDefs as g, TStorageType as h, TValidationRules as i, Text as j, isDataType as k, normalizePropertyRecordSchema as l, getPropertyIdForModelAndName as m, normalizeDataType as n, normalizePublisher as o, getAllAddressesFromDb as p, escapeSqliteString as q, normalizeHexAddress as r, addModelsToDb as s, getModelIdByFileId as t, getModelId as u, getAddressesForItemsFilter as v, normalizeAddressConfig as w, normalizeAddressList as x, writeModelToDb as y, writePropertyToDb as z };
-//# sourceMappingURL=db-WbrzEf7c.js.map
+export { AmbiguousModelError as A, Boolean as B, normalizeAddressConfig as C, DEFAULT_TEXT_MAX_LENGTH as D, normalizeAddressList as E, File as F, writeModelToDb as G, Html as H, Image as I, Json as J, writePropertyToDb as K, List as L, ModelPropertyDataTypes as M, Number$1 as N, addSchemaToDb as O, Property as P, renameModelInDb as Q, Relation as R, loadModelsFromDbForSchema as S, THtmlEmbeddedDataUriPolicy as T, linkModelToSchema as U, getWatchedAddressesFromDb as V, getOwnedAddressesFromDb as W, getPropertyIdForSchemaFileId as X, resolveModelRecord$1 as Y, db as Z, Date$1 as a, PropertyConstructor as b, PropertyMetadataKey as c, TProperty as d, TPropertyConstructor as e, TPropertyDataType as f, TPropertyDefs as g, TStorageType as h, TValidationRules as i, Text as j, isDataType as k, normalizePropertyRecordSchema as l, getItemModelScope as m, normalizeDataType as n, eventEmitter as o, getPropertyIdForModelAndName as p, resolveItemModelFileId as q, resolveModelRecord as r, normalizePublisher as s, getAllAddressesFromDb as t, normalizeHexAddress as u, getItemStoragePropertiesForModel as v, addModelsToDb as w, getModelIdByFileId as x, getModelId as y, getAddressesForItemsFilter as z };
+//# sourceMappingURL=db-BJZN0a0a.js.map