@seedprotocol/sdk 0.4.32 → 0.5.1

package/dist/db-Cvh84NY7.js

@@ -0,0 +1,1972 @@
+import { B as BaseDb, m as models, i as modelSchemas, r as schemas, p as properties, b as appState, f as metadata } from './BasePathResolver-BDgc7c4T.js';
+import { toSnakeCase } from 'drizzle-orm/casing';
+import { eq, and, isNull } from 'drizzle-orm';
+import { upperFirst, camelCase } from 'lodash-es';
+import debug from 'debug';
+import 'drizzle-orm/sqlite-core';
+
+/**
+ * Detect SQLite UNIQUE constraint failures across better-sqlite3 and drizzle/wasm wrappers.
+ * Drizzle often surfaces `Failed query: insert into...` without "UNIQUE constraint" on message,
+ * with the real SQLITE_CONSTRAINT_UNIQUE on cause / nested error.
+ */
+function isSqliteUniqueConstraintError(error) {
+    const seen = new Set();
+    const queue = [error];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (current == null || seen.has(current))
+            continue;
+        seen.add(current);
+        if (typeof current === 'string') {
+            if (matchesUniqueConstraintText(current))
+                return true;
+            continue;
+        }
+        if (typeof current !== 'object')
+            continue;
+        const err = current;
+        const code = err.code;
+        if (code === 'SQLITE_CONSTRAINT_UNIQUE' ||
+            code === 2067 ||
+            code === '2067') {
+            return true;
+        }
+        for (const key of ['message', 'msg', 'stack']) {
+            const value = err[key];
+            if (typeof value === 'string' && matchesUniqueConstraintText(value)) {
+                return true;
+            }
+        }
+        // Drizzle / wasm often nest the real SQLite error
+        for (const key of ['cause', 'reason', 'error', 'originalError', 'err']) {
+            if (err[key] != null)
+                queue.push(err[key]);
+        }
+    }
+    return false;
+}
+function matchesUniqueConstraintText(text) {
+    const lower = text.toLowerCase();
+    return (lower.includes('unique constraint') ||
+        lower.includes('sqlite_constraint_unique') ||
+        (lower.includes('constraint failed') && lower.includes('unique')) ||
+        /\brc\s*=\s*2067\b/i.test(text) ||
+        (text.includes('2067') && lower.includes('constraint')));
+}
+
+const logger = debug('seedSdk:helpers:db');
+/**
+ * Resolve property_id from model name/type and property name.
+ * 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)
+ * @returns properties.id or null if not found
+ */
+async function getPropertyIdForModelAndName(modelNameOrType, propertyName) {
+    const db = BaseDb.getAppDb();
+    if (!db)
+        return null;
+    if (!modelNameOrType || !propertyName)
+        return null;
+    const normalizedModelName = upperFirst(camelCase(modelNameOrType));
+    const propertyNamesToTry = [propertyName];
+    if (propertyName.endsWith('Ids')) {
+        propertyNamesToTry.push(propertyName.slice(0, -3));
+    }
+    if (propertyName.endsWith('Id')) {
+        propertyNamesToTry.push(propertyName.slice(0, -2));
+    }
+    for (const pName of propertyNamesToTry) {
+        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)))
+            .limit(1);
+        if (rows.length > 0 && rows[0].id != null) {
+            return rows[0].id;
+        }
+    }
+    return null;
+}
+/**
+ * Migrate metadata rows when a property is renamed.
+ * Updates metadata.propertyName from old to new for all rows that reference the renamed property.
+ * Called from renameModelProperty to prevent duplicate ItemProperties.
+ * @param modelName - Model name (PascalCase)
+ * @param oldPropertyName - Current property name before rename
+ * @param newPropertyName - New property name after rename
+ * @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) {
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        logger('[migrateMetadataForPropertyRename] Database not available, skipping');
+        return 0;
+    }
+    const normalizedModelName = upperFirst(camelCase(modelName));
+    // Find the property row by schemaFileId (preferred) or by name
+    let propertyId = null;
+    if (propertySchemaFileId) {
+        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.schemaFileId, propertySchemaFileId)))
+            .limit(1);
+        if (rows.length > 0 && rows[0].id != null) {
+            propertyId = rows[0].id;
+        }
+    }
+    if (propertyId == null) {
+        propertyId = await getPropertyIdForModelAndName(modelName, oldPropertyName);
+    }
+    if (propertyId == null) {
+        logger(`[migrateMetadataForPropertyRename] Property not found: ${modelName}.${oldPropertyName}, skipping`);
+        return 0;
+    }
+    // Primary path: update metadata by propertyId
+    const toUpdateByPropertyId = await db
+        .select({ localId: metadata.localId })
+        .from(metadata)
+        .where(eq(metadata.propertyId, propertyId));
+    const updatedByPropertyId = toUpdateByPropertyId.length;
+    if (updatedByPropertyId > 0) {
+        await db
+            .update(metadata)
+            .set({ propertyName: newPropertyName })
+            .where(eq(metadata.propertyId, propertyId));
+    }
+    // Fallback: update metadata with null propertyId (legacy rows) by propertyName + modelType
+    const modelType = toSnakeCase(modelName);
+    const toUpdateByFallback = await db
+        .select({ localId: metadata.localId })
+        .from(metadata)
+        .where(and(eq(metadata.propertyName, oldPropertyName), eq(metadata.modelType, modelType), isNull(metadata.propertyId)));
+    const updatedByFallback = toUpdateByFallback.length;
+    if (updatedByFallback > 0) {
+        await db
+            .update(metadata)
+            .set({ propertyName: newPropertyName })
+            .where(and(eq(metadata.propertyName, oldPropertyName), eq(metadata.modelType, modelType), isNull(metadata.propertyId)));
+    }
+    if (updatedByFallback > 0) {
+        logger(`[migrateMetadataForPropertyRename] Fallback updated ${updatedByFallback} rows (propertyId was null)`);
+    }
+    const total = updatedByPropertyId + updatedByFallback;
+    if (total > 0) {
+        logger(`[migrateMetadataForPropertyRename] Migrated ${total} metadata rows for ${modelName}.${oldPropertyName} -> ${newPropertyName}`);
+    }
+    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) => {
+        const value = row.row[index];
+        if (typeof value !== 'string') {
+            obj[colName] = row.row[index];
+            return;
+        }
+        // Try to parse the value as JSON
+        try {
+            obj[colName] = JSON.parse(value);
+        }
+        catch (e) {
+            // If it fails, just set the value as a string
+            obj[colName] = value;
+        }
+    });
+    return obj;
+};
+const getSqlResultObject = (queryResult) => {
+    if (!queryResult || !queryResult.rows || queryResult.rows.length === 0) {
+        return;
+    }
+    let obj;
+    if (queryResult.rows.length === 1) {
+        obj = getObjectForRow(queryResult.rows[0]);
+    }
+    if (queryResult.rows.length > 1) {
+        obj = queryResult.rows.reduce((acc, row) => {
+            const rowObj = getObjectForRow(row);
+            acc.push(rowObj);
+            return acc;
+        }, []);
+    }
+    return obj;
+};
+/**
+ * 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).
+ */
+const findOrCreateModelRecord = async (db, modelName, modelFileId) => {
+    if (modelFileId) {
+        const byFileId = await db
+            .select()
+            .from(models)
+            .where(eq(models.schemaFileId, modelFileId))
+            .limit(1);
+        if (byFileId.length > 0) {
+            const record = byFileId[0];
+            if (record.name !== modelName) {
+                await db
+                    .update(models)
+                    .set({ name: modelName })
+                    .where(eq(models.id, record.id));
+                return { ...record, name: modelName };
+            }
+            return record;
+        }
+    }
+    const byName = (await db
+        .select()
+        .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
+            ? 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) {
+            const conflict = await db
+                .select()
+                .from(models)
+                .where(eq(models.schemaFileId, modelFileId))
+                .limit(1);
+            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}"`);
+            }
+        }
+        return chosen;
+    }
+    try {
+        const inserted = await db
+            .insert(models)
+            .values({
+            name: modelName,
+            schemaFileId: modelFileId || null,
+            isEdited: false,
+        })
+            .returning();
+        return inserted[0];
+    }
+    catch (error) {
+        if (isSqliteUniqueConstraintError(error) && modelFileId) {
+            const existing = await db
+                .select()
+                .from(models)
+                .where(eq(models.schemaFileId, modelFileId))
+                .limit(1);
+            if (existing.length > 0) {
+                return existing[0];
+            }
+        }
+        // Race: another writer inserted by name — reuse rather than throw on duplicates.
+        const raced = (await db
+            .select()
+            .from(models)
+            .where(eq(models.name, modelName)));
+        if (raced.length > 0) {
+            return ((modelFileId
+                ? raced.find((r) => r.schemaFileId === modelFileId)
+                : undefined) ||
+                raced.find((r) => !r.schemaFileId) ||
+                raced[0]);
+        }
+        throw error;
+    }
+};
+const createOrUpdate = async (db, table, values) => {
+    const valueFilters = [];
+    const propertiesToExcludeFromDb = ['ref'];
+    const safeValues = Object.keys(values).reduce((acc, key) => {
+        if (!propertiesToExcludeFromDb.includes(key)) {
+            acc[key] = values[key];
+        }
+        return acc;
+    }, {});
+    for (const [key, value] of Object.entries(safeValues)) {
+        let finalValue = value;
+        if (key === 'TObject') {
+            continue;
+        }
+        if (typeof value === 'object') {
+            finalValue = JSON.stringify(value);
+        }
+        const column = table[key];
+        if (!column) {
+            throw new Error(`Column not found for ${key}`);
+        }
+        if (typeof finalValue === 'undefined') {
+            finalValue = null;
+        }
+        if (finalValue === null) {
+            valueFilters.push(isNull(table[key]));
+            continue;
+        }
+        valueFilters.push(eq(table[key], finalValue));
+    }
+    // console.log('valueFilters:', valueFilters)
+    // for ( const filter of valueFilters ) {
+    //   console.log('filter:', Object.keys(filter))
+    // }
+    // Build a query to find the record based on properties
+    const existingRecords = await db
+        .select()
+        .from(table)
+        .where(and(...valueFilters));
+    if (existingRecords.length > 1) {
+        throw new Error('Multiple records found');
+    }
+    if (existingRecords.length > 0) {
+        // If record exists, update it
+        await db
+            .update(table)
+            .set(safeValues)
+            .where(and(...valueFilters));
+        return existingRecords[0];
+    }
+    else {
+        // If no record exists, create a new one
+        const newRecord = await db.insert(table).values(safeValues).returning();
+        return newRecord[0];
+    }
+};
+/**
+ * Searches the database for an existing schema by schemaFileId (preferred) or name and creates it if it doesn't exist
+ * @param schema - The schema to add to the database
+ * @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)
+ * @returns The schema record (either existing or newly created)
+ */
+const addSchemaToDb = async (schema, schemaFileId, schemaData, isDraft, isEdited) => {
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        throw new Error('Database not found');
+    }
+    // First, try to find existing schema by schemaFileId (preferred for change tracking)
+    if (schemaFileId) {
+        const existingByFileId = await db
+            .select()
+            .from(schemas)
+            .where(eq(schemas.schemaFileId, schemaFileId))
+            .limit(1);
+        if (existingByFileId.length > 0) {
+            // Update fields if provided
+            const updates = {};
+            if (schemaFileId && !existingByFileId[0].schemaFileId) {
+                updates.schemaFileId = schemaFileId;
+            }
+            // Always update name if it's different (handles name changes)
+            if (schema.name && existingByFileId[0].name !== schema.name) {
+                updates.name = schema.name;
+            }
+            if (schemaData !== undefined) {
+                updates.schemaData = schemaData;
+            }
+            if (schema.version !== undefined && existingByFileId[0].version !== schema.version) {
+                updates.version = schema.version;
+            }
+            if (isDraft !== undefined && existingByFileId[0].isDraft !== isDraft) {
+                updates.isDraft = isDraft;
+            }
+            if (isEdited !== undefined && existingByFileId[0].isEdited !== isEdited) {
+                updates.isEdited = isEdited;
+            }
+            if (schema.updatedAt && existingByFileId[0].updatedAt !== schema.updatedAt) {
+                updates.updatedAt = schema.updatedAt;
+            }
+            if (Object.keys(updates).length > 0) {
+                await db
+                    .update(schemas)
+                    .set(updates)
+                    .where(eq(schemas.id, existingByFileId[0].id));
+                return { ...existingByFileId[0], ...updates };
+            }
+            return existingByFileId[0];
+        }
+    }
+    // For drafts, check if there's an existing draft by name (not by schemaFileId)
+    if (isDraft === true) {
+        const existingDrafts = await db
+            .select()
+            .from(schemas)
+            .where(eq(schemas.name, schema.name))
+            .limit(1);
+        if (existingDrafts.length > 0 && existingDrafts[0].isDraft === true) {
+            // Update existing draft
+            const updates = {};
+            // Update schemaFileId if provided and different from existing
+            if (schemaFileId && existingDrafts[0].schemaFileId !== schemaFileId) {
+                updates.schemaFileId = schemaFileId;
+            }
+            if (schemaData !== undefined) {
+                updates.schemaData = schemaData;
+            }
+            if (schema.version !== undefined) {
+                updates.version = schema.version;
+            }
+            updates.updatedAt = schema.updatedAt || Date.now();
+            if (Object.keys(updates).length > 0) {
+                await db
+                    .update(schemas)
+                    .set(updates)
+                    .where(eq(schemas.id, existingDrafts[0].id));
+                return { ...existingDrafts[0], ...updates };
+            }
+            return existingDrafts[0];
+        }
+    }
+    // Fallback: Search for existing schema by name
+    // BUT: If we have a schemaFileId, also check if any record with that schemaFileId exists
+    // (in case the name changed but we're looking up by the new name)
+    if (schemaFileId) {
+        // Double-check by schemaFileId - maybe the name changed and we're looking up by new name
+        const doubleCheckByFileId = await db
+            .select()
+            .from(schemas)
+            .where(eq(schemas.schemaFileId, schemaFileId))
+            .limit(1);
+        if (doubleCheckByFileId.length > 0) {
+            // Found by schemaFileId - update it (name might have changed)
+            const updates = {};
+            // Always update name if it's different (handles name changes)
+            if (schema.name && doubleCheckByFileId[0].name !== schema.name) {
+                updates.name = schema.name;
+            }
+            if (schemaData !== undefined) {
+                updates.schemaData = schemaData;
+            }
+            if (schema.version !== undefined && doubleCheckByFileId[0].version !== schema.version) {
+                updates.version = schema.version;
+            }
+            if (isDraft !== undefined && doubleCheckByFileId[0].isDraft !== isDraft) {
+                updates.isDraft = isDraft;
+            }
+            if (isEdited !== undefined && doubleCheckByFileId[0].isEdited !== isEdited) {
+                updates.isEdited = isEdited;
+            }
+            if (schema.updatedAt && doubleCheckByFileId[0].updatedAt !== schema.updatedAt) {
+                updates.updatedAt = schema.updatedAt;
+            }
+            if (Object.keys(updates).length > 0) {
+                await db
+                    .update(schemas)
+                    .set(updates)
+                    .where(eq(schemas.id, doubleCheckByFileId[0].id));
+                return { ...doubleCheckByFileId[0], ...updates };
+            }
+            return doubleCheckByFileId[0];
+        }
+    }
+    // Final fallback: Search by name (only if no schemaFileId or schemaFileId lookup failed)
+    // If isDraft is explicitly false, first try to find non-draft, but also check for drafts
+    // to handle the case where a draft exists and we're loading a non-draft version
+    let existingSchemas = await db
+        .select()
+        .from(schemas)
+        .where(isDraft === false
+        ? and(eq(schemas.name, schema.name), eq(schemas.isDraft, false))
+        : eq(schemas.name, schema.name))
+        .limit(1);
+    // If isDraft is false and we didn't find a non-draft, check for a draft with the same name
+    // This handles the case where a draft was created first and we're now loading the non-draft version
+    if (isDraft === false && existingSchemas.length === 0) {
+        const draftSchemas = await db
+            .select()
+            .from(schemas)
+            .where(and(eq(schemas.name, schema.name), eq(schemas.isDraft, true)))
+            .limit(1);
+        if (draftSchemas.length > 0) {
+            // Found a draft - we'll update it to non-draft below
+            logger(`Found draft schema "${schema.name}" with schemaFileId "${draftSchemas[0].schemaFileId}", will update to non-draft with schemaFileId "${schemaFileId}"`);
+            existingSchemas = draftSchemas;
+        }
+    }
+    if (existingSchemas.length > 0) {
+        // Update fields if provided
+        const updates = {};
+        // Update schemaFileId if provided and different from existing (or if existing doesn't have one or is null)
+        // This is important for preserving IDs from schema files when drafts exist
+        // BUT: Don't overwrite a non-draft schema's schemaFileId with a new generated one
+        // This prevents loadOrCreateSchema from overwriting correct IDs from fixture files
+        if (schemaFileId && existingSchemas[0].schemaFileId !== schemaFileId) {
+            // Only update if:
+            // 1. Existing schema is a draft (can be updated)
+            // 2. Existing schema has no schemaFileId (should be set)
+            // 3. We're explicitly setting isDraft to false (updating from draft to non-draft)
+            const shouldUpdate = existingSchemas[0].isDraft === true ||
+                !existingSchemas[0].schemaFileId ||
+                (isDraft === false && existingSchemas[0].isDraft === true);
+            if (shouldUpdate) {
+                logger(`Updating schemaFileId from "${existingSchemas[0].schemaFileId}" to "${schemaFileId}" for schema "${schema.name}"`);
+                updates.schemaFileId = schemaFileId;
+            }
+            else {
+                logger(`Preserving existing schemaFileId "${existingSchemas[0].schemaFileId}" for non-draft schema "${schema.name}" (new schemaFileId "${schemaFileId}" would overwrite it)`);
+            }
+        }
+        // Always update name if it's different (handles name changes)
+        if (schema.name && existingSchemas[0].name !== schema.name) {
+            updates.name = schema.name;
+        }
+        if (schemaData !== undefined) {
+            updates.schemaData = schemaData;
+        }
+        if (schema.version !== undefined && existingSchemas[0].version !== schema.version) {
+            updates.version = schema.version;
+        }
+        // If isDraft is explicitly false and we found a draft, update it to non-draft
+        if (isDraft === false && existingSchemas[0].isDraft === true) {
+            updates.isDraft = false;
+        }
+        else if (isDraft !== undefined && existingSchemas[0].isDraft !== isDraft) {
+            updates.isDraft = isDraft;
+        }
+        if (isEdited !== undefined && existingSchemas[0].isEdited !== isEdited) {
+            updates.isEdited = isEdited;
+        }
+        if (schema.updatedAt && existingSchemas[0].updatedAt !== schema.updatedAt) {
+            updates.updatedAt = schema.updatedAt;
+        }
+        if (Object.keys(updates).length > 0) {
+            logger(`Applying updates to schema "${schema.name}" (id: ${existingSchemas[0].id}):`, Object.keys(updates));
+            await db
+                .update(schemas)
+                .set(updates)
+                .where(eq(schemas.id, existingSchemas[0].id));
+            const updated = { ...existingSchemas[0], ...updates };
+            logger(`Schema "${schema.name}" updated. New schemaFileId: "${updated.schemaFileId}", isDraft: ${updated.isDraft}`);
+            return updated;
+        }
+        logger(`No updates needed for schema "${schema.name}" (id: ${existingSchemas[0].id})`);
+        return existingSchemas[0];
+    }
+    const newSchema = await db.insert(schemas).values({
+        name: schema.name,
+        version: schema.version,
+        schemaFileId: schemaFileId || null,
+        schemaData: schemaData || null,
+        isDraft: isDraft ?? false,
+        isEdited: isEdited ?? false,
+        createdAt: schema.createdAt,
+        updatedAt: schema.updatedAt,
+    }).returning();
+    // Notify React useSchemas so it can invalidate; live query often doesn't re-run when schemas table is inserted.
+    if (typeof BroadcastChannel !== 'undefined') {
+        try {
+            await new Promise((r) => setTimeout(r, 10));
+            new BroadcastChannel('seed-schemas-invalidate').postMessage({});
+        }
+        catch (_) { }
+    }
+    return newSchema[0];
+};
+/**
+ * Rename a model in the database
+ * Updates the model name and all properties that reference it
+ * @param oldName - The current model name
+ * @param newName - The new model name
+ * @param schemaNameOrId - Schema name or schema ID to scope the rename (required when multiple schemas have models with the same name)
+ * @returns The updated model record
+ */
+const renameModelInDb = async (oldName, newName, schemaNameOrId) => {
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        throw new Error('Database not found');
+    }
+    const _mod_0 = await import('./BasePathResolver-BDgc7c4T.js');
+    const _ns_0 = _mod_0.S;
+    const { schemas: schemasTable } = _ns_0;
+    // Find the model by old name, optionally scoped by schema
+    let existingModels;
+    if (schemaNameOrId !== undefined) {
+        if (typeof schemaNameOrId === 'number') {
+            const rows = await db
+                .select({
+                id: models.id,
+                name: models.name,
+                schemaFileId: models.schemaFileId,
+                isEdited: models.isEdited,
+            })
+                .from(models)
+                .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
+                .where(and(eq(models.name, oldName), eq(modelSchemas.schemaId, schemaNameOrId)))
+                .limit(1);
+            existingModels = rows;
+        }
+        else {
+            const rows = await db
+                .select({
+                id: models.id,
+                name: models.name,
+                schemaFileId: models.schemaFileId,
+                isEdited: models.isEdited,
+            })
+                .from(models)
+                .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
+                .innerJoin(schemasTable, eq(modelSchemas.schemaId, schemasTable.id))
+                .where(and(eq(models.name, oldName), eq(schemasTable.name, schemaNameOrId)))
+                .limit(1);
+            existingModels = rows;
+        }
+    }
+    else {
+        existingModels = await db
+            .select({
+            id: models.id,
+            name: models.name,
+            schemaFileId: models.schemaFileId,
+            isEdited: models.isEdited,
+        })
+            .from(models)
+            .where(eq(models.name, oldName))
+            .limit(1);
+    }
+    if (existingModels.length === 0) {
+        if (schemaNameOrId !== undefined) {
+            throw new Error(`Model "${oldName}" not found in schema "${schemaNameOrId}"`);
+        }
+        // Backward compat: model doesn't exist, create it with new name
+        const newModel = await db.insert(models).values({ name: newName }).returning();
+        return newModel[0];
+    }
+    const modelToRename = existingModels[0];
+    // Check if a model with the new name already exists in the same schema
+    let existingWithNewName;
+    if (schemaNameOrId !== undefined) {
+        if (typeof schemaNameOrId === 'number') {
+            existingWithNewName = await db
+                .select({
+                id: models.id,
+                name: models.name,
+                schemaFileId: models.schemaFileId,
+                isEdited: models.isEdited,
+            })
+                .from(models)
+                .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
+                .where(and(eq(models.name, newName), eq(modelSchemas.schemaId, schemaNameOrId)))
+                .limit(1);
+        }
+        else {
+            existingWithNewName = await db
+                .select({
+                id: models.id,
+                name: models.name,
+                schemaFileId: models.schemaFileId,
+                isEdited: models.isEdited,
+            })
+                .from(models)
+                .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
+                .innerJoin(schemasTable, eq(modelSchemas.schemaId, schemasTable.id))
+                .where(and(eq(models.name, newName), eq(schemasTable.name, schemaNameOrId)))
+                .limit(1);
+        }
+    }
+    else {
+        existingWithNewName = await db
+            .select({
+            id: models.id,
+            name: models.name,
+            schemaFileId: models.schemaFileId,
+            isEdited: models.isEdited,
+        })
+            .from(models)
+            .where(eq(models.name, newName))
+            .limit(1);
+    }
+    if (existingWithNewName.length > 0) {
+        // New name already exists in this schema, return it
+        return existingWithNewName[0];
+    }
+    // Update the model name
+    await db
+        .update(models)
+        .set({ name: newName })
+        .where(eq(models.id, modelToRename.id));
+    return { ...modelToRename, name: newName };
+};
+/**
+ * Check if a property has been locally edited (has unsaved changes)
+ * This checks both the in-memory cache (for current session) and the database
+ * (for persistence across reloads) by comparing database values with schema file values.
+ * @param modelName - The name of the model
+ * @param propertyName - The name of the property
+ * @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) {
+    try {
+        // When schemaFileValue is provided (schema sync path), do database check FIRST.
+        // This avoids the ModelProperty dynamic import which can hang due to circular
+        // dependency (ModelProperty -> helpers/db) when called from addModelsToDb during init.
+        if (schemaFileValue) {
+            const db = BaseDb.getAppDb();
+            if (db) {
+                // Find the model
+                const modelRecords = await db
+                    .select()
+                    .from(models)
+                    .where(eq(models.name, modelName))
+                    .limit(1);
+                if (modelRecords.length > 0) {
+                    const modelRecord = modelRecords[0];
+                    // Find the property in the database
+                    const propertyRecords = await db
+                        .select()
+                        .from(properties)
+                        .where(and(eq(properties.name, propertyName), eq(properties.modelId, modelRecord.id)))
+                        .limit(1);
+                    if (propertyRecords.length > 0) {
+                        const dbProperty = propertyRecords[0];
+                        // Compare database value with schema file value
+                        // If they differ, the property has been edited
+                        if (dbProperty.dataType !== schemaFileValue.dataType) {
+                            logger(`Property ${modelName}:${propertyName} has been edited (dataType differs: DB=${dbProperty.dataType}, Schema=${schemaFileValue.dataType})`);
+                            return true;
+                        }
+                        // 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;
+                                if (dbProperty.refModelId !== expectedRefModelId) {
+                                    logger(`Property ${modelName}:${propertyName} has been edited (refModelId differs)`);
+                                    return true;
+                                }
+                            }
+                        }
+                        else if (dbProperty.refModelId !== null) {
+                            // Schema file has no ref, but DB has one
+                            logger(`Property ${modelName}:${propertyName} has been edited (refModelId differs)`);
+                            return true;
+                        }
+                        // Check refValueType
+                        if (dbProperty.refValueType !== (schemaFileValue.refValueType || null)) {
+                            logger(`Property ${modelName}:${propertyName} has been edited (refValueType differs)`);
+                            return true;
+                        }
+                        // Check required (for Relation/Image properties)
+                        if (schemaFileValue.required !== undefined) {
+                            const schemaRequired = !!schemaFileValue.required;
+                            const dbRequired = dbProperty.required === true;
+                            if (dbRequired !== schemaRequired) {
+                                logger(`Property ${modelName}:${propertyName} has been edited (required differs: DB=${dbRequired}, Schema=${schemaRequired})`);
+                                return true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    catch (error) {
+        // If we can't check, assume it's not edited to be safe
+        logger('Error checking if property is edited:', error);
+        return false;
+    }
+}
+/**
+ * Adds models and their properties to the database.
+ * Optionally connects models to a schema via join records.
+ * @param models - The model definitions to add
+ * @param schema - Optional schema to connect models to
+ * @param modelRenames - Optional map of old model names to new model names for handling renames
+ * @param schemaFileData - Optional object containing schemaFileId mappings from JSON file: { schemaFileId, modelFileIds: Map<modelName, id>, propertyFileIds: Map<modelName, Map<propertyName, id>> }
+ */
+const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) => {
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        throw new Error('Database not found');
+    }
+    // If schema is provided, add it to the database
+    // Note: schema might already be a database record (with id) if passed from importJsonSchema
+    let schemaRecord;
+    if (schema) {
+        // Check if schema already has an id (it's already a database record)
+        // SchemaType includes id, so check if it's set
+        if (schema.id !== null && schema.id !== undefined) {
+            schemaRecord = schema;
+            logger(`Using existing schema record with id: ${schemaRecord.id}`);
+        }
+        else {
+            schemaRecord = await addSchemaToDb(schema, schemaFileData?.schemaFileId);
+            logger(`Created/found schema record with id: ${schemaRecord.id}`);
+        }
+    }
+    // Handle model renames first if provided
+    if (modelRenames && schemaRecord) {
+        const schemaNameOrId = schemaRecord.name ?? schemaRecord.id;
+        for (const [oldName, newName] of modelRenames.entries()) {
+            await renameModelInDb(oldName, newName, schemaNameOrId);
+        }
+    }
+    // Search for all models by schemaFileId (preferred) or name and create them if they don't exist
+    const modelRecords = new Map();
+    const modelProcessingErrors = [];
+    for (const [modelName, modelClass] of Object.entries(models$1)) {
+        try {
+            const modelFileId = schemaFileData?.modelFileIds?.get(modelName);
+            let modelRecord = await findOrCreateModelRecord(db, modelName, modelFileId);
+            // 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).
+            if (modelFileId && modelRecord.schemaFileId !== modelFileId) {
+                const existingWithFileId = await db
+                    .select()
+                    .from(models)
+                    .where(eq(models.schemaFileId, modelFileId))
+                    .limit(1);
+                if (existingWithFileId.length > 0 && existingWithFileId[0].id !== modelRecord.id) {
+                    logger(`WARNING: Model "${modelName}" (id: ${modelRecord.id}) conflicts with existing model "${existingWithFileId[0].name}" (id: ${existingWithFileId[0].id}) both trying to use schemaFileId "${modelFileId}"`);
+                    modelRecord = existingWithFileId[0];
+                }
+                else if (!modelRecord.schemaFileId) {
+                    await db
+                        .update(models)
+                        .set({ schemaFileId: modelFileId })
+                        .where(eq(models.id, modelRecord.id));
+                    modelRecord = { ...modelRecord, schemaFileId: modelFileId };
+                }
+            }
+            modelRecords.set(modelName, modelRecord);
+            // Get all existing properties for this model upfront to handle renamed properties
+            const allDbProperties = await db
+                .select()
+                .from(properties)
+                .where(eq(properties.modelId, modelRecord.id));
+            // Track which DB properties have been matched to schema properties
+            const matchedDbPropertyIds = new Set();
+            // Get properties from Model context (where they're stored as an object when Model is created)
+            // modelClass.properties returns ModelProperty instances from DB, but we need the context properties
+            // which are stored as an object when Model.create() is called with properties
+            const modelContext = modelClass._getSnapshotContext?.() || {};
+            const contextProperties = modelContext.properties || {};
+            // When models are created from JSON, properties are stored as _pendingPropertyDefinitions
+            const pendingProperties = modelContext._pendingPropertyDefinitions || {};
+            // If context properties are empty, try modelClass.properties (for backward compatibility)
+            // but convert ModelProperty instances to object format
+            let schema = {};
+            if (Object.keys(contextProperties).length > 0) {
+                schema = contextProperties;
+            }
+            else if (Object.keys(pendingProperties).length > 0) {
+                // Use pending property definitions (from JSON import)
+                schema = pendingProperties;
+            }
+            else {
+                const _mod_1 = await import('./index--F3Wolt5.js');
+                const _ns_1 = _mod_1.ac;
+                const modelHelpersMod = _ns_1;
+                const { modelPropertiesToObject } = modelHelpersMod;
+                const modelProperties = modelClass.properties || [];
+                schema = modelPropertiesToObject(modelProperties);
+            }
+            const schemaPropertyNames = new Set(Object.keys(schema));
+            // Search for all properties and create them if they don't exist
+            // Properties are unique by name + modelId, so we search using both
+            const schemaEntries = Object.entries(schema);
+            for (let index = 0; index < schemaEntries.length; index++) {
+                const [propertyName, propertyValues] = schemaEntries[index];
+                if (!propertyValues) {
+                    throw new Error(`Property values not found for ${propertyName}`);
+                }
+                // Get property schemaFileId if available
+                let propertyFileId = schemaFileData?.propertyFileIds?.get(modelName)?.get(propertyName);
+                // If no propertyFileId from map, generate a random ID
+                // IDs should be generated in the import process before calling addModelsToDb
+                if (!propertyFileId) {
+                    const _mod_2 = await import('./index--F3Wolt5.js');
+                    const _ns_2 = _mod_2.ab;
+                    const { generateId } = _ns_2;
+                    propertyFileId = generateId();
+                    logger(`Generated propertyFileId "${propertyFileId}" for property "${modelName}:${propertyName}" (not found in propertyFileIds map)`);
+                }
+                // First, try to find by schemaFileId (preferred for change tracking)
+                let existingProperty;
+                if (propertyFileId) {
+                    existingProperty = allDbProperties.find((p) => p.schemaFileId === propertyFileId && !matchedDbPropertyIds.has(p.id));
+                }
+                // Fallback: check if property exists by name + modelId
+                if (!existingProperty) {
+                    existingProperty = allDbProperties.find((p) => p.name === propertyName && !matchedDbPropertyIds.has(p.id));
+                }
+                // Prepare property values
+                const propertyData = {
+                    name: propertyName,
+                    modelId: modelRecord.id,
+                    dataType: propertyValues.dataType,
+                    schemaFileId: propertyFileId || null,
+                    required: propertyValues.required ?? false,
+                };
+                // Handle ref property - create ref model if needed
+                // Check both ref and refModelName (refModelName is set by createModelFromJson)
+                let expectedRefModelId = null;
+                const refModelName = propertyValues.ref || propertyValues.refModelName;
+                if (refModelName) {
+                    // When ref model was already processed in this batch, use it (avoids db round-trip)
+                    const cachedRef = modelRecords.get(refModelName);
+                    const refModelFileId = schemaFileData?.modelFileIds?.get(refModelName);
+                    const refModel = cachedRef
+                        ? cachedRef
+                        : await findOrCreateModelRecord(db, refModelName, refModelFileId);
+                    if (!cachedRef) {
+                        modelRecords.set(refModelName, refModel);
+                    }
+                    propertyData.refModelId = refModel.id ?? null;
+                    expectedRefModelId = refModel.id ?? null;
+                }
+                else {
+                    // If it's not a Relation type, ensure refModelId is null
+                    propertyData.refModelId = null;
+                }
+                if (propertyValues.refValueType) {
+                    propertyData.refValueType = propertyValues.refValueType;
+                }
+                else {
+                    // If refValueType is not set, ensure it's null
+                    propertyData.refValueType = null;
+                }
+                // If not found by name, try to find by position/characteristics (for renamed properties)
+                if (!existingProperty) {
+                    // Look for unmatched DB properties that could be this renamed property
+                    // Match by: same dataType, same refModelId (if applicable), and not matching any schema property name
+                    const potentialMatches = allDbProperties.filter((p) => !matchedDbPropertyIds.has(p.id) &&
+                        !schemaPropertyNames.has(p.name) && // This DB property doesn't match any schema property name
+                        p.dataType === propertyValues.dataType &&
+                        (expectedRefModelId === null
+                            ? p.refModelId === null
+                            : p.refModelId === expectedRefModelId) &&
+                        (propertyValues.refValueType
+                            ? p.refValueType === propertyValues.refValueType
+                            : p.refValueType === null));
+                    // If we find exactly one match, or if we're at the same position index, use it
+                    // For now, use the first match (could be enhanced to use position more precisely)
+                    if (potentialMatches.length > 0) {
+                        const matchedProperty = potentialMatches[0];
+                        existingProperty = matchedProperty;
+                        logger(`Found renamed property: ${modelName}:${matchedProperty.name} -> ${propertyName} (matched by characteristics)`);
+                    }
+                }
+                if (existingProperty) {
+                    // Mark this DB property as matched
+                    matchedDbPropertyIds.add(existingProperty.id);
+                    // When syncing from schema (schemaFileData present), skip the expensive checkIfPropertyIsEdited.
+                    // It can hang for minutes in browser due to circular deps / SQLite contention during init.
+                    // Use DB isEdited column as a fast check: if already marked edited, preserve.
+                    const skipEditCheck = !!schemaFileData;
+                    const isPropertyEdited = skipEditCheck
+                        ? existingProperty.isEdited === true
+                        : await checkIfPropertyIsEdited(modelName, existingProperty.name, {
+                            dataType: propertyValues.dataType,
+                            ref: propertyValues.ref,
+                            refValueType: propertyValues.refValueType,
+                            required: propertyValues.required,
+                        });
+                    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`);
+                        continue;
+                    }
+                    // Property exists (possibly with different name) - update it with new values from schema file
+                    // This handles both regular updates and renames
+                    // Ensure schemaFileId is updated if we have it
+                    // Preserve existing isEdited value if it was true (local edits take precedence)
+                    const updateData = { ...propertyData };
+                    if (existingProperty.isEdited === true) {
+                        // Preserve isEdited = true if property was locally edited
+                        delete updateData.isEdited;
+                    }
+                    else {
+                        updateData.isEdited = false;
+                    }
+                    // Skip db.update when data unchanged (avoids slow OPFS writes in browser)
+                    const unchanged = existingProperty.name === updateData.name &&
+                        existingProperty.dataType === updateData.dataType &&
+                        existingProperty.schemaFileId === (updateData.schemaFileId ?? null) &&
+                        existingProperty.required === (updateData.required ?? false) &&
+                        existingProperty.refModelId === (updateData.refModelId ?? null) &&
+                        existingProperty.refValueType === (updateData.refValueType ?? null) &&
+                        existingProperty.isEdited === (updateData.isEdited ?? false);
+                    if (!unchanged) {
+                        await db
+                            .update(properties)
+                            .set(updateData)
+                            .where(eq(properties.id, existingProperty.id));
+                    }
+                }
+                else {
+                    // Property doesn't exist, create it with schemaFileId
+                    // Set isEdited = false when loading from schema file
+                    const propertyDataWithIsEdited = {
+                        ...propertyData,
+                        isEdited: false,
+                    };
+                    // Global schemaFileId lookup (unique across all models) before insert — avoids
+                    // UNIQUE races when the property already exists on another model row or from a prior pass.
+                    if (propertyFileId) {
+                        const existingByFileId = await db
+                            .select()
+                            .from(properties)
+                            .where(eq(properties.schemaFileId, propertyFileId))
+                            .limit(1);
+                        if (existingByFileId.length > 0) {
+                            const found = existingByFileId[0];
+                            matchedDbPropertyIds.add(found.id);
+                            logger(`Property ${modelName}:${propertyName} already exists by schemaFileId "${propertyFileId}" (id: ${found.id}), skipping insert`);
+                            continue;
+                        }
+                    }
+                    logger(`Creating new property ${modelName}:${propertyName} with schemaFileId: ${propertyData.schemaFileId}`);
+                    try {
+                        await db.insert(properties).values(propertyDataWithIsEdited);
+                    }
+                    catch (insertError) {
+                        // Treat UNIQUE constraint as success - property already exists (e.g. from concurrent addModelsToDb call)
+                        if (isSqliteUniqueConstraintError(insertError)) {
+                            logger(`Property ${modelName}:${propertyName} already exists (UNIQUE constraint), treating as success`);
+                        }
+                        else {
+                            throw insertError;
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            const errorMessage = error?.message || String(error);
+            logger(`Error processing model "${modelName}": ${errorMessage}`);
+            modelProcessingErrors.push({ modelName, error: errorMessage });
+            // Continue processing other models even if one fails
+        }
+    }
+    if (modelProcessingErrors.length > 0) {
+        console.warn(`[addModelsToDb] Errors occurred while processing ${modelProcessingErrors.length} model(s):`, modelProcessingErrors.map(e => `${e.modelName}: ${e.error}`).join('; '));
+        logger(`Errors processing models: ${modelProcessingErrors.map(e => e.modelName).join(', ')}`);
+    }
+    // If schema was provided, create modelSchema join records to connect models to the schema
+    if (schemaRecord && schemaRecord.id) {
+        const modelIds = [...modelRecords.entries()]
+            .filter(([, r]) => r.id)
+            .map(([name, r]) => ({ modelName: name, modelId: r.id }));
+        if (modelIds.length === 0) {
+            logger('No model IDs to link, skipping schema linking');
+        }
+        else {
+            // Single batch query: get all existing joins for this schema
+            const existingJoins = await db
+                .select({ modelId: modelSchemas.modelId })
+                .from(modelSchemas)
+                .where(eq(modelSchemas.schemaId, schemaRecord.id));
+            const existingSet = new Set(existingJoins.map((r) => r.modelId));
+            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,
+                    });
+                    logger(`Created join table entry for model ${modelName} (id: ${modelId}) to schema (id: ${schemaRecord.id})`);
+                }
+            }
+        }
+    }
+    else if (schemaRecord && !schemaRecord.id) {
+        logger(`Warning: schemaRecord provided but has no id, cannot create join table entries`);
+    }
+};
+/**
+ * Loads models from the database for a given schema by querying the model_schemas join table.
+ * This ensures that models added to the database (via model_schemas) are included even if
+ * they're not in the schemaData JSON.
+ * @param schemaId - The ID of the schema record in the database
+ * @returns A map of model names to model data (compatible with SchemaFileFormat.models)
+ */
+const loadModelsFromDbForSchema = async (schemaId) => {
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        logger('Database not found, cannot load models from DB');
+        return {};
+    }
+    try {
+        // Query model_schemas join table to find all models linked to this schema
+        const modelSchemaRecords = 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 models$1 = {};
+        // For each model, load its properties
+        for (const { modelId, modelName, schemaFileId } of modelSchemaRecords) {
+            if (!modelId || !modelName)
+                continue;
+            // Get all properties for this model
+            const propertyRecords = await db
+                .select()
+                .from(properties)
+                .where(eq(properties.modelId, modelId));
+            // Reconstruct properties object
+            const modelProperties = {};
+            for (const prop of propertyRecords) {
+                // Build a basic property structure from database fields
+                // Note: This is a simplified reconstruction - full property schemas
+                // (like Relation details, List configs, etc.) should come from schemaData
+                const propertyData = {
+                    dataType: prop.dataType,
+                };
+                if (prop.schemaFileId) {
+                    propertyData.schemaFileId = prop.schemaFileId;
+                }
+                // Add ref information if it's a relation
+                if (prop.refModelId) {
+                    // Get the referenced model name
+                    const refModelRecords = await db
+                        .select({ name: models.name })
+                        .from(models)
+                        .where(eq(models.id, prop.refModelId))
+                        .limit(1);
+                    if (refModelRecords.length > 0) {
+                        propertyData.ref = refModelRecords[0].name;
+                    }
+                }
+                if (prop.refValueType) {
+                    propertyData.refValueType = prop.refValueType;
+                }
+                modelProperties[prop.name] = propertyData;
+            }
+            // Create model structure. Include id (schemaFileId) so processSchemaFiles can populate
+            // modelFileIds and Model.create can skip duplicate-name logic, preventing model
+            // duplication on reload (Post 1 1, Post 2 1, etc.).
+            models$1[modelName] = {
+                properties: modelProperties,
+                ...(schemaFileId ? { id: schemaFileId } : {}),
+                // Note: description would need to be stored separately
+                // or reconstructed from schemaData if available
+            };
+        }
+        logger(`Loaded ${Object.keys(models$1).length} models from database for schema ${schemaId}`);
+        return models$1;
+    }
+    catch (error) {
+        logger(`Error loading models from database for schema ${schemaId}:`, error);
+        return {};
+    }
+};
+/**
+ * Returns model name by database model ID.
+ */
+async function getModelNameByModelId(modelId) {
+    const db = BaseDb.getAppDb();
+    if (!db)
+        return undefined;
+    try {
+        const rows = await db
+            .select({ name: models.name })
+            .from(models)
+            .where(eq(models.id, modelId))
+            .limit(1);
+        return rows.length > 0 ? rows[0].name : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Resolves modelName and dataType for a property by its schemaFileId (e.g. context.id).
+ * Used when machine context lacks these (e.g. just-created property renamed before full context is set).
+ */
+async function getPropertyModelNameAndDataType(schemaFileId) {
+    const db = BaseDb.getAppDb();
+    if (!db || !schemaFileId)
+        return undefined;
+    try {
+        const rows = await db
+            .select({
+            dataType: properties.dataType,
+            modelId: properties.modelId,
+        })
+            .from(properties)
+            .where(eq(properties.schemaFileId, schemaFileId))
+            .limit(1);
+        if (rows.length === 0)
+            return undefined;
+        const modelRows = await db
+            .select({ name: models.name })
+            .from(models)
+            .where(eq(models.id, rows[0].modelId))
+            .limit(1);
+        if (modelRows.length === 0)
+            return undefined;
+        return {
+            modelName: modelRows[0].name,
+            dataType: rows[0].dataType ?? '',
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Saves a property's changes to the database without updating the JSON schema file.
+ * This is used when properties are edited but the schema hasn't been saved as a new version yet.
+ * @param property - The ModelPropertyMachineContext with updated values
+ */
+const savePropertyToDb = async (property) => {
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        throw new Error('Database not found');
+    }
+    if (!property.name) {
+        throw new Error('Property name is required');
+    }
+    // Find the model: prefer modelId (reliable), then modelName as name, then modelName as schemaFileId
+    // (context.modelName can be a model schemaFileId when schema uses that as identifier)
+    let modelRecord;
+    if (property.modelId != null && typeof property.modelId === 'number') {
+        const byId = await db
+            .select()
+            .from(models)
+            .where(eq(models.id, property.modelId))
+            .limit(1);
+        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];
+    }
+    if (!modelRecord && property.modelName) {
+        const bySchemaFileId = await db
+            .select()
+            .from(models)
+            .where(eq(models.schemaFileId, property.modelName))
+            .limit(1);
+        modelRecord = bySchemaFileId[0];
+    }
+    // Fallback: resolve model from existing property row (by schemaFileId) when modelName is wrong
+    const schemaFileId = property._propertyFileId || (typeof property.id === 'string' ? property.id : undefined);
+    if (!modelRecord && schemaFileId) {
+        const propRows = await db
+            .select({ modelId: properties.modelId })
+            .from(properties)
+            .where(eq(properties.schemaFileId, schemaFileId))
+            .limit(1);
+        if (propRows.length > 0 && propRows[0].modelId) {
+            const byPropModelId = await db
+                .select()
+                .from(models)
+                .where(eq(models.id, propRows[0].modelId))
+                .limit(1);
+            modelRecord = byPropModelId[0];
+        }
+    }
+    if (!modelRecord) {
+        throw new Error(`Model not found in database (modelId=${property.modelId}, modelName=${property.modelName})`);
+    }
+    // Find existing property - try multiple strategies to handle name changes
+    // 1. First try by schemaFileId (most reliable - doesn't change when name changes)
+    let existingProperties = [];
+    logger(`[savePropertyToDb] Looking for property ${property.modelName}:${property.name} (schemaFileId: ${schemaFileId}, originalName: ${property._originalValues?.name})`);
+    if (schemaFileId) {
+        existingProperties = await db
+            .select()
+            .from(properties)
+            .where(and(eq(properties.schemaFileId, schemaFileId), eq(properties.modelId, modelRecord.id)))
+            .limit(1);
+        logger(`[savePropertyToDb] Found ${existingProperties.length} properties by schemaFileId`);
+    }
+    // 2. If not found by schemaFileId, try by original name (if name was changed)
+    if (existingProperties.length === 0 && property._originalValues?.name && property._originalValues.name !== property.name) {
+        logger(`[savePropertyToDb] Trying to find by original name: ${property._originalValues.name}`);
+        existingProperties = await db
+            .select()
+            .from(properties)
+            .where(and(eq(properties.name, property._originalValues.name), eq(properties.modelId, modelRecord.id)))
+            .limit(1);
+        logger(`[savePropertyToDb] Found ${existingProperties.length} properties by original name`);
+    }
+    // 3. Fallback: try by current name
+    if (existingProperties.length === 0) {
+        logger(`[savePropertyToDb] Trying to find by current name: ${property.name}`);
+        existingProperties = await db
+            .select()
+            .from(properties)
+            .where(and(eq(properties.name, property.name), eq(properties.modelId, modelRecord.id)))
+            .limit(1);
+        logger(`[savePropertyToDb] Found ${existingProperties.length} properties by current name`);
+    }
+    // Prepare property data
+    const propertyData = {
+        name: property.name,
+        modelId: modelRecord.id,
+        dataType: property.dataType || '',
+    };
+    // Preserve schemaFileId if we have it
+    if (schemaFileId) {
+        propertyData.schemaFileId = schemaFileId;
+    }
+    // Handle ref property - create ref model if needed
+    if (property.refModelName) {
+        const refModel = await createOrUpdate(db, models, {
+            name: property.refModelName,
+        });
+        propertyData.refModelId = refModel.id;
+    }
+    else if (property.refModelId) {
+        propertyData.refModelId = property.refModelId;
+    }
+    else {
+        // If it's not a Relation type, ensure refModelId is null
+        propertyData.refModelId = null;
+    }
+    if (property.refValueType) {
+        propertyData.refValueType = property.refValueType;
+    }
+    else {
+        // If refValueType is not set, ensure it's null
+        propertyData.refValueType = null;
+    }
+    propertyData.required = property.required ?? false;
+    if (existingProperties.length > 0) {
+        // Property exists, update it with new values (including new name)
+        // Set isEdited = true when property is edited
+        const existingProperty = existingProperties[0];
+        await db
+            .update(properties)
+            .set({
+            ...propertyData,
+            isEdited: true, // Mark as edited when saving changes
+        })
+            .where(eq(properties.id, existingProperty.id));
+        logger(`Updated property ${property.modelName}:${property._originalValues?.name || 'unknown'} -> ${property.name} in database`);
+    }
+    else {
+        // Property doesn't exist, create it
+        // Set isEdited = true for runtime-created properties
+        try {
+            await db.insert(properties).values({
+                ...propertyData,
+                isEdited: true, // Runtime-created properties are edited
+            });
+            logger(`Created property ${property.modelName}:${property.name} in database`);
+        }
+        catch (insertError) {
+            // Treat UNIQUE constraint as success - property already exists (e.g. from concurrent addModelsToDb or race)
+            if (isSqliteUniqueConstraintError(insertError)) {
+                logger(`Property ${property.modelName}:${property.name} already exists (UNIQUE constraint), treating as success`);
+            }
+            else {
+                throw insertError;
+            }
+        }
+    }
+};
+function parseAddressConfig(value) {
+    if (!value)
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        if (Array.isArray(parsed)) {
+            return { owned: parsed, watched: [] };
+        }
+        if (parsed && typeof parsed === 'object' && Array.isArray(parsed.owned)) {
+            return {
+                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 ?? [];
+};
+/**
+ * Returns addresses for useItems/getItemsData addressFilter.
+ * Encapsulates owned (with additional sync addresses) and watched logic.
+ */
+const getAddressesForItemsFilter = async (addressFilter) => {
+    if (addressFilter === 'owned') {
+        const _mod_3 = await import('./index--F3Wolt5.js');
+        const _ns_3 = _mod_3.aa;
+        const { getGetAdditionalSyncAddresses } = _ns_3;
+        let ownedAddresses = await getOwnedAddressesFromDb();
+        const additionalGetter = getGetAdditionalSyncAddresses();
+        if (additionalGetter) {
+            const additional = await additionalGetter();
+            if (additional?.length) {
+                const seen = new Set(ownedAddresses.map((a) => a.toLowerCase()));
+                for (const addr of additional) {
+                    if (addr && !seen.has(addr.toLowerCase())) {
+                        seen.add(addr.toLowerCase());
+                        ownedAddresses = [...ownedAddresses, addr];
+                    }
+                }
+            }
+        }
+        return ownedAddresses;
+    }
+    return getWatchedAddressesFromDb();
+};
+/**
+ * Returns owned + watched addresses. Use for EAS sync and file download.
+ */
+const getAllAddressesFromDb = async () => {
+    const config = await getAddressConfigFromDb();
+    if (!config)
+        return [];
+    return [...config.owned, ...config.watched];
+};
+async function getAddressConfigFromDb() {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb) {
+        return new Promise((resolve) => {
+            setTimeout(async () => {
+                resolve(await getAddressConfigFromDb());
+            }, 500);
+        });
+    }
+    const appStatesRecords = await appDb
+        .select()
+        .from(appState)
+        .where(eq(appState.key, 'addresses'))
+        .limit(1);
+    if (!appStatesRecords || appStatesRecords.length === 0) {
+        return null;
+    }
+    const addressArrayString = appStatesRecords[0].value;
+    return parseAddressConfig(addressArrayString);
+}
+const getAddressesFromDb = async () => {
+    const config = await getAddressConfigFromDb();
+    if (!config || config.owned.length === 0) {
+        throw new Error('No addresses found');
+    }
+    return config.owned;
+};
+/**
+ * Like getAddressesFromDb but returns [] instead of throwing when no addresses are configured.
+ * Returns owned addresses. Use getAllAddressesFromDb for sync (owned + watched).
+ */
+const getAddressesFromDbOptional = async () => {
+    const config = await getAddressConfigFromDb();
+    return config?.owned ?? [];
+};
+/**
+ * Write model to database and create model_schemas join entry
+ * @param modelFileId - The model file ID (schema_file_id)
+ * @param data - Model data including modelName, schemaId, and optional properties
+ */
+async function writeModelToDb(modelFileId, data) {
+    const db = BaseDb.getAppDb();
+    if (!db)
+        throw new Error('Database not available');
+    // Find or create model record
+    let modelRecords = await db
+        .select()
+        .from(models)
+        .where(eq(models.schemaFileId, modelFileId))
+        .limit(1);
+    let modelId;
+    if (modelRecords.length === 0) {
+        // Create new model record
+        // Check again right before insert to avoid race conditions
+        const doubleCheck = await db
+            .select()
+            .from(models)
+            .where(eq(models.schemaFileId, modelFileId))
+            .limit(1);
+        if (doubleCheck.length > 0) {
+            // Another process created it, use existing
+            modelId = doubleCheck[0].id;
+            logger(`Model with schemaFileId "${modelFileId}" was created by another process, using existing record (id: ${modelId})`);
+        }
+        else {
+            try {
+                const newModel = await db.insert(models).values({
+                    name: data.modelName,
+                    schemaFileId: modelFileId,
+                    isEdited: true, // Runtime-created models are edited
+                }).returning();
+                modelId = newModel[0].id;
+            }
+            catch (error) {
+                // Handle unique constraint violation
+                if (isSqliteUniqueConstraintError(error)) {
+                    logger(`Unique constraint violation for schemaFileId "${modelFileId}", attempting to find existing model`);
+                    const existing = await db
+                        .select()
+                        .from(models)
+                        .where(eq(models.schemaFileId, modelFileId))
+                        .limit(1);
+                    if (existing.length > 0) {
+                        modelId = existing[0].id;
+                        logger(`Found existing model with schemaFileId "${modelFileId}" (id: ${modelId}) after constraint violation`);
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+    }
+    else {
+        // Update existing model record
+        modelId = modelRecords[0].id;
+        const updates = {};
+        if (data.modelName !== modelRecords[0].name) {
+            updates.name = data.modelName;
+        }
+        if (Object.keys(updates).length > 0) {
+            await db
+                .update(models)
+                .set(updates)
+                .where(eq(models.id, modelId));
+        }
+    }
+    // Validate that modelId and schemaId are valid before creating join entry
+    if (!modelId || !Number.isInteger(modelId) || modelId <= 0) {
+        throw new Error(`Invalid modelId: ${modelId}. Model record must be created successfully before creating join entry.`);
+    }
+    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.`);
+    }
+    // Create model_schemas join entry
+    // CRITICAL: This must happen AFTER the model record is fully saved and committed
+    // The modelId comes from .returning() which ensures the record is committed
+    const existingJoin = await db
+        .select()
+        .from(modelSchemas)
+        .where(and(eq(modelSchemas.modelId, modelId), eq(modelSchemas.schemaId, data.schemaId)))
+        .limit(1);
+    if (existingJoin.length === 0) {
+        // Only provide modelId and schemaId - id is auto-increment and should not be included
+        // Don't use type cast - let Drizzle infer the correct type without id
+        // Verify both modelId and schemaId exist before inserting join record
+        try {
+            // Verify modelId exists
+            const modelCheck = await db
+                .select({ id: models.id })
+                .from(models)
+                .where(eq(models.id, modelId))
+                .limit(1);
+            if (modelCheck.length === 0) {
+                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_4 = await import('./BasePathResolver-BDgc7c4T.js');
+            const _ns_4 = _mod_4.S;
+            const schemaSchemaMod = _ns_4;
+            const { schemas: schemasTable } = schemaSchemaMod;
+            const schemaCheck = await db
+                .select({
+                id: schemasTable.id,
+                name: schemasTable.name,
+                schemaFileId: schemasTable.schemaFileId,
+            })
+                .from(schemasTable)
+                .where(eq(schemasTable.id, data.schemaId))
+                .limit(1);
+            if (schemaCheck.length === 0) {
+                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,
+            });
+            // 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') {
+                await new Promise((r) => setTimeout(r, 10));
+                const row = schemaCheck[0];
+                try {
+                    new BroadcastChannel('seed-models-invalidate').postMessage({
+                        schemaName: row.name ?? undefined,
+                        schemaFileId: row.schemaFileId ?? undefined,
+                    });
+                }
+                catch (_) { }
+            }
+            logger(`Successfully created join record for model ${data.modelName} (id: ${modelId}) to schema (id: ${data.schemaId})`);
+        }
+        catch (error) {
+            if (error?.code === 'SQLITE_CONSTRAINT_FOREIGNKEY') {
+                logger(`FOREIGN KEY constraint failed when creating join record for model "${data.modelName}"`);
+                logger(`modelId: ${modelId}, schemaId: ${data.schemaId}`);
+                logger(`Error details:`, error);
+                // Re-throw with more context
+                throw new Error(`FOREIGN KEY constraint failed when creating join record for model "${data.modelName}" (modelId: ${modelId}, schemaId: ${data.schemaId}). ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    // Write properties if provided
+    if (data.properties) {
+        for (const [propName, propData] of Object.entries(data.properties)) {
+            // Check if property already exists in database
+            const existingProps = await db
+                .select()
+                .from(properties)
+                .where(and(eq(properties.name, propName), eq(properties.modelId, modelId)))
+                .limit(1);
+            let propertyFileId;
+            if (existingProps.length > 0 && existingProps[0].schemaFileId) {
+                // Use existing property's schemaFileId
+                propertyFileId = existingProps[0].schemaFileId;
+                logger(`Using existing propertyFileId "${propertyFileId}" for property "${data.modelName}:${propName}"`);
+            }
+            else if (propData.id) {
+                // Use provided ID
+                propertyFileId = propData.id;
+            }
+            else {
+                // Generate random propertyFileId
+                // IDs should be generated in the import process before calling writeModelToDb
+                const _mod_5 = await import('./index--F3Wolt5.js');
+                const _ns_5 = _mod_5.ab;
+                const { generateId } = _ns_5;
+                propertyFileId = generateId();
+                logger(`Generated propertyFileId "${propertyFileId}" for property "${data.modelName}:${propName}"`);
+            }
+            await writePropertyToDb(propertyFileId, {
+                modelId,
+                name: propName,
+                ...propData,
+            });
+        }
+    }
+    logger(`Wrote model ${data.modelName} (${modelFileId}) to database`);
+}
+/**
+ * Write property to database
+ * @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 (default: false)
+ */
+async function writePropertyToDb(propertyFileId, data, isEdited = false) {
+    const db = BaseDb.getAppDb();
+    if (!db)
+        throw new Error('Database not available');
+    // Find existing property by schemaFileId first (preferred for uniqueness)
+    let existingProperties = await db
+        .select()
+        .from(properties)
+        .where(eq(properties.schemaFileId, propertyFileId))
+        .limit(1);
+    // Fallback: find by modelId and name if not found by schemaFileId
+    if (existingProperties.length === 0) {
+        existingProperties = await db
+            .select()
+            .from(properties)
+            .where(and(eq(properties.name, data.name), eq(properties.modelId, data.modelId)))
+            .limit(1);
+    }
+    // Prepare property data
+    const propertyData = {
+        name: data.name,
+        modelId: data.modelId,
+        dataType: data.dataType || '',
+        schemaFileId: propertyFileId,
+        isEdited: isEdited, // Persist isEdited flag
+    };
+    // Handle ref property - create ref model if needed
+    // 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,
+        });
+        propertyData.refModelId = refModel.id;
+    }
+    else if (data.refModelId) {
+        propertyData.refModelId = data.refModelId;
+    }
+    else {
+        // If it's not a Relation type, ensure refModelId is null
+        propertyData.refModelId = null;
+    }
+    if (data.refValueType) {
+        propertyData.refValueType = data.refValueType;
+    }
+    else {
+        // 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
+    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
+        // may have the old name but we're updating to the new one.
+        const existing = existingProperties[0];
+        await db
+            .update(properties)
+            .set(propertyData)
+            .where(eq(properties.id, existing.id));
+        logger(`Updated property ${data.name} (${propertyFileId}) in database`);
+    }
+    else {
+        // Property doesn't exist, create it
+        // Double-check before insert to avoid race conditions
+        const doubleCheck = await db
+            .select()
+            .from(properties)
+            .where(eq(properties.schemaFileId, propertyFileId))
+            .limit(1);
+        if (doubleCheck.length > 0) {
+            // Another process created it, update it instead
+            await db
+                .update(properties)
+                .set(propertyData)
+                .where(eq(properties.id, doubleCheck[0].id));
+            logger(`Property with schemaFileId "${propertyFileId}" was created by another process, updated existing record`);
+        }
+        else {
+            try {
+                await db.insert(properties).values(propertyData);
+                logger(`Created property ${data.name} (${propertyFileId}) in database`);
+            }
+            catch (error) {
+                // Handle unique constraint violation
+                if (isSqliteUniqueConstraintError(error)) {
+                    logger(`Unique constraint violation for property schemaFileId "${propertyFileId}", attempting to find existing property`);
+                    const existing = await db
+                        .select()
+                        .from(properties)
+                        .where(eq(properties.schemaFileId, propertyFileId))
+                        .limit(1);
+                    if (existing.length > 0) {
+                        await db
+                            .update(properties)
+                            .set(propertyData)
+                            .where(eq(properties.id, existing[0].id));
+                        logger(`Found existing property with schemaFileId "${propertyFileId}" (id: ${existing[0].id}) after constraint violation, updated it`);
+                    }
+                    else {
+                        throw new Error(`Failed to create or find property "${data.name}" with schemaFileId "${propertyFileId}": ${error.message}`);
+                    }
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+    }
+}
+/**
+ * Get schema database ID from schema name or schemaFileId
+ * @param schemaNameOrFileId - Schema name (string) or schemaFileId (string)
+ * @returns Schema database ID
+ * @throws Error if schema not found
+ */
+async function getSchemaId(schemaNameOrFileId) {
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        throw new Error('Database not available');
+    }
+    const _mod_6 = await import('./BasePathResolver-BDgc7c4T.js');
+    const _ns_6 = _mod_6.S;
+    const schemaSchemaMod = _ns_6;
+    const { schemas: schemasTable } = schemaSchemaMod;
+    const drizzleMod = await import('drizzle-orm');
+    const { eq, desc } = drizzleMod;
+    // Try to find by schemaFileId first (more reliable)
+    let records = await db
+        .select()
+        .from(schemasTable)
+        .where(eq(schemasTable.schemaFileId, schemaNameOrFileId))
+        .orderBy(desc(schemasTable.version))
+        .limit(1);
+    // If not found by schemaFileId, try by name
+    if (records.length === 0) {
+        records = await db
+            .select()
+            .from(schemasTable)
+            .where(eq(schemasTable.name, schemaNameOrFileId))
+            .orderBy(desc(schemasTable.version))
+            .limit(1);
+    }
+    if (records.length === 0) {
+        throw new Error(`Schema "${schemaNameOrFileId}" not found in database`);
+    }
+    return records[0].id;
+}
+/**
+ * Get schema database ID from schemaFileId
+ * @param schemaFileId - The schema file ID
+ * @returns Schema database ID
+ * @throws Error if schema not found
+ */
+async function getSchemaIdByFileId(schemaFileId) {
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        throw new Error('Database not available');
+    }
+    const _mod_7 = await import('./BasePathResolver-BDgc7c4T.js');
+    const _ns_7 = _mod_7.S;
+    const schemaSchemaMod = _ns_7;
+    const { schemas: schemasTable } = schemaSchemaMod;
+    const drizzleMod = await import('drizzle-orm');
+    const { eq, desc } = drizzleMod;
+    const records = await db
+        .select()
+        .from(schemasTable)
+        .where(eq(schemasTable.schemaFileId, schemaFileId))
+        .orderBy(desc(schemasTable.version))
+        .limit(1);
+    if (records.length === 0) {
+        throw new Error(`Schema with file ID "${schemaFileId}" not found in database`);
+    }
+    return records[0].id;
+}
+/**
+ * Get model database ID from model name or modelFileId
+ * @param modelNameOrFileId - Model name (string) or modelFileId (string)
+ * @param schemaNameOrId - Optional schema name or ID to narrow search
+ * @returns Model database ID
+ * @throws Error if model not found
+ */
+async function getModelId(modelNameOrFileId, schemaNameOrId) {
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        throw new Error('Database not available');
+    }
+    const _mod_8 = await import('./BasePathResolver-BDgc7c4T.js');
+    const _ns_8 = _mod_8.M;
+    const modelSchemaMod = _ns_8;
+    const { models: modelsTable } = modelSchemaMod;
+    const drizzleMod = await import('drizzle-orm');
+    const { eq, and, or } = drizzleMod;
+    // Try to find by modelFileId first (more reliable)
+    let records = await db
+        .select()
+        .from(modelsTable)
+        .where(eq(modelsTable.schemaFileId, modelNameOrFileId))
+        .limit(1);
+    // If not found by modelFileId, try by name
+    if (records.length === 0) {
+        [eq(modelsTable.name, modelNameOrFileId)];
+        // If schema is provided, narrow the search
+        if (schemaNameOrId !== undefined) {
+            const _mod_9 = await import('./BasePathResolver-BDgc7c4T.js');
+            const _ns_9 = _mod_9.x;
+            const modelSchemaSchemaMod = _ns_9;
+            const { modelSchemas } = modelSchemaSchemaMod;
+            const _mod_10 = await import('./BasePathResolver-BDgc7c4T.js');
+            const _ns_10 = _mod_10.S;
+            const schemaSchemaMod = _ns_10;
+            const { schemas: schemasTable } = schemaSchemaMod;
+            if (typeof schemaNameOrId === 'number') {
+                // schemaNameOrId is schemaId
+                records = await db
+                    .select({ id: modelsTable.id })
+                    .from(modelsTable)
+                    .innerJoin(modelSchemas, eq(modelsTable.id, modelSchemas.modelId))
+                    .where(and(eq(modelsTable.name, modelNameOrFileId), eq(modelSchemas.schemaId, schemaNameOrId)))
+                    .limit(1);
+            }
+            else {
+                // schemaNameOrId is schemaName
+                records = await db
+                    .select({ id: modelsTable.id })
+                    .from(modelsTable)
+                    .innerJoin(modelSchemas, eq(modelsTable.id, modelSchemas.modelId))
+                    .innerJoin(schemasTable, eq(modelSchemas.schemaId, schemasTable.id))
+                    .where(and(eq(modelsTable.name, modelNameOrFileId), eq(schemasTable.name, schemaNameOrId)))
+                    .limit(1);
+            }
+        }
+        else {
+            // No schema filter, just search by name
+            records = await db
+                .select()
+                .from(modelsTable)
+                .where(eq(modelsTable.name, modelNameOrFileId))
+                .limit(1);
+        }
+    }
+    if (records.length === 0) {
+        const schemaInfo = schemaNameOrId ? ` in schema "${schemaNameOrId}"` : '';
+        throw new Error(`Model "${modelNameOrFileId}"${schemaInfo} not found in database`);
+    }
+    return records[0].id;
+}
+/**
+ * Get model database ID from modelFileId
+ * @param modelFileId - The model file ID (schema_file_id)
+ * @returns Model database ID
+ * @throws Error if model not found
+ */
+async function getModelIdByFileId(modelFileId) {
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        throw new Error('Database not available');
+    }
+    const _mod_11 = await import('./BasePathResolver-BDgc7c4T.js');
+    const _ns_11 = _mod_11.M;
+    const modelSchemaMod = _ns_11;
+    const { models: modelsTable } = modelSchemaMod;
+    const drizzleMod = await import('drizzle-orm');
+    const { eq } = drizzleMod;
+    const records = await db
+        .select()
+        .from(modelsTable)
+        .where(eq(modelsTable.schemaFileId, modelFileId))
+        .limit(1);
+    if (records.length === 0) {
+        throw new Error(`Model with file ID "${modelFileId}" not found in database`);
+    }
+    return records[0].id;
+}
+
+export { addModelsToDb, addSchemaToDb, createOrUpdate, escapeSqliteString, getAddressesForItemsFilter, getAddressesFromDb, getAddressesFromDbOptional, getAllAddressesFromDb, getModelId, getModelIdByFileId, getModelNameByModelId, getObjectForRow, getOwnedAddressesFromDb, getPropertyIdForModelAndName, getPropertyModelNameAndDataType, getSchemaId, getSchemaIdByFileId, getSqlResultObject, getWatchedAddressesFromDb, loadModelsFromDbForSchema, migrateMetadataForPropertyRename, renameModelInDb, savePropertyToDb, writeModelToDb, writePropertyToDb };
+//# sourceMappingURL=db-Cvh84NY7.js.map