@seedprotocol/sdk 0.7.5 → 0.7.6-next.957.g6bb7768

package/dist/{ClientManager-DRf4uuei.js → ClientManager-D6YA20jP.js}

@@ -1,10 +1,10 @@
 import { startCase, isEqual } from 'lodash-es';
-import { B as BaseDb, o as easSyncProcesses, I as eventEmitter, a4 as isNode, af as isBrowser, K as BasePathResolver, aF as normalizeAddressConfig, j as appState, aS as downloadAllFilesRequestHandler, aT as downloadAllFilesBinaryRequestHandler, h as BaseFileManager, t as models$1, s as modelUids, C as seeds, aG as normalizeAddressList, A as schemas, aQ as loadModelsFromDbForSchema, aN as addSchemaToDb, aK as isInternalSchema, aU as warnOnInvalidNameMatch, aV as INTERNAL_SCHEMA_IDS, al as generateId, aW as linkModelToSchema, aR as clearNameMatchLevels, n as normalizeDataType, ae as easPropertyNameForPublish, av as SEED_PROTOCOL_SCHEMA_NAME, r as modelSchemas, m as metadata$1, v as properties, N as resolveItemModelFileId, F as versions, ah as normalizePublisher, aj as loadNameMatchLevels, p as htmlEmbeddedImageCoPublish, k as arweaveL1FinalizeJobs, z as publishProcesses, aX as getWatchedAddressesFromDb, aY as getOwnedAddressesFromDb, aZ as CLIENT_NOT_INITIALIZED } from './BasePathResolver-CBTXCMFL.js';
+import { B as BaseDb, o as easSyncProcesses, I as eventEmitter, ac as isBrowser, a1 as isNode, aE as normalizeAddressConfig, aS as isTestOrSeedDev, j as appState, aT as downloadAllFilesRequestHandler, aU as downloadAllFilesBinaryRequestHandler, h as BaseFileManager, t as models$1, s as modelUids, C as seeds, aF as normalizeAddressList, A as schemas, aP as loadModelsFromDbForSchema, aM as addSchemaToDb, aJ as isInternalSchema, ai as generateId, aR as clearNameMatchLevels, aV as warnOnInvalidNameMatch, aW as INTERNAL_SCHEMA_IDS, aX as linkModelToSchema, n as normalizeDataType, ab as easPropertyNameForPublish, au as SEED_PROTOCOL_SCHEMA_NAME, r as modelSchemas, m as metadata$1, v as properties, L as resolveItemModelFileId, F as versions, ae as normalizePublisher, ag as loadNameMatchLevels, p as htmlEmbeddedImageCoPublish, k as arweaveL1FinalizeJobs, z as publishProcesses, aY as getWatchedAddressesFromDb, aZ as getOwnedAddressesFromDb, a_ as CLIENT_NOT_INITIALIZED } from './index-CrvIcVFJ.js';
 import debug from 'debug';
 import { createActor, setup, assign, fromPromise, fromCallback, waitFor } from 'xstate';
-import { u as MachineIds, a0 as ClientManagerEvents, a1 as withLockedItemStorageRow, a2 as getItemStorageFilePath, a3 as writeItemStorageFile, e as compareMetadataRowsLatestFirst, w as writeInBatches, a4 as resolvePublisherFromSeedRow, C as ClientManagerState, G as isLocalUnsealedDraft, s as selectInBatches, I as Item } from './Item-DTJPMjFk.js';
+import { u as MachineIds, a0 as ClientManagerEvents, a1 as withLockedItemStorageRow, a2 as getItemStorageFilePath, a3 as writeItemStorageFile, e as compareMetadataRowsLatestFirst, w as writeInBatches, a4 as resolvePublisherFromSeedRow, C as ClientManagerState, G as isLocalUnsealedDraft, s as selectInBatches, I as Item } from './Item-B1MH0tXx.js';
 import { eq, inArray, and, isNotNull, ne, desc, countDistinct, isNull, or, sql, like } from 'drizzle-orm';
-import { a as withDbTabLock, i as isLeaderTab, c as postTabMessage, o as onTabMessage, w as whenLeaderTab, l as listenForOtherTabsEvents, s as startTabCoordination, b as withSeedDbLock, e as emitAcrossTabs, A as ADDRESSES_PERSISTED_EVENT, p as parseAddressesPersistedPayload, L as LOCAL_COPIES_REMOVED_EVENT } from './tabEvents-BGBYV65P.js';
+import { a as withDbTabLock, i as isLeaderTab, c as postTabMessage, o as onTabMessage, w as whenLeaderTab, l as listenForOtherTabsEvents, s as startTabCoordination, b as withSeedDbLock, e as emitAcrossTabs, A as ADDRESSES_PERSISTED_EVENT, p as parseAddressesPersistedPayload, L as LOCAL_COPIES_REMOVED_EVENT } from './tabEvents-D9x26vf2.js';
 import { seedGatewayConfigFromSeedConfig, setPreferredArweaveReadBaseUrls, resolveSeedGatewayEndpoints, setResolvedSeedGatewayEndpoints, BaseArweaveClient, ensureReadGatewaySelected, DEFAULT_ARWEAVE_HOST } from '@seedprotocol/arweave';
 import { configureEasReadChain, easName, BaseQueryClient, BaseEasClient, GET_SCHEMAS, whenEasReadChainSettled, getEasReadChainId, DEFAULT_EAS_CHAIN_ID, isEasReadChainConfigured, isPlaceholderUid, localNamesInBestMatchTier, isValidEasAttestationUid } from '@seedprotocol/eas';
 import 'pluralize';
@@ -212,7 +212,7 @@ function toRunSyncArg(options) {
     return undefined;
 }
 const runEasSync = fromPromise(async ({ input, }) => {
-    const { runSyncFromEas } = await import('./syncDbWithEas-CrAY9Rl2.js');
+    const { runSyncFromEas } = await import('./syncDbWithEas-Y5GysSCm.js');
     // Sync checks for rows and then inserts the rest (no unique index on uids), so syncs in
     // different tabs take turns. A sync can run for minutes, so wait without a timeout.
     await withDbTabLock('eas-sync', async () => {
@@ -542,39 +542,28 @@ const setupServiceHandlers = () => {
     eventEmitter.addListener('service.save', saveServiceHandler);
 };
 
+/** `filesDir` when the config sets neither it nor `endpoints.files`. */
+const DEFAULT_FILES_DIR = '.seed';
 /**
- * On Node, storage uses `filesDir`. `endpoints.filePaths` and `endpoints.files` are
- * required by init but have no separate Node consumer, so fill them from `filesDir`.
- * Browser configs are left unchanged.
+ * Fills `filesDir` and `endpoints` so `client.init` can be called with neither. `filesDir` falls
+ * back to `endpoints.files`, then to {@link DEFAULT_FILES_DIR}. The endpoint labels have no consumer
+ * besides that fallback and the copy saved in `app_state`, so missing ones take `filesDir`.
  */
-function normalizeSeedConfigEndpoints(config) {
+function applySeedConfigDefaults(config) {
     if (!config)
         return config;
     const endpoints = config.endpoints;
     if (endpoints?.filePaths && endpoints?.files)
         return config;
-    if (!(isNode() && !isBrowser()))
-        return config;
-    const filesDir = config.filesDir;
-    if (!filesDir)
-        return config;
+    const filesDir = config.filesDir || endpoints?.files || DEFAULT_FILES_DIR;
     const next = {
         filePaths: endpoints?.filePaths || filesDir,
         files: endpoints?.files || filesDir,
     };
-    return { ...config, endpoints: next };
+    return { ...config, filesDir, endpoints: next };
 }
 
 const logger$e = debug('seedSdk:ClientManager:initialize');
-/**
- * Whether a relative filesDir already names the .seed directory or a path inside
- * it ('.seed', '.seed/files', './.seed/files'). '.seed-alt/x' is not: it is
- * resolved under .seed like any other relative path.
- */
-function isUnderDotSeed(relativePath) {
-    const firstSegment = relativePath.split(/[\\/]+/).find((segment) => segment !== '' && segment !== '.');
-    return firstSegment === '.seed';
-}
 const platformClassesInit = fromCallback(({ sendBack, input: { context, event } }) => {
     logger$e('initialize from ClientManager');
     const { isInitialized } = context;
@@ -586,10 +575,6 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
         sendBack({ type: 'initialized' });
         return;
     }
-    // Validate synchronously before starting async operations
-    // This ensures errors are handled immediately, preventing unhandled rejections
-    const { config } = options;
-    const { endpoints } = config || {};
     // Track if the operation is cancelled
     let cancelled = false;
     // Create a promise that will handle validation errors immediately
@@ -601,21 +586,22 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
             return;
         }
         const { addresses } = options;
-        const config = normalizeSeedConfigEndpoints(options.config);
-        // Validate required endpoints - this should happen early in the initialization process.
-        // Node fills these from filesDir; browser callers still pass them.
-        if (!config?.endpoints || !config.endpoints.filePaths || !config.endpoints.files) {
-            throw new Error('Config must include endpoints with filePaths and files');
-        }
-        // Prefer the condition-resolved factory when available; fall back to explicit
-        // platform imports so source/vitest resolution stays reliable.
-        const { configurePlatform } = await import('./configurePlatform-D4aGjKNk.js');
+        const config = applySeedConfigDefaults(options.config);
+        if (!config) {
+            throw new Error('client.init requires a config');
+        }
+        const _mod_0 = await import('./configurePlatform-CVoh3JeR.js');
+        const _ns_0 = _mod_0.a;
+        const { configurePlatform } = _ns_0;
         if (isBrowser()) {
             const { createPlatformServices } = await import('./platform.browser.js');
             configurePlatform(createPlatformServices());
         }
         else if (isNode()) {
-            const { createPlatformServices } = await import('./platform.node.js');
+            // `#seed-node-platform` (package.json `imports`) maps to the browser platform under
+            // the `browser` condition, so browser bundles never contain the Node platform
+            // (libsql, node:fs). A relative import here would ship it to every browser app.
+            const { createPlatformServices } = await import('#seed-node-platform');
             configurePlatform(createPlatformServices());
         }
         else {
@@ -642,45 +628,15 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
         const resolvedGateway = await resolveSeedGatewayEndpoints(gatewayConfig);
         setResolvedSeedGatewayEndpoints(resolvedGateway);
         BaseArweaveClient.setHost(`${resolvedGateway.arweaveProtocol}://${resolvedGateway.arweaveHost}`);
-        // Note: Validation already happened above, but we have endpoints here for path normalization
-        // Normalize filesDir for Node.js environment
-        // In Node.js, filesDir should be resolved relative to .seed directory at project root
+        // filesDir falls back to endpoints.files (applySeedConfigDefaults fills both)
         let normalizedFilesDir = filesDir || endpoints?.files;
         // jsdom (and any env with both Node + window) is "browser" for SDK: PathResolver is OPFS/virtual.
         // Do not run real fs against those paths (e.g. mkdir '/.seed').
         if (isNode() && !isBrowser() && normalizedFilesDir) {
-            const path = (await import('node:path')).default;
-            const fs = (await import('node:fs')).default;
-            // Not created here: prepareDb creates filesDir (under .seed when it's relative), so an absolute
-            // filesDir works from a read-only working directory (e.g. a packaged Electron app's cwd `/`).
-            const dotSeedDir = BasePathResolver.getDotSeedDir();
-            // Check if filesDir is a browser OPFS-style path (absolute path starting with '/'
-            // that is a simple single-level path like '/app-files', not a real filesystem path)
-            // Browser OPFS paths are typically simple like '/app-files', '/files', etc.
-            const pathWithoutLeadingSlash = normalizedFilesDir.slice(1);
-            const isBrowserOpfsPath = path.isAbsolute(normalizedFilesDir) &&
-                normalizedFilesDir.startsWith('/') &&
-                pathWithoutLeadingSlash.length > 0 &&
-                !pathWithoutLeadingSlash.includes('/') && // Single directory name, no subdirectories
-                !fs.existsSync(normalizedFilesDir); // Doesn't exist on filesystem
-            if (isBrowserOpfsPath) {
-                // Convert browser OPFS path to .seed subdirectory
-                // e.g., '/app-files' -> '.seed/app-files'
-                const dirName = normalizedFilesDir.slice(1) || 'app-files';
-                normalizedFilesDir = path.join(dotSeedDir, dirName);
-            }
-            else if (!path.isAbsolute(normalizedFilesDir)) {
-                // If it's a relative path, check if it is already under .seed
-                if (isUnderDotSeed(normalizedFilesDir)) {
-                    // Already relative to project root, resolve it
-                    normalizedFilesDir = path.resolve(normalizedFilesDir);
-                }
-                else {
-                    // Resolve relative to .seed directory
-                    normalizedFilesDir = path.join(dotSeedDir, normalizedFilesDir);
-                }
-            }
-            // If it's an absolute path that exists or is a valid filesystem path, use it as-is
+            // Lives in the Node platform so browser bundles (and Next.js server builds, which
+            // alias it to the browser platform) carry no fs code with computed paths.
+            const { resolveFilesDir } = await import('#seed-node-platform');
+            normalizedFilesDir = resolveFilesDir(normalizedFilesDir);
         }
         const normalizedAddresses = normalizeAddressConfig(addresses);
         sendBack({ type: 'updateContext', context: {
@@ -754,7 +710,7 @@ const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
             const appDb = BaseDb.getAppDb();
             if (!appDb) {
                 // In test environments, continue anyway
-                if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
+                if (isTestOrSeedDev()) {
                     logger$d('[client/actors] [saveAppState] App DB not found, but continuing in test environment');
                     return;
                 }
@@ -776,7 +732,7 @@ const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
         catch (error) {
             logger$d('[client/actors] [saveAppState] Error saving app state:', error);
             // In test environments, continue anyway
-            if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
+            if (isTestOrSeedDev()) {
                 logger$d('[client/actors] [saveAppState] Continuing despite error in test environment');
                 return;
             }
@@ -794,7 +750,7 @@ const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
         .catch((error) => {
         logger$d('[client/actors] [saveAppState] Error in promise chain:', error);
         // In test environments, still send success to allow state machine to progress
-        if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
+        if (isTestOrSeedDev()) {
             logger$d('[client/actors] [saveAppState] Sending success despite error in test environment');
             sendBack({
                 type: 'saveAppStateSuccess',
@@ -1051,7 +1007,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
                 }
             }
             catch (error) {
-                if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
+                if (isTestOrSeedDev()) {
                     logger$a('[client/actors] [addModelsToDb] Warning: Could not fetch schemas from EAS (background):', error.message);
                 }
                 else {
@@ -1073,7 +1029,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         .catch((error) => {
         logger$a('[client/actors] [addModelsToDb] Error:', error);
         // In test environments, still send success to allow initialization to complete
-        if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
+        if (isTestOrSeedDev()) {
             logger$a('[client/actors] [addModelsToDb] Continuing despite error in test environment');
             sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_DB_SUCCESS });
         }
@@ -1238,7 +1194,7 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
             const appDb = BaseDb.getAppDb();
             if (!appDb) {
                 // In test environments, continue anyway
-                if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
+                if (isTestOrSeedDev()) {
                     logger$8('[internal/actors] [saveConfig] App DB not found, but continuing in test environment');
                     return;
                 }
@@ -1296,7 +1252,7 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
         catch (error) {
             logger$8('[internal/actors] [saveConfig] Error saving config:', error);
             // In test environments, continue anyway
-            if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
+            if (isTestOrSeedDev()) {
                 logger$8('[internal/actors] [saveConfig] Continuing despite error in test environment');
                 return;
             }
@@ -1312,7 +1268,7 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
         .catch((error) => {
         logger$8('[internal/actors] [saveConfig] Error in saveConfig promise chain:', error);
         // In test environments, still send success to allow state machine to progress
-        if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
+        if (isTestOrSeedDev()) {
             logger$8('[internal/actors] [saveConfig] Sending success despite error in test environment');
             sendBack({ type: ClientManagerEvents.SAVE_CONFIG_SUCCESS });
         }
@@ -2023,9 +1979,9 @@ function getRefValueType(prop) {
  * @returns Promise that resolves when properties are found, or rejects if not found after max retries
  */
 const verifyPropertiesPersisted = async (db, modelId, modelName, maxRetries = 10, retryDelay = 100) => {
-    const _mod_0 = await import('./BasePathResolver-CBTXCMFL.js');
-    const _ns_0 = _mod_0.bb;
-    const modelSchemaMod = _ns_0;
+    const _mod_1 = await import('./index-CrvIcVFJ.js');
+    const _ns_1 = _mod_1.bd;
+    const modelSchemaMod = _ns_1;
     const { properties: propertiesTable } = modelSchemaMod;
     const drizzleMod = await import('drizzle-orm');
     const { eq } = drizzleMod;
@@ -2246,17 +2202,11 @@ const transformImportToSchemaFile = (importData, version = 1) => {
 const parseJsonImportContent = (content) => {
     try {
         const data = JSON.parse(content);
-        // Determine the format and extract name
-        let schemaName;
-        // Check if it's a complete schema format (has $schema field)
-        if (data.$schema) {
-            // Complete schema format: name is in metadata.name
-            schemaName = data.metadata?.name;
-        }
-        else {
-            // Minimal format: name is at top level
-            schemaName = data.name;
-        }
+        // Complete schema format keeps the name in metadata.name, minimal format at the top level.
+        // A schema file without $schema (SchemaFileInput) still has metadata.name.
+        const schemaName = data.$schema
+            ? data.metadata?.name
+            : (data.name ?? data.metadata?.name);
         if (!schemaName) {
             throw new Error('Schema name is required (either at top level or in metadata.name)');
         }
@@ -2334,6 +2284,21 @@ const getSchemaFilePath = (workingDir, name, version, schemaFileId) => {
     const filename = `${schemaFileId}_${sanitizedName}_v${version}.json`;
     return path.join(workingDir, filename);
 };
+/** The complete schema stored at filePath, or undefined when it can't be read or isn't complete. */
+const readCompleteSchemaFile = async (filePath) => {
+    try {
+        const schema = JSON.parse(await BaseFileManager.readFileAsString(filePath));
+        if (!schema.$schema)
+            return undefined;
+        if (schema.models)
+            schema.models = normalizeSchemaModels(schema.models);
+        return schema;
+    }
+    catch (error) {
+        logger$6(`Could not read schema file ${filePath}:`, error);
+        return undefined;
+    }
+};
 /**
  * Import a JSON schema file and save it in the full schema file format
  * Also converts the JSON models to Model classes and adds them to the database
@@ -2375,6 +2340,9 @@ function warnOnEasNameCollisions(schemaFile) {
     return warnings;
 }
 async function importJsonSchema(importFilePathOrContents, version = 1) {
+    return importSchema(importFilePathOrContents, version, { replaceStoredFile: false });
+}
+async function importSchema(importFilePathOrContents, version, options) {
     // Determine if we have a file path or file contents
     let importData;
     let importFilePath;
@@ -2403,6 +2371,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
     }
     // Use original schema file if available, otherwise transform from import format
     let schemaFile;
+    let replacingStoredFile = false;
     if (originalSchemaFile) {
         schemaFile = originalSchemaFile;
         // Normalize models if provided as array (some tools output array format)
@@ -2416,9 +2385,9 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         // Check DB for existing schema by name+version (same as minimal path)
         const db = BaseDb.getAppDb();
         if (db) {
-            const _mod_1 = await import('./BasePathResolver-CBTXCMFL.js');
-            const _ns_1 = _mod_1.bd;
-            const schemaSchemaMod = _ns_1;
+            const _mod_2 = await import('./index-CrvIcVFJ.js');
+            const _ns_2 = _mod_2.bf;
+            const schemaSchemaMod = _ns_2;
             const { schemas: schemasTable } = schemaSchemaMod;
             const drizzleMod = await import('drizzle-orm');
             const { eq, and, desc } = drizzleMod;
@@ -2465,16 +2434,23 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
             schemaFile.id = await getDeterministicSchemaFileId(schemaFile);
             logger$6(`Generated deterministic schema ID for ${schemaFile.metadata.name}:`, schemaFile.id);
         }
-        // Before generating IDs, check if a file already exists with this schemaFileId
-        // This handles the case where the schema was already loaded via loadSchemaFromFile
+        // A file with this schemaFileId and version is reused only when its content matches. A pinned id
+        // (one the schema file sets) keeps the same path when the content changes.
         const workingDir = BaseFileManager.getWorkingDir();
-        BaseFileManager.getPathModule();
         const existingFilePath = getSchemaFilePath(workingDir, schemaFile.metadata.name, schemaFile.version, schemaFile.id);
-        const existingFileExists = await BaseFileManager.pathExists(existingFilePath);
-        if (existingFileExists) {
-            // File already exists with this schemaFileId - just load it instead of creating a new one
-            logger$6(`Schema file already exists with schemaFileId ${schemaFile.id}, loading it instead of creating new file`);
-            return await loadSchemaFromFile(existingFilePath);
+        if (await BaseFileManager.pathExists(existingFilePath)) {
+            const storedSchema = await readCompleteSchemaFile(existingFilePath);
+            if (storedSchema && compareSchemaContent(schemaFile, storedSchema)) {
+                logger$6(`Schema file already exists with schemaFileId ${schemaFile.id} and the same content, loading it`);
+                return await loadSchemaFromFile(existingFilePath);
+            }
+            if (!options.replaceStoredFile) {
+                throw new Error(`Schema ${schemaFile.metadata.name} v${schemaFile.version} already exists with different content ` +
+                    `(schema id ${schemaFile.id}). Bump the schema's version, or delete the existing file first.`);
+            }
+            console.warn(`[seed] schema ${schemaFile.metadata.name} v${schemaFile.version}: content changed but id ` +
+                `${schemaFile.id} and version did not; replacing the stored schema file. Bump "version" when the schema changes.`);
+            replacingStoredFile = true;
         }
         // Generate missing model and property IDs.
         // Use deterministic IDs (from schema content hash) so addModelsToDb finds existing
@@ -2501,9 +2477,9 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         // For minimal imports: check DB for existing schema before creating new file
         const db = BaseDb.getAppDb();
         if (db) {
-            const _mod_2 = await import('./BasePathResolver-CBTXCMFL.js');
-            const _ns_2 = _mod_2.bd;
-            const schemaSchemaMod = _ns_2;
+            const _mod_3 = await import('./index-CrvIcVFJ.js');
+            const _ns_3 = _mod_3.bf;
+            const schemaSchemaMod = _ns_3;
             const { schemas: schemasTable } = schemaSchemaMod;
             const drizzleMod = await import('drizzle-orm');
             const { eq, and, desc } = drizzleMod;
@@ -2670,8 +2646,10 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                 propertyFileIds.set(modelName, propIds);
             }
         }
-        // Convert JSON models to Model classes, passing modelFileIds and propertyFileIds so Model instances use correct IDs
-        const modelDefinitions = await createModelsFromJson(importDataForInternal, modelFileIds, propertyFileIds);
+        // Convert JSON models to Model classes, passing modelFileIds and propertyFileIds so Model instances use correct IDs.
+        // addModelsToDb below writes their rows; the models adopt them once it has run.
+        const rowsWritten = createRowsWrittenSignal();
+        const modelDefinitions = await createModelsFromJson(importDataForInternal, modelFileIds, propertyFileIds, rowsWritten.promise);
         logger$6('loadSchemaFromFile (internal) - modelDefinitions length:', Object.keys(modelDefinitions).length);
         // Convert schema file metadata to schema input for database
         const schemaInput = {
@@ -2682,9 +2660,9 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
             updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
         };
         // Use dynamic import to break circular dependency
-        const _mod_3 = await import('./BasePathResolver-CBTXCMFL.js');
-        const _ns_3 = _mod_3.bg;
-        const dbMod = _ns_3;
+        const _mod_4 = await import('./index-CrvIcVFJ.js');
+        const _ns_4 = _mod_4.bi;
+        const dbMod = _ns_4;
         const { addSchemaToDb, addModelsToDb } = dbMod;
         // Try to add schema and models to database if database is available
         try {
@@ -2704,13 +2682,13 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                     });
                     // Verify expected models are linked (single attempt - addModelsToDb already confirmed)
                     const expectedModelNames = Object.keys(schemaFile.models || {});
-                    const _mod_4 = await import('./BasePathResolver-CBTXCMFL.js');
-                    const _ns_4 = _mod_4.be;
-                    const modelSchemaSchemaMod = _ns_4;
+                    const _mod_5 = await import('./index-CrvIcVFJ.js');
+                    const _ns_5 = _mod_5.bg;
+                    const modelSchemaSchemaMod = _ns_5;
                     const { modelSchemas } = modelSchemaSchemaMod;
-                    const _mod_5 = await import('./BasePathResolver-CBTXCMFL.js');
-                    const _ns_5 = _mod_5.bb;
-                    const modelSchemaMod = _ns_5;
+                    const _mod_6 = await import('./index-CrvIcVFJ.js');
+                    const _ns_6 = _mod_6.bd;
+                    const modelSchemaMod = _ns_6;
                     const { models: modelsTable } = modelSchemaMod;
                     const drizzleMod = await import('drizzle-orm');
                     const { eq, and, isNull } = drizzleMod;
@@ -2800,6 +2778,9 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
             // Database not available - log warning but continue
             logger$6('Database not available, skipping database operations:', dbError instanceof Error ? dbError.message : String(dbError));
         }
+        finally {
+            rowsWritten.settle();
+        }
         // Models are now Model instances, no registration needed
         // They should be created via Model.create() and are accessible via Model static methods
         for (const [modelName] of Object.entries(modelDefinitions)) {
@@ -2819,7 +2800,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
     // Get the target file path using ID-based naming (preferred)
     const filePath = getSchemaFilePath(workingDir, schemaFile.metadata.name, version, schemaFile.id);
     // Check if schema already exists
-    const exists = await BaseFileManager.pathExists(filePath);
+    const exists = !replacingStoredFile && (await BaseFileManager.pathExists(filePath));
     if (exists) {
         // If we have a file path and the import file is the same as the target file,
         // and it's already a complete schema, just load it without writing
@@ -2907,15 +2888,16 @@ async function applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, prope
         createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
         updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
     };
-    const _mod_6 = await import('./BasePathResolver-CBTXCMFL.js');
-    const _ns_6 = _mod_6.bg;
-    const dbMod = _ns_6;
+    const _mod_7 = await import('./index-CrvIcVFJ.js');
+    const _ns_7 = _mod_7.bi;
+    const dbMod = _ns_7;
     const { addSchemaToDb, addModelsToDb } = dbMod;
     const db = BaseDb.getAppDb();
     if (!db) {
         throw new Error('Database not found');
     }
     warnOnInvalidNameMatch(schemaFile);
+    const droppedModelNames = await getModelsDroppedFromStoredSchema(db, schemaFile);
     const schemaData = JSON.stringify(schemaFile, null, 2);
     const schemaRecord = await addSchemaToDb(schemaInput, schemaFile.id, schemaData, false);
     if (Object.keys(modelDefinitions).length > 0) {
@@ -2927,11 +2909,66 @@ async function applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, prope
         });
         await new Promise(resolve => setTimeout(resolve, 200));
     }
+    if (droppedModelNames.length > 0 && schemaRecord.id) {
+        await unlinkModelsFromSchema(db, schemaRecord.id, droppedModelNames);
+    }
     return { schemaRecord };
 }
+/**
+ * Names of the models the stored published schema of this name has and schemaFile drops. A model
+ * whose id is still in schemaFile was renamed, not dropped. Returns none when the stored row is a
+ * draft (its edits aren't the app's to undo) or a newer version than schemaFile.
+ */
+async function getModelsDroppedFromStoredSchema(db, schemaFile) {
+    const _mod_8 = await import('./index-CrvIcVFJ.js');
+    const _ns_8 = _mod_8.bf;
+    const { schemas: schemasTable } = _ns_8;
+    const { eq } = await import('drizzle-orm');
+    const rows = await db
+        .select({ version: schemasTable.version, isDraft: schemasTable.isDraft, schemaData: schemasTable.schemaData })
+        .from(schemasTable)
+        .where(eq(schemasTable.name, schemaFile.metadata.name));
+    if (rows.length === 0 || rows.some((row) => row.isDraft))
+        return [];
+    const stored = rows.reduce((a, b) => (b.version > a.version ? b : a));
+    if (!stored.schemaData || stored.version > schemaFile.version)
+        return [];
+    let storedModels;
+    try {
+        storedModels = normalizeSchemaModels(JSON.parse(stored.schemaData).models ?? {});
+    }
+    catch {
+        return [];
+    }
+    const models = schemaFile.models ?? {};
+    const modelIds = new Set(Object.values(models).map((model) => model.id).filter(Boolean));
+    return Object.entries(storedModels)
+        .filter(([name, model]) => !(name in models) && !(model.id && modelIds.has(model.id)))
+        .map(([name]) => name);
+}
+/** Delete the model_schemas rows linking the named models to the schema. The models and their items stay. */
+async function unlinkModelsFromSchema(db, schemaId, modelNames) {
+    const _mod_9 = await import('./index-CrvIcVFJ.js');
+    const _ns_9 = _mod_9.bg;
+    const { modelSchemas } = _ns_9;
+    const _mod_10 = await import('./index-CrvIcVFJ.js');
+    const _ns_10 = _mod_10.bd;
+    const { models: modelsTable } = _ns_10;
+    const { and, eq, inArray } = await import('drizzle-orm');
+    const links = await db
+        .select({ id: modelSchemas.id })
+        .from(modelSchemas)
+        .innerJoin(modelsTable, eq(modelSchemas.modelId, modelsTable.id))
+        .where(and(eq(modelSchemas.schemaId, schemaId), inArray(modelsTable.name, modelNames)));
+    if (links.length === 0)
+        return;
+    await db.delete(modelSchemas).where(inArray(modelSchemas.id, links.map((link) => link.id)));
+    logger$6(`Unlinked models dropped from the schema (schema id ${schemaId}): ${modelNames.join(', ')}`);
+}
 /**
  * Sync a canonical schema from a file path or inlined object to the database.
- * Uses add/update semantics: no "already exists with different content" errors, no ID-based file copy.
+ * A stored schema file with the same id and version but different content is overwritten (with a
+ * warning) instead of reused, and models dropped from the schema are unlinked from it.
  * Called automatically at init when config.schema is provided.
  *
  * @param source - File path (string) or complete SchemaFileFormat object
@@ -2947,11 +2984,11 @@ async function syncSchemaFromSource(source) {
         const content = await BaseFileManager.readFileAsString(resolvedPath);
         const parsed = JSON.parse(content);
         const version = parsed?.version ?? 1;
-        await importJsonSchema({ contents: content }, version);
+        await importSchema({ contents: content }, version, { replaceStoredFile: true });
     }
     else {
         const version = source.version ?? 1;
-        await importJsonSchema({ contents: JSON.stringify(source) }, version);
+        await importSchema({ contents: JSON.stringify(source) }, version, { replaceStoredFile: true });
     }
 }
 /**
@@ -3060,8 +3097,10 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                 propertyFileIds.set(modelName, propIds);
             }
         }
-        // Convert JSON models to Model classes, passing modelFileIds and propertyFileIds so Model instances use correct IDs
-        const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds);
+        // Convert JSON models to Model classes, passing modelFileIds and propertyFileIds so Model instances use correct IDs.
+        // applySchemaToDb below writes their rows; the models adopt them once it has run.
+        const rowsWritten = createRowsWrittenSignal();
+        const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds, rowsWritten.promise);
         logger$6('loadSchemaFromFile - modelDefinitions length:', Object.keys(modelDefinitions).length);
         // Try to add schema and models to database if database is available
         try {
@@ -3074,15 +3113,15 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                     modelName,
                     jsonPropertiesToSchemaProperties(modelName, modelDef, propertyFileIds.get(modelName)),
                 ]));
-                const { schemaRecord } = await applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, propertyFileIds, propertyDefinitions);
+                const { schemaRecord } = await applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, propertyFileIds, propertyDefinitions).finally(rowsWritten.settle);
                 // Query the database to get model IDs that were just created
-                const _mod_7 = await import('./BasePathResolver-CBTXCMFL.js');
-                const _ns_7 = _mod_7.be;
-                const modelSchemaSchemaMod = _ns_7;
+                const _mod_11 = await import('./index-CrvIcVFJ.js');
+                const _ns_11 = _mod_11.bg;
+                const modelSchemaSchemaMod = _ns_11;
                 const { modelSchemas } = modelSchemaSchemaMod;
-                const _mod_8 = await import('./BasePathResolver-CBTXCMFL.js');
-                const _ns_8 = _mod_8.bb;
-                const modelSchemaMod = _ns_8;
+                const _mod_12 = await import('./index-CrvIcVFJ.js');
+                const _ns_12 = _mod_12.bd;
+                const modelSchemaMod = _ns_12;
                 const { models: modelsTable } = modelSchemaMod;
                 const drizzleMod = await import('drizzle-orm');
                 const { eq } = drizzleMod;
@@ -3146,9 +3185,9 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                 // After properties are created (file path), ensure schemaFile has the correct IDs from database
                 // Query the database to get the actual schemaFileId values that were used
                 // This ensures schemaData matches what's actually in the database
-                const _mod_9 = await import('./BasePathResolver-CBTXCMFL.js');
-                const _ns_9 = _mod_9.bb;
-                const modelSchemaMod2 = _ns_9;
+                const _mod_13 = await import('./index-CrvIcVFJ.js');
+                const _ns_13 = _mod_13.bd;
+                const modelSchemaMod2 = _ns_13;
                 const { properties: propertiesTable } = modelSchemaMod2;
                 let schemaFileUpdated = false;
                 for (const [modelName, modelFileId] of modelFileIds.entries()) {
@@ -3182,9 +3221,9 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                 // This is important even if nothing changed, to ensure consistency
                 const updatedSchemaData = JSON.stringify(schemaFile, null, 2);
                 // Update the schema record in the database with current schemaData
-                const _mod_10 = await import('./BasePathResolver-CBTXCMFL.js');
-                const _ns_10 = _mod_10.bd;
-                const schemaSchemaMod = _ns_10;
+                const _mod_14 = await import('./index-CrvIcVFJ.js');
+                const _ns_14 = _mod_14.bf;
+                const schemaSchemaMod = _ns_14;
                 const { schemas: schemasTable } = schemaSchemaMod;
                 await db
                     .update(schemasTable)
@@ -3203,6 +3242,9 @@ const loadSchemaFromFile = async (schemaFilePath) => {
             // Database not available - log warning but continue
             logger$6('Database not available, skipping database operations:', dbError instanceof Error ? dbError.message : String(dbError));
         }
+        finally {
+            rowsWritten.settle();
+        }
         // Models are now Model instances, no registration needed
         // They should be created via Model.create() and are accessible via Model static methods
         for (const [modelName] of Object.entries(modelDefinitions)) {
@@ -3284,6 +3326,18 @@ const jsonPropertiesToSchemaProperties = (modelName, modelDef, propertyFileIds)
     }
     return convertedProperties;
 };
+/**
+ * For callers of createModelsFromJson that write the models with addModelsToDb: pass `promise` as its
+ * persistedBy and call `settle` once addModelsToDb has run or failed (in a finally). The new models wait
+ * for it, then adopt the rows addModelsToDb wrote; any model it didn't write writes itself.
+ */
+const createRowsWrittenSignal = () => {
+    let settle;
+    const promise = new Promise((resolve) => {
+        settle = resolve;
+    });
+    return { promise, settle };
+};
 /**
  * Create a Model class from a JSON model definition
  * @param modelName - The name of the model
@@ -3292,10 +3346,11 @@ const jsonPropertiesToSchemaProperties = (modelName, modelDef, propertyFileIds)
  * @returns A Model class that can be used with the SDK
  */
 const createModelFromJson = async (modelName, modelDef, schemaName, modelFileId, // Optional modelFileId from JSON file
-propertyFileIds) => {
-    const _mod_11 = await import('./errors-CIrbsN_i.js');
-    const _ns_11 = _mod_11.h;
-    const modelMod = _ns_11;
+propertyFileIds, // Optional map of property names to their file IDs from the JSON file
+persistedBy) => {
+    const _mod_15 = await import('./errors-3tc6XkCB.js');
+    const _ns_15 = _mod_15.h;
+    const modelMod = _ns_15;
     const { Model } = modelMod;
     const convertedProperties = jsonPropertiesToSchemaProperties(modelName, modelDef, propertyFileIds);
     // Create Model instance with the definition
@@ -3312,6 +3367,7 @@ propertyFileIds) => {
         id: modelFileId, // Also pass as id for backward compatibility
         properties: convertedProperties,
         waitForReady: false,
+        persistedBy,
     });
     return modelInstance;
 };
@@ -3320,9 +3376,11 @@ propertyFileIds) => {
  * @param importData - The JSON import data
  * @param modelFileIds - Optional map of model names to their file IDs from the JSON file
  * @param propertyFileIds - Optional map of model names to maps of property names to their file IDs from the JSON file
+ * @param persistedBy - When the caller writes the models with addModelsToDb: a promise that settles once
+ *   that has run (see createRowsWrittenSignal). New models then adopt those rows instead of writing them too.
  * @returns ModelDefinitions object with Model classes
  */
-const createModelsFromJson = async (importData, modelFileIds, propertyFileIds) => {
+const createModelsFromJson = async (importData, modelFileIds, propertyFileIds, persistedBy) => {
     const modelDefinitions = {};
     const schemaName = importData.name;
     for (const [modelName, modelDef] of Object.entries(importData.models)) {
@@ -3335,7 +3393,7 @@ const createModelsFromJson = async (importData, modelFileIds, propertyFileIds) =
         }
         // Get propertyFileIds for this model if available
         const modelPropertyFileIds = propertyFileIds?.get(modelName);
-        const ModelClass = await createModelFromJson(modelName, modelDef, schemaName, finalModelFileId, modelPropertyFileIds);
+        const ModelClass = await createModelFromJson(modelName, modelDef, schemaName, finalModelFileId, modelPropertyFileIds, persistedBy);
         modelDefinitions[modelName] = ModelClass;
     }
     return modelDefinitions;
@@ -5650,5 +5708,5 @@ var ClientManager$1 = /*#__PURE__*/Object.freeze({
     getClient: getClient
 });
 
-export { requestEasSyncFromEventBus as A, requestEasSyncFromModelsInit as B, ClientManager as C, sendEasSyncClientRequest as D, EAS_CHAIN_ID_APP_STATE_KEY as E, setRetriesWhenOnlineEnabled as F, startEasSyncActor as G, unregisterSeedQueryLocalSource as H, INIT_CONFIG_CONFLICT_MESSAGE as I, createModelsFromJson as J, getLatestSchemaVersion as K, jsonPropertiesToSchemaProperties as L, schema as M, ClientManager$1 as N, SEEDPROTOCOL_Seed_Protocol_v1 as S, getContentHash as a, isVerbatimItemStorageDraftRow as b, convertVerbatimItemStorageRow as c, assertLocalDbChain as d, claimUnpublishedDrafts as e, createLocalQueryDataSource as f, getRefValueType as g, hardDeleteLocalSeedsByLocalIds as h, importJsonSchema as i, createSchema as j, easSyncActor as k, loadSchemaFromFile as l, getClient as m, getPublishedSeedRecord as n, getSchemaNameFromId as o, isSeedQueryLocalSourceRegistered as p, listCompleteSchemaFiles as q, readJsonImportFile as r, syncSchemaFromSource as s, transformImportToSchemaFile as t, loadAllSchemasFromDb as u, mergeEasSyncRequestIntents as v, waitForEasReadChain as w, readSchema as x, registerSeedQueryLocalSource as y, requestEasSyncFromAddressChange as z };
-//# sourceMappingURL=ClientManager-DRf4uuei.js.map
+export { requestEasSyncFromEventBus as A, requestEasSyncFromModelsInit as B, ClientManager as C, sendEasSyncClientRequest as D, EAS_CHAIN_ID_APP_STATE_KEY as E, setRetriesWhenOnlineEnabled as F, startEasSyncActor as G, unregisterSeedQueryLocalSource as H, INIT_CONFIG_CONFLICT_MESSAGE as I, createRowsWrittenSignal as J, createModelsFromJson as K, getLatestSchemaVersion as L, jsonPropertiesToSchemaProperties as M, schema as N, ClientManager$1 as O, SEEDPROTOCOL_Seed_Protocol_v1 as S, getContentHash as a, isVerbatimItemStorageDraftRow as b, convertVerbatimItemStorageRow as c, assertLocalDbChain as d, claimUnpublishedDrafts as e, createLocalQueryDataSource as f, getRefValueType as g, hardDeleteLocalSeedsByLocalIds as h, importJsonSchema as i, createSchema as j, easSyncActor as k, loadSchemaFromFile as l, getClient as m, getPublishedSeedRecord as n, getSchemaNameFromId as o, isSeedQueryLocalSourceRegistered as p, listCompleteSchemaFiles as q, readJsonImportFile as r, syncSchemaFromSource as s, transformImportToSchemaFile as t, loadAllSchemasFromDb as u, mergeEasSyncRequestIntents as v, waitForEasReadChain as w, readSchema as x, registerSeedQueryLocalSource as y, requestEasSyncFromAddressChange as z };
+//# sourceMappingURL=ClientManager-D6YA20jP.js.map