@seedprotocol/sdk 0.6.10 → 0.7.1

package/dist/ClientManager-DngaZdw6.js

@@ -0,0 +1,4763 @@
+import debug from 'debug';
+import { createActor, setup, assign, fromPromise, fromCallback, waitFor } from 'xstate';
+import { m as eventEmitter, C as normalizeAddressConfig, E as normalizeAddressList, S as loadModelsFromDbForSchema, O as addSchemaToDb, n as normalizeDataType, U as linkModelToSchema, s as normalizePublisher, V as getWatchedAddressesFromDb, W as getOwnedAddressesFromDb } from './db-Lw0KVZmc.js';
+import { u as MachineIds, W as ClientManagerEvents, C as ClientManagerState, X as resolvePublisherFromSeedRow, G as isLocalUnsealedDraft, I as Item } from './Item-ZUAmf943.js';
+import { B as BaseDb, e as easSyncProcesses, t as BasePathResolver, b as appState, a as BaseFileManager, j as models$1, i as modelUids, r as seeds, s as schemas, K as isInternalSchema, L as INTERNAL_SCHEMA_IDS, F as SEED_PROTOCOL_SCHEMA_NAME, g as modelSchemas, m as metadata$1, v as versions, h as htmlEmbeddedImageCoPublish, c as arweaveL1FinalizeJobs, q as publishProcesses, M as CLIENT_NOT_INITIALIZED } from './BasePathResolver-DRT09oVv.js';
+import { eq, inArray, and, isNotNull, ne, desc, countDistinct, or, isNull } from 'drizzle-orm';
+import { o as withDbTabLock, j as isLeaderTab, v as postTabMessage, x as onTabMessage, w as whenLeaderTab, y as listenForOtherTabsEvents, z as isNode, B as isBrowser, C as startTabCoordination, D as downloadAllFilesRequestHandler, E as downloadAllFilesBinaryRequestHandler, t as toSnakeCase, u as withSeedDbLock, p as parseAddressesPersistedPayload, e as emitAcrossTabs, A as ADDRESSES_PERSISTED_EVENT, L as LOCAL_COPIES_REMOVED_EVENT } from './tabEvents-C6NXS6Jl.js';
+import { seedGatewayConfigFromSeedConfig, setPreferredArweaveReadBaseUrls, resolveSeedGatewayEndpoints, setResolvedSeedGatewayEndpoints, BaseArweaveClient, ensureReadGatewaySelected, DEFAULT_ARWEAVE_HOST } from '@seedprotocol/arweave';
+import { configureEasReadChain, BaseQueryClient, BaseEasClient, GET_SCHEMAS, whenEasReadChainSettled, getEasReadChainId, DEFAULT_EAS_CHAIN_ID, isEasReadChainConfigured, isValidEasAttestationUid } from '@seedprotocol/eas';
+import 'pluralize';
+import { sha3_256 } from '@noble/hashes/sha3';
+import { bytesToHex, utf8ToBytes } from '@noble/hashes/utils';
+import { generateId } from './generateId-BopUwD8F.js';
+import { clearLocalQuerySource, registerLocalQuerySource, getSeed } from '@seedprotocol/query';
+import { startCase } from 'lodash-es';
+
+let writeTail = Promise.resolve();
+function enqueueEasSyncDbWrite(fn) {
+    const next = writeTail.then(fn);
+    writeTail = next.catch(() => { });
+    return next;
+}
+const MAX_ERROR_MESSAGE_LENGTH = 500;
+const MAX_ERROR_DETAILS_LENGTH = 2000;
+async function insertEasSyncProcessRow(params) {
+    return enqueueEasSyncDbWrite(async () => {
+        const db = BaseDb.getAppDb();
+        if (!db) {
+            throw new Error('[easSyncProcess] App DB not available');
+        }
+        const now = Date.now();
+        const [row] = await db
+            .insert(easSyncProcesses)
+            .values({
+            status: 'in_progress',
+            startedAt: now,
+            requestPayload: JSON.stringify(params.requestPayload),
+            persistedSnapshot: JSON.stringify(params.persistedSnapshot),
+            createdAt: now,
+            updatedAt: now,
+        })
+            .returning({ id: easSyncProcesses.id });
+        return row.id;
+    });
+}
+async function finalizeEasSyncProcessRow(id, params) {
+    return enqueueEasSyncDbWrite(async () => {
+        const db = BaseDb.getAppDb();
+        if (!db) {
+            return;
+        }
+        const now = Date.now();
+        await db
+            .update(easSyncProcesses)
+            .set({
+            status: params.status,
+            completedAt: now,
+            updatedAt: now,
+            errorMessage: params.errorMessage?.slice(0, MAX_ERROR_MESSAGE_LENGTH) ?? null,
+            errorDetails: params.errorDetails?.slice(0, MAX_ERROR_DETAILS_LENGTH) ?? null,
+            persistedSnapshot: JSON.stringify(params.persistedSnapshot),
+        })
+            .where(eq(easSyncProcesses.id, id));
+    });
+}
+
+/**
+ * Merge multiple EAS sync intents: full sync (no concrete address list) wins;
+ * otherwise union addresses (first-seen casing).
+ */
+function mergeEasSyncRequestIntents(parts) {
+    const norm = parts.filter((p) => p != null);
+    if (norm.length === 0) {
+        return {};
+    }
+    let full = false;
+    const addressMap = new Map();
+    for (const p of norm) {
+        if (!('addresses' in p) || p.addresses === undefined) {
+            full = true;
+            break;
+        }
+        for (const addr of p.addresses) {
+            const k = addr.toLowerCase();
+            if (!addressMap.has(k)) {
+                addressMap.set(k, addr);
+            }
+        }
+    }
+    if (full) {
+        return {};
+    }
+    if (addressMap.size === 0) {
+        return { addresses: [] };
+    }
+    return { addresses: [...addressMap.values()] };
+}
+
+const log = debug('seedSdk:events:easSyncManager');
+function toRunSyncArg(options) {
+    if (options &&
+        'addresses' in options &&
+        options.addresses !== undefined) {
+        return options;
+    }
+    return undefined;
+}
+const runEasSync = fromPromise(async ({ input, }) => {
+    const rowId = await insertEasSyncProcessRow({
+        requestPayload: input.requestPayload,
+        persistedSnapshot: input.runningSnapshot,
+    });
+    const { runSyncFromEas } = await import('./syncDbWithEas-BPap9Sru.js');
+    try {
+        // 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', () => runSyncFromEas(toRunSyncArg(input.options)), {
+            timeoutMs: Infinity,
+        });
+        await finalizeEasSyncProcessRow(rowId, {
+            status: 'completed',
+            persistedSnapshot: {
+                phase: 'completed',
+                correlationIds: input.requestPayload.correlationIds,
+            },
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const details = err instanceof Error && err.stack
+            ? err.stack.slice(0, 2000)
+            : undefined;
+        await finalizeEasSyncProcessRow(rowId, {
+            status: 'failed',
+            errorMessage: message,
+            errorDetails: details,
+            persistedSnapshot: {
+                phase: 'failed',
+                correlationIds: input.requestPayload.correlationIds,
+            },
+        });
+        throw err;
+    }
+});
+const initialContext = {
+    runOptions: {},
+    activeCorrelationIds: [],
+    activePrimarySource: 'event_bus',
+    pendingMergedOptions: undefined,
+    pendingCorrelationIds: [],
+    pendingPrimarySource: null,
+    lastFinishedCorrelationIds: null,
+    lastFinishedStatus: null,
+    lastFinishedError: null,
+};
+const easSyncMachine = setup({
+    types: {
+        context: {},
+        events: {},
+    },
+    actors: {
+        runEasSync,
+    },
+}).createMachine({
+    id: MachineIds.EAS_SYNC_MANAGER,
+    initial: 'idle',
+    context: initialContext,
+    states: {
+        idle: {
+            on: {
+                REQUEST: {
+                    target: 'running',
+                    actions: assign({
+                        runOptions: ({ event }) => event.options === undefined
+                            ? {}
+                            : mergeEasSyncRequestIntents([event.options]),
+                        activeCorrelationIds: ({ event }) => [event.correlationId],
+                        activePrimarySource: ({ event }) => event.source,
+                    }),
+                },
+            },
+        },
+        running: {
+            on: {
+                REQUEST: {
+                    actions: assign({
+                        pendingMergedOptions: ({ context, event }) => mergeEasSyncRequestIntents([
+                            context.runOptions,
+                            context.pendingMergedOptions,
+                            event.options === undefined ? {} : event.options,
+                        ].filter((x) => x != null)),
+                        pendingCorrelationIds: ({ context, event }) => [
+                            ...context.pendingCorrelationIds,
+                            event.correlationId,
+                        ],
+                        pendingPrimarySource: ({ context, event }) => context.pendingPrimarySource ?? event.source,
+                    }),
+                },
+            },
+            invoke: {
+                src: 'runEasSync',
+                input: ({ context }) => ({
+                    options: context.runOptions,
+                    requestPayload: {
+                        source: context.activePrimarySource,
+                        correlationIds: context.activeCorrelationIds,
+                        options: context.runOptions,
+                    },
+                    runningSnapshot: {
+                        phase: 'running',
+                        correlationIds: context.activeCorrelationIds,
+                    },
+                }),
+                onDone: {
+                    target: 'afterRun',
+                    actions: assign({
+                        lastFinishedCorrelationIds: ({ context }) => [
+                            ...context.activeCorrelationIds,
+                        ],
+                        lastFinishedStatus: () => 'success',
+                        lastFinishedError: () => null,
+                        activeCorrelationIds: () => [],
+                        runOptions: () => ({}),
+                    }),
+                },
+                onError: {
+                    target: 'afterRun',
+                    actions: [
+                        assign({
+                            lastFinishedCorrelationIds: ({ context }) => [
+                                ...context.activeCorrelationIds,
+                            ],
+                            lastFinishedStatus: () => 'failed',
+                            lastFinishedError: ({ event }) => {
+                                const e = event.error;
+                                if (e instanceof Error) {
+                                    return e.message;
+                                }
+                                return e != null ? String(e) : 'EAS sync failed';
+                            },
+                            activeCorrelationIds: () => [],
+                            runOptions: () => ({}),
+                        }),
+                        ({ event }) => {
+                            log('runEasSync error', event.error);
+                        },
+                    ],
+                },
+            },
+        },
+        afterRun: {
+            always: [
+                {
+                    guard: ({ context }) => context.pendingCorrelationIds.length > 0,
+                    target: 'running',
+                    actions: assign({
+                        runOptions: ({ context }) => mergeEasSyncRequestIntents([context.pendingMergedOptions]),
+                        activeCorrelationIds: ({ context }) => [
+                            ...context.pendingCorrelationIds,
+                        ],
+                        activePrimarySource: ({ context }) => context.pendingPrimarySource ?? 'event_bus',
+                        pendingMergedOptions: () => undefined,
+                        pendingCorrelationIds: () => [],
+                        pendingPrimarySource: () => null,
+                    }),
+                },
+                { target: 'idle' },
+            ],
+        },
+    },
+});
+const easSyncActor = createActor(easSyncMachine);
+let easSyncActorStarted = false;
+function startEasSyncActor() {
+    if (easSyncActorStarted) {
+        return;
+    }
+    easSyncActorStarted = true;
+    easSyncActor.start();
+}
+function newCorrelationId() {
+    const c = globalThis.crypto;
+    if (c?.randomUUID) {
+        return c.randomUUID();
+    }
+    return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+/** Requests deferred in this tab until it leads, by source; each runs once on takeover. */
+const deferredUntilLeader = new Set();
+/**
+ * Automatic syncs run in the leader tab only (docs/MULTI_TAB.md). A tab that skips one runs it if
+ * it later becomes leader, so closing the leader doesn't lose the catch-up sync.
+ */
+function runInLeaderTab(source, request) {
+    if (isLeaderTab()) {
+        request();
+        return;
+    }
+    log(`${source} sync skipped: another tab leads`);
+    if (deferredUntilLeader.has(source))
+        return;
+    deferredUntilLeader.add(source);
+    void whenLeaderTab().then(() => {
+        deferredUntilLeader.delete(source);
+        request();
+    });
+}
+let listeningToOtherTabs = false;
+/** The leader runs address-change syncs requested by other tabs. */
+function listenForEasSyncRequestsFromOtherTabs() {
+    if (listeningToOtherTabs)
+        return;
+    listeningToOtherTabs = true;
+    onTabMessage((message) => {
+        if (message.type === 'eas-sync-address-change' && isLeaderTab()) {
+            requestEasSyncFromAddressChange(message.addresses);
+        }
+    });
+}
+function requestEasSyncFromEventBus() {
+    runInLeaderTab('event_bus', sendEventBusRequest);
+}
+function sendEventBusRequest() {
+    startEasSyncActor();
+    easSyncActor.send({
+        type: 'REQUEST',
+        correlationId: newCorrelationId(),
+        source: 'event_bus',
+    });
+}
+function requestEasSyncFromAddressChange(addresses) {
+    if (!isLeaderTab()) {
+        // The leader syncs these addresses; its own address list may be stale.
+        postTabMessage({ type: 'eas-sync-address-change', addresses });
+        return;
+    }
+    startEasSyncActor();
+    easSyncActor.send({
+        type: 'REQUEST',
+        correlationId: newCorrelationId(),
+        options: { addresses },
+        source: 'address_change',
+    });
+}
+function requestEasSyncFromModelsInit() {
+    runInLeaderTab('models_init', sendModelsInitRequest);
+}
+function sendModelsInitRequest() {
+    startEasSyncActor();
+    easSyncActor.send({
+        type: 'REQUEST',
+        correlationId: newCorrelationId(),
+        source: 'models_init',
+    });
+}
+function sendEasSyncClientRequest(correlationId, options) {
+    startEasSyncActor();
+    easSyncActor.send({
+        type: 'REQUEST',
+        correlationId,
+        options,
+        source: 'client_api',
+    });
+}
+
+var easSyncManager = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    easSyncActor: easSyncActor,
+    easSyncMachine: easSyncMachine,
+    listenForEasSyncRequestsFromOtherTabs: listenForEasSyncRequestsFromOtherTabs,
+    requestEasSyncFromAddressChange: requestEasSyncFromAddressChange,
+    requestEasSyncFromEventBus: requestEasSyncFromEventBus,
+    requestEasSyncFromModelsInit: requestEasSyncFromModelsInit,
+    sendEasSyncClientRequest: sendEasSyncClientRequest,
+    startEasSyncActor: startEasSyncActor
+});
+
+const logger$b = debug('seedSdk:services:events');
+const handleServiceSaveState = (event) => {
+    const { state, serviceId } = event;
+    logger$b(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
+    // TODO: This is called from Node as well. Do we need it? If so, need to generalize this to all platforms.
+    // localStorage.setItem(`seed_sdk_service_${serviceId}`, JSON.stringify(state))
+};
+const setupServicesEventHandlers = () => {
+    eventEmitter.addListener('service.saveState.request', handleServiceSaveState);
+};
+
+const setupAllItemsEventHandlers = () => {
+    startEasSyncActor();
+    listenForEasSyncRequestsFromOtherTabs();
+    listenForOtherTabsEvents();
+    eventEmitter.addListener('syncDbWithEas', requestEasSyncFromEventBus);
+};
+// Note: getAreItemEventHandlersReady removed - was only used by useItemIsReady hook which has been removed
+
+// AllItems services have been removed - this handler is no longer needed
+// Service state persistence is now handled by entity instances directly
+const saveServiceHandler = async (event) => {
+    // AllItems services removed - this functionality is no longer needed
+    // Entity instances (Schema, Model, Item) manage their own state
+    console.warn('[saveServiceHandler] AllItems services removed - handler is a no-op');
+};
+
+const setupServiceHandlers = () => {
+    eventEmitter.addListener('service.save', saveServiceHandler);
+};
+
+/**
+ * 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.
+ */
+function normalizeSeedConfigEndpoints(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 next = {
+        filePaths: endpoints?.filePaths || filesDir,
+        files: endpoints?.files || filesDir,
+    };
+    return { ...config, endpoints: next };
+}
+
+const logger$a = debug('seedSdk:ClientManager:initialize');
+const platformClassesInit = fromCallback(({ sendBack, input: { context, event } }) => {
+    logger$a('initialize from ClientManager');
+    const { isInitialized } = context;
+    if (!event || !('options' in event)) {
+        throw new Error('Initialize event must include options');
+    }
+    const { options } = event;
+    if (isInitialized) {
+        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
+    // We use Promise.resolve().then() to ensure the catch handler is attached synchronously
+    // before the async function starts executing, preventing unhandled rejections
+    const initPromise = Promise.resolve().then(async () => {
+        // Check if cancelled before starting
+        if (cancelled) {
+            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-CZpjyuCo.js');
+        if (isBrowser()) {
+            const { createPlatformServices } = await import('./platform.browser.js');
+            configurePlatform(createPlatformServices());
+        }
+        else if (isNode()) {
+            const { createPlatformServices } = await import('./platform.node.js');
+            configurePlatform(createPlatformServices());
+        }
+        else {
+            throw new Error(`Unable to determine environment. isBrowser()=${isBrowser()}, isNode()=${isNode()}. Platform-specific implementations could not be loaded.`);
+        }
+        // Check if cancelled after async imports
+        if (cancelled) {
+            return;
+        }
+        const { models, endpoints, arweaveDomain, dbConfig, filesDir, schemaFile, schema, gateway, uploadApiBaseUrl, eas } = config;
+        if (eas) {
+            configureEasReadChain('sdk', { chainId: eas.chainId, indexerUrl: eas.indexerUrl });
+        }
+        const gatewayConfig = seedGatewayConfigFromSeedConfig({
+            ...config,
+            arweaveDomain,
+            uploadApiBaseUrl,
+            gateway,
+        });
+        // Only when configured, so a host app's own setPreferredArweaveReadBaseUrls() call survives init.
+        if (gatewayConfig.preferredReadBaseUrls) {
+            setPreferredArweaveReadBaseUrls(gatewayConfig.preferredReadBaseUrls);
+        }
+        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
+        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;
+            const dotSeedDir = BasePathResolver.getDotSeedDir();
+            // Ensure .seed directory exists
+            if (!fs.existsSync(dotSeedDir)) {
+                fs.mkdirSync(dotSeedDir, { recursive: true });
+            }
+            // 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 already starts with .seed
+                if (normalizedFilesDir.startsWith('.seed') || normalizedFilesDir.startsWith('.seed/')) {
+                    // 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
+        }
+        const normalizedAddresses = normalizeAddressConfig(addresses);
+        sendBack({ type: 'updateContext', context: {
+                models: models || {},
+                endpoints,
+                arweaveDomain: resolvedGateway.arweaveHost,
+                uploadApiBaseUrl: resolvedGateway.uploadApiBaseUrl,
+                gatewayTransport: resolvedGateway.mode,
+                gatewayHyperKey: resolvedGateway.gatewayHyperKey,
+                gatewaySidecarHost: gatewayConfig.hyper?.localSidecarHost,
+                gatewaySidecarPort: gatewayConfig.hyper?.localSidecarPort,
+                gatewayProxyBaseUrl: resolvedGateway.proxyBaseUrl ?? gatewayConfig.proxyBaseUrl,
+                addresses: normalizedAddresses.owned,
+                ownedAddresses: normalizedAddresses.owned,
+                watchedAddresses: normalizedAddresses.watched,
+                filesDir: normalizedFilesDir,
+                dbConfig,
+                schemaFile,
+                schema,
+                syncFromEasOnAddressChange: options.syncFromEasOnAddressChange ?? true,
+            } });
+        // Elect a leader tab for background work before anything requests it (docs/MULTI_TAB.md).
+        if (normalizedFilesDir) {
+            startTabCoordination({ filesDir: normalizedFilesDir, mode: options.multiTab });
+        }
+        if (resolvedGateway.activePath !== 'hyper-sidecar' && resolvedGateway.activePath !== 'http-proxy') {
+            void ensureReadGatewaySelected().catch(() => {
+                /* non-blocking warm-up for read gateway probe */
+            });
+        }
+        // Models are now Model instances, no registration needed
+        // They should be created via Model.create() and are accessible via Model static methods
+        setupAllItemsEventHandlers();
+        setupServicesEventHandlers();
+        setupServiceHandlers();
+    });
+    // Handle the promise immediately - this ensures rejections are caught synchronously
+    // The catch handler is attached synchronously before the async function executes
+    initPromise
+        .then(() => {
+        if (!cancelled) {
+            sendBack({ type: 'platformClassesReady' });
+        }
+    })
+        .catch((error) => {
+        // Only send error if not cancelled (prevents unhandled rejections after cleanup)
+        if (!cancelled) {
+            // Send error event using sendBack - this is the recommended XState pattern
+            // The parent state machine should handle the 'error' event
+            sendBack({
+                type: 'error',
+                error: error instanceof Error ? error : new Error(String(error))
+            });
+        }
+        // Explicitly handle the rejection to prevent unhandled promise rejection warnings
+        // The error has been sent via sendBack, so we've handled it
+    });
+    // Return cleanup function to cancel pending operations
+    return () => {
+        cancelled = true;
+        // The promise will still resolve/reject, but we won't send events if cancelled
+        // This prevents unhandled rejections after the callback is cleaned up
+    };
+});
+
+const logger$9 = debug('seedSdk:client:writeToDb');
+const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
+    const _saveAppState = async () => {
+        try {
+            const appDb = BaseDb.getAppDb();
+            if (!appDb) {
+                // In test environments, continue anyway
+                if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
+                    logger$9('[client/actors] [saveAppState] App DB not found, but continuing in test environment');
+                    return;
+                }
+                throw new Error('App DB not found');
+            }
+            const result = await appDb.insert(appState)
+                .values({
+                key: key,
+                value: JSON.stringify(value),
+            })
+                .onConflictDoUpdate({
+                target: appState.key,
+                set: {
+                    value: JSON.stringify(value),
+                },
+            });
+            logger$9('result', result);
+        }
+        catch (error) {
+            logger$9('[client/actors] [saveAppState] Error saving app state:', error);
+            // In test environments, continue anyway
+            if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
+                logger$9('[client/actors] [saveAppState] Continuing despite error in test environment');
+                return;
+            }
+            throw error;
+        }
+    };
+    _saveAppState()
+        .then(() => {
+        sendBack({
+            type: 'saveAppStateSuccess',
+            key,
+            value,
+        });
+    })
+        .catch((error) => {
+        logger$9('[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) {
+            logger$9('[client/actors] [saveAppState] Sending success despite error in test environment');
+            sendBack({
+                type: 'saveAppStateSuccess',
+                key,
+                value,
+            });
+        }
+        else {
+            sendBack({
+                type: 'saveAppStateError',
+                error: error instanceof Error ? error : new Error(String(error)),
+                key,
+                value,
+            });
+        }
+    });
+});
+
+let isInitialized = false;
+const fsInitHandler = async () => {
+    if (isInitialized) {
+        return;
+    }
+    isInitialized = true;
+};
+let areReady = false;
+const setupFsListeners = () => {
+    eventEmitter.addListener('fs.downloadAll.request', downloadAllFilesRequestHandler);
+    eventEmitter.addListener('fs.downloadAllBinary.request', downloadAllFilesBinaryRequestHandler);
+    eventEmitter.addListener('fs.init', fsInitHandler);
+    areReady = true;
+};
+const areFsListenersReady = () => {
+    return areReady;
+};
+
+debug('seedSdk:client:actors:fileSystemInit');
+const fileSystemInit = fromCallback(({ sendBack, input: { context }, }) => {
+    setupFsListeners();
+    if (!areFsListenersReady()) {
+        throw new Error('fs listeners not ready during init');
+    }
+    // Check for filesDir synchronously before starting async operation
+    // This ensures the error is thrown synchronously and caught by XState
+    const { filesDir } = context;
+    if (!filesDir) {
+        throw new Error('filesDir is required');
+    }
+    const _fileSystemInit = async () => {
+        await BaseFileManager.initializeFileSystem(filesDir);
+        eventEmitter.emit('fs.init');
+    };
+    _fileSystemInit()
+        .then(() => {
+        sendBack({ type: 'fileSystemReady' });
+    })
+        .catch((error) => {
+        // Send error event using sendBack - this is the recommended XState pattern
+        // The parent state machine should handle the 'ERROR' event
+        sendBack({
+            type: 'error',
+            error: error instanceof Error ? error : new Error(String(error))
+        });
+    });
+    // Return cleanup function
+    return () => {
+        // Cleanup if needed
+    };
+});
+
+const logger$8 = debug('seedSdk:client:actors:dbInit');
+const dbInit = fromCallback(({ sendBack, input: { context } }) => {
+    const _dbInit = async () => {
+        const { filesDir } = context;
+        if (!filesDir) {
+            throw new Error('filesDir is required');
+        }
+        // Prepare databases - this handles all initialization, migration, and file setup
+        await BaseDb.prepareDb(filesDir);
+        // Verify database is ready
+        const appDb = BaseDb.getAppDb();
+        if (!appDb) {
+            throw new Error('Database not available after preparation');
+        }
+        logger$8('[client/actors] [dbInit] Database prepared and ready');
+    };
+    _dbInit()
+        .then(() => {
+        sendBack({ type: ClientManagerEvents.DB_READY });
+    })
+        .catch((error) => {
+        logger$8('Error in dbInit:', error);
+        sendBack({
+            type: 'error',
+            error: error instanceof Error ? error : new Error(String(error))
+        });
+    });
+});
+
+const logger$7 = debug('seedSdk:client:actors:addModelsToStore');
+const addModelsToStore = fromCallback(({ sendBack, input: { context } }) => {
+    const _addModelsToStore = async () => {
+        let { models } = context;
+        if (!models) {
+            models = {};
+        }
+        // Internal models (Seed, Version, Metadata, Image) are now loaded via SEEDPROTOCOL_Seed_Protocol_v1.json schema
+        // They should already be in context.models from processSchemaFiles
+        const allModels = { ...models };
+        sendBack({ type: ClientManagerEvents.UPDATE_CONTEXT, context: { models: allModels } });
+        // Models are now Model instances, no registration needed
+        // They should be created via Model.create() and are accessible via Model static methods
+        for (const [key] of Object.entries(allModels)) {
+            logger$7('model available:', key);
+        }
+    };
+    _addModelsToStore()
+        .then(() => {
+        sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_STORE_SUCCESS });
+    })
+        .catch((error) => {
+        logger$7('[client/actors] [addModelsToStore] Error:', error);
+        sendBack({
+            type: 'error',
+            error: error instanceof Error ? error : new Error(String(error)),
+        });
+    });
+});
+
+const logger$6 = debug('seedSdk:client:actors:addModelsToDb');
+/**
+ * Returns every `models` row named in `modelNames`, inserting a null-schemaFileId stub for each name
+ * with no row yet (the schema import adopts stubs via findOrCreateModelRecord). Check-then-insert:
+ * another tab initializing at the same time would insert the same stubs, so tabs take turns
+ * (docs/MULTI_TAB.md).
+ */
+async function ensureModelStubs(appDb, modelNames, filesDir) {
+    return withSeedDbLock('init', filesDir, async () => {
+        // One query for all names. Model names are only unique per schema, so callers match each
+        // Model by its id (schemaFileId) first.
+        const rows = (await appDb
+            .select({ id: models$1.id, name: models$1.name, schemaFileId: models$1.schemaFileId })
+            .from(models$1)
+            .where(inArray(models$1.name, modelNames)));
+        const modelsToInsert = modelNames.filter((name) => !rows.some((m) => m.name === name));
+        if (modelsToInsert.length > 0) {
+            const newlyInserted = (await appDb
+                .insert(models$1)
+                .values(modelsToInsert.map((name) => ({ name })))
+                .returning({ id: models$1.id, name: models$1.name, schemaFileId: models$1.schemaFileId }));
+            rows.push(...newlyInserted);
+            for (const name of modelsToInsert) {
+                logger$6('[client/actors] [addModelsToDb] inserted model:', name);
+            }
+        }
+        return rows;
+    });
+}
+const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
+    const { models } = context;
+    const _addModelsToDb = async () => {
+        const appDb = BaseDb.getAppDb();
+        if (!appDb) {
+            throw new Error('Database not ready');
+        }
+        if (!models) {
+            return;
+        }
+        // Internal models (Seed, Version, Metadata) are now loaded via SEEDPROTOCOL_Seed_Protocol_v1.json schema
+        // They should already be in context.models from processSchemaFiles
+        const allModels = { ...models };
+        const modelNames = Object.keys(allModels);
+        if (modelNames.length === 0) {
+            return;
+        }
+        const schemaDefsByModelName = new Map();
+        // Model names are only unique per schema, so match each Model by its id (schemaFileId) first.
+        const existingModels = await ensureModelStubs(appDb, modelNames, context.filesDir);
+        const rowFor = (modelName) => {
+            const modelFileId = allModels[modelName]?.id;
+            const sameName = existingModels.filter((m) => m.name === modelName);
+            return ((modelFileId ? sameName.find((m) => m.schemaFileId === modelFileId) : undefined) ??
+                (sameName.length === 1 ? sameName[0] : undefined) ??
+                sameName.find((m) => !m.schemaFileId));
+        };
+        let hasModelsInDb = true;
+        for (const modelName of modelNames) {
+            const foundModel = rowFor(modelName);
+            if (!foundModel) {
+                logger$6('[client/actors] [addModelsToDb] Warning: Could not find or create model:', modelName);
+                hasModelsInDb = false;
+                continue;
+            }
+            // The EAS schema string depends only on the model name, so every same-name row shares its uid.
+            schemaDefsByModelName.set(modelName, {
+                dbIds: existingModels.filter((m) => m.name === modelName).map((m) => m.id),
+                schemaDef: `bytes32 ${toSnakeCase(modelName)}`,
+            });
+        }
+        // If we have no models to process, still send success (empty models is valid)
+        if (schemaDefsByModelName.size === 0) {
+            logger$6('[client/actors] [addModelsToDb] No models to process, but continuing');
+            sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_DB_SUCCESS });
+            return;
+        }
+        const schemaDefs = Array.from(schemaDefsByModelName.values()).map(({ schemaDef }) => schemaDef);
+        // Fetch schemas from EAS in background - do not block init. EAS can be slow (10s+);
+        // modelUids will be populated async and EAS sync orchestrator runs when done.
+        const fetchEasAndPopulateModelUids = async () => {
+            try {
+                const queryClient = BaseQueryClient.getQueryClient();
+                const easClient = BaseEasClient.getEasClient();
+                const queryPromise = queryClient.fetchQuery({
+                    queryKey: [`getSchemasVersion`, [...schemaDefs].sort()],
+                    queryFn: async () => easClient.request(GET_SCHEMAS, {
+                        where: {
+                            schema: {
+                                in: schemaDefs,
+                            },
+                        },
+                    }),
+                });
+                const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('EAS query timeout after 10 seconds')), 10000));
+                const { schemas } = await Promise.race([queryPromise, timeoutPromise]);
+                if (schemas && schemas.length > 0) {
+                    const db = BaseDb.getAppDb();
+                    if (db) {
+                        for (const schema of schemas) {
+                            const modelIds = Array.from(schemaDefsByModelName.values()).find(({ schemaDef }) => schemaDef === schema.schema)?.dbIds ?? [];
+                            for (const modelId of modelIds) {
+                                await db
+                                    .insert(modelUids)
+                                    .values({
+                                    modelId,
+                                    uid: schema.id,
+                                })
+                                    .onConflictDoNothing();
+                            }
+                        }
+                    }
+                    const { requestEasSyncFromModelsInit } = await Promise.resolve().then(function () { return easSyncManager; });
+                    requestEasSyncFromModelsInit();
+                }
+                else {
+                    logger$6('[client/actors] [addModelsToDb] No schemas found from EAS, but continuing');
+                }
+            }
+            catch (error) {
+                if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
+                    logger$6('[client/actors] [addModelsToDb] Warning: Could not fetch schemas from EAS (background):', error.message);
+                }
+                else {
+                    logger$6('[client/actors] [addModelsToDb] Error fetching schemas (background):', error.message);
+                }
+            }
+        };
+        fetchEasAndPopulateModelUids();
+        return hasModelsInDb;
+    };
+    _addModelsToDb()
+        .then(() => {
+        sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_DB_SUCCESS });
+    })
+        .catch((error) => {
+        logger$6('[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) {
+            logger$6('[client/actors] [addModelsToDb] Continuing despite error in test environment');
+            sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_DB_SUCCESS });
+        }
+        else {
+            sendBack({
+                type: 'error',
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
+        }
+    });
+    return () => { };
+});
+
+const logger$5 = debug('seedSdk:helpers:localDbChain');
+/** appState key recording which EAS chain the local database holds attestations from. */
+const EAS_CHAIN_ID_APP_STATE_KEY = 'easChainId';
+/**
+ * Databases written before the chain was recorded only ever held Optimism Sepolia data
+ * (the only chain the SDK supported then).
+ */
+const LEGACY_CHAIN_ID = DEFAULT_EAS_CHAIN_ID;
+async function readRecordedChainId(appDb) {
+    const rows = await appDb
+        .select({ value: appState.value })
+        .from(appState)
+        .where(eq(appState.key, EAS_CHAIN_ID_APP_STATE_KEY))
+        .limit(1);
+    const parsed = Number(rows[0]?.value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+async function recordChainId(appDb, chainId) {
+    const value = String(chainId);
+    await appDb
+        .insert(appState)
+        .values({ key: EAS_CHAIN_ID_APP_STATE_KEY, value })
+        .onConflictDoUpdate({ target: appState.key, set: { value } });
+}
+async function hasOnChainData(appDb) {
+    const rows = await appDb
+        .select({ uid: seeds.uid })
+        .from(seeds)
+        .where(and(isNotNull(seeds.uid), ne(seeds.uid, '')))
+        .limit(1);
+    return rows.length > 0;
+}
+/**
+ * Chain the local DB holds data from: the recorded one, or Optimism Sepolia for an unrecorded
+ * DB that already has attestations. Records the legacy value so later checks are cheap.
+ */
+async function resolveLocalDbChainId(appDb) {
+    const recorded = await readRecordedChainId(appDb);
+    if (recorded !== undefined)
+        return recorded;
+    if (await hasOnChainData(appDb)) {
+        await recordChainId(appDb, LEGACY_CHAIN_ID);
+        return LEGACY_CHAIN_ID;
+    }
+    return undefined;
+}
+/** How long EAS sync waits for `initPublish` to set the chain before using the current one. */
+const EAS_CHAIN_SETTLE_TIMEOUT_MS = 30000;
+/**
+ * Wait until the read chain is known before syncing. Only waits when `@seedprotocol/publish`
+ * is loaded but `initPublish` has not run, and no chain is configured or recorded locally.
+ */
+async function waitForEasReadChain(timeoutMs = EAS_CHAIN_SETTLE_TIMEOUT_MS) {
+    if (await whenEasReadChainSettled(timeoutMs))
+        return;
+    console.warn(`[Seed Protocol] EAS sync waited ${Math.round(timeoutMs / 1000)}s for initPublish to set the chain and is continuing on chain ${getEasReadChainId()}. Set SeedConfig.eas.chainId to skip the wait.`);
+}
+/**
+ * Called at SDK init once the DB is ready. Registers the DB's chain with the EAS read side so
+ * reads start on that chain even before publish is initialized, and throws when SeedConfig.eas
+ * or PublishConfig.chain names a different chain. An empty DB is recorded only when a chain
+ * is configured explicitly; otherwise the first sync or publish records it.
+ */
+async function loadLocalDbChain() {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb)
+        return;
+    const localChainId = await resolveLocalDbChainId(appDb);
+    if (localChainId !== undefined) {
+        configureEasReadChain('localDb', { chainId: localChainId });
+        logger$5('local DB holds chain %d', localChainId);
+        return;
+    }
+    if (isEasReadChainConfigured()) {
+        const chainId = getEasReadChainId();
+        await recordChainId(appDb, chainId);
+        configureEasReadChain('localDb', { chainId });
+    }
+}
+/**
+ * Call before writing chain data to the local DB (EAS sync, publish, revoke). Records the
+ * current chain on an empty DB; throws when the DB holds data from a different chain.
+ */
+async function assertLocalDbChain() {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb)
+        return;
+    const chainId = getEasReadChainId();
+    const localChainId = await resolveLocalDbChainId(appDb);
+    if (localChainId === undefined) {
+        await recordChainId(appDb, chainId);
+    }
+    // Throws with a remediation message when the local chain differs from the configured one.
+    configureEasReadChain('localDb', { chainId: localChainId ?? chainId });
+}
+
+const logger$4 = debug('seedSdk:client:actors:saveConfig');
+/**
+ * Saves the addresses passed to init. Hosts pass `addresses: []` before a wallet connects. In the
+ * first (leader) tab that clears stored addresses, as it always has, so drafts made before the
+ * wallet reconnects stay editable. A tab opened while another is running (`keepStoredWhenEmpty`)
+ * keeps them instead: they're the other tab's connected wallet, which EAS sync, downloads and
+ * publishing read. See docs/MULTI_TAB.md.
+ */
+async function persistInitAddresses(appDb, { addresses, ownedAddresses, watchedAddresses }, { keepStoredWhenEmpty }) {
+    const owned = normalizeAddressList(ownedAddresses ?? addresses ?? []);
+    const watched = normalizeAddressList(watchedAddresses ?? []);
+    if (owned.length === 0 && watched.length === 0 && keepStoredWhenEmpty)
+        return;
+    const value = JSON.stringify({ owned, watched });
+    await appDb
+        .insert(appState)
+        .values({ key: 'addresses', value })
+        .onConflictDoUpdate({ target: appState.key, set: { value } });
+}
+const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
+    logger$4('saveConfig starting');
+    const { endpoints, addresses, ownedAddresses, watchedAddresses, arweaveDomain, uploadApiBaseUrl, gatewayTransport, gatewayHyperKey, gatewaySidecarHost, gatewaySidecarPort, gatewayProxyBaseUrl, } = context;
+    // Validate endpoints - required for proper initialization
+    // If endpoints are missing or invalid, initialization should fail
+    if (!endpoints || !endpoints.filePaths || !endpoints.files) {
+        const error = new Error('saveConfig called with invalid endpoints: endpoints must include both filePaths and files');
+        logger$4('[internal/actors] [saveConfig] Invalid endpoints:', { endpoints });
+        throw error;
+    }
+    const _saveConfig = async () => {
+        try {
+            const appDb = BaseDb.getAppDb();
+            if (!appDb) {
+                // In test environments, continue anyway
+                if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
+                    logger$4('[internal/actors] [saveConfig] App DB not found, but continuing in test environment');
+                    return;
+                }
+                throw new Error('App DB not found');
+            }
+            const endpointsValueString = JSON.stringify(endpoints);
+            // TODO: Figure out how to define on conflict with multiple rows added
+            await appDb
+                .insert(appState)
+                .values({
+                key: 'endpoints',
+                value: endpointsValueString,
+            })
+                .onConflictDoUpdate({
+                target: appState.key,
+                set: {
+                    value: endpointsValueString,
+                },
+            });
+            await persistInitAddresses(appDb, { addresses, ownedAddresses, watchedAddresses }, { keepStoredWhenEmpty: !isLeaderTab() });
+            await appDb
+                .insert(appState)
+                .values({
+                key: 'arweaveDomain',
+                value: arweaveDomain || DEFAULT_ARWEAVE_HOST,
+            })
+                .onConflictDoUpdate({
+                target: appState.key,
+                set: {
+                    value: arweaveDomain || DEFAULT_ARWEAVE_HOST,
+                },
+            });
+            const persistKey = async (key, value) => {
+                if (value == null || value === '')
+                    return;
+                await appDb
+                    .insert(appState)
+                    .values({ key, value })
+                    .onConflictDoUpdate({
+                    target: appState.key,
+                    set: { value },
+                });
+            };
+            await persistKey('uploadApiBaseUrl', uploadApiBaseUrl);
+            await persistKey('gatewayTransport', gatewayTransport);
+            await persistKey('gatewayHyperKey', gatewayHyperKey);
+            await persistKey('gatewaySidecarHost', gatewaySidecarHost);
+            if (gatewaySidecarPort != null) {
+                await persistKey('gatewaySidecarPort', String(gatewaySidecarPort));
+            }
+            await persistKey('gatewayProxyBaseUrl', gatewayProxyBaseUrl);
+            // Throws when the DB holds attestations from a different chain than the one configured.
+            await loadLocalDbChain();
+        }
+        catch (error) {
+            logger$4('[internal/actors] [saveConfig] Error saving config:', error);
+            // In test environments, continue anyway
+            if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
+                logger$4('[internal/actors] [saveConfig] Continuing despite error in test environment');
+                return;
+            }
+            throw error;
+        }
+    };
+    // Init writes run one tab at a time (docs/MULTI_TAB.md).
+    withSeedDbLock('init', context.filesDir, _saveConfig)
+        .then(() => {
+        logger$4('[internal/actors] [saveConfig] saveConfig success');
+        return sendBack({ type: ClientManagerEvents.SAVE_CONFIG_SUCCESS });
+    })
+        .catch((error) => {
+        logger$4('[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) {
+            logger$4('[internal/actors] [saveConfig] Sending success despite error in test environment');
+            sendBack({ type: ClientManagerEvents.SAVE_CONFIG_SUCCESS });
+        }
+        else {
+            sendBack({
+                type: 'error',
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
+        }
+    });
+    return () => { };
+});
+
+const logger$3 = debug('seedSdk:helpers:schema');
+/**
+ * Sanitize a schema name to be filesystem-safe
+ * Replaces all special characters (except alphanumeric, hyphens, underscores) with underscores
+ * Converts spaces to underscores
+ * Removes leading/trailing underscores
+ *
+ * @param name - Schema name to sanitize
+ * @returns Sanitized name safe for use in filenames
+ */
+const sanitizeSchemaName$1 = (name) => {
+    return name
+        .replace(/[^a-zA-Z0-9\s_-]/g, '_') // Replace special chars (except spaces, hyphens, underscores) with underscore
+        .replace(/\s+/g, '_') // Convert spaces to underscores
+        .replace(/^_+|_+$/g, '') // Remove leading/trailing underscores
+        .replace(/_+/g, '_'); // Collapse multiple underscores to single
+};
+/**
+ * Generate filename for a schema
+ * Format: {schemaFileId}_{schemaName}_v{version}.json
+ *
+ * The ID-first format ensures all files for a schema group together when sorted alphabetically.
+ *
+ * @param name - Schema name
+ * @param version - Schema version
+ * @param schemaFileId - Schema file ID (required)
+ */
+const getSchemaFilename = (name, version, schemaFileId) => {
+    const sanitizedName = sanitizeSchemaName$1(name);
+    return `${schemaFileId}_${sanitizedName}_v${version}.json`;
+};
+/**
+ * Get the full file path for a schema
+ * Format: {schemaFileId}_{schemaName}_v{version}.json
+ *
+ * The ID-first format ensures all files for a schema group together when sorted alphabetically.
+ *
+ * @param name - Schema name
+ * @param version - Schema version
+ * @param schemaFileId - Schema file ID (required)
+ */
+const getSchemaFilePath$1 = (name, version, schemaFileId) => {
+    const path = BaseFileManager.getPathModule();
+    const filename = getSchemaFilename(name, version, schemaFileId);
+    const workingDir = BaseFileManager.getWorkingDir();
+    return path.join(workingDir, filename);
+};
+/**
+ * Create a new schema file
+ * @param schema - The schema object to save
+ * @param schemaFileId - Schema file ID (required)
+ * @throws Error if schema already exists or if workingDir is invalid
+ */
+const createSchema = async (schema, schemaFileId) => {
+    if (!schema.name || !schema.version) {
+        throw new Error('Schema must have a name and version');
+    }
+    const filePath = getSchemaFilePath$1(schema.name, schema.version, schemaFileId);
+    // Check if schema already exists
+    const exists = await BaseFileManager.pathExists(filePath);
+    if (exists) {
+        throw new Error(`Schema ${schema.name} v${schema.version} already exists`);
+    }
+    // Ensure working directory exists
+    const workingDir = BaseFileManager.getWorkingDir();
+    await BaseFileManager.createDirIfNotExists(workingDir);
+    // Write schema to file
+    const content = JSON.stringify(schema, null, 2);
+    await BaseFileManager.saveFile(filePath, content);
+};
+/**
+ * Read a schema file by name and version
+ * @param name - The name of the schema
+ * @param version - The version of the schema
+ * @param schemaFileId - Schema file ID (required)
+ * @returns The schema object, or null if not found
+ */
+const readSchema = async (name, version, schemaFileId) => {
+    const filePath = getSchemaFilePath$1(name, version, schemaFileId);
+    const exists = await BaseFileManager.pathExists(filePath);
+    if (!exists) {
+        return null;
+    }
+    try {
+        const content = await BaseFileManager.readFileAsString(filePath);
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to read schema ${name} v${version}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+/**
+ * Update an existing schema file
+ * @param schema - The updated schema object (must have same name and version as existing)
+ * @param schemaFileId - Schema file ID (required)
+ * @throws Error if schema doesn't exist
+ */
+async function updateSchema(schema, schemaFileId) {
+    if (!schema.name || !schema.version) {
+        throw new Error('Schema must have a name and version');
+    }
+    const filePath = getSchemaFilePath$1(schema.name, schema.version, schemaFileId);
+    // Check if schema exists
+    const exists = await BaseFileManager.pathExists(filePath);
+    if (!exists) {
+        throw new Error(`Schema ${schema.name} v${schema.version} does not exist`);
+    }
+    // Write updated schema to file
+    const content = JSON.stringify(schema, null, 2);
+    await BaseFileManager.saveFile(filePath, content);
+}
+/**
+ * Delete a schema file
+ * @param name - The name of the schema
+ * @param version - The version of the schema
+ * @param schemaFileId - Schema file ID (required)
+ * @throws Error if schema doesn't exist
+ */
+async function deleteSchema(name, version, schemaFileId) {
+    const filePath = getSchemaFilePath$1(name, version, schemaFileId);
+    // Check if schema exists
+    const exists = await BaseFileManager.pathExists(filePath);
+    if (!exists) {
+        throw new Error(`Schema ${name} v${version} does not exist`);
+    }
+    // Delete the file
+    const fs = await BaseFileManager.getFs();
+    BaseFileManager.getPathModule();
+    try {
+        await fs.promises.unlink(filePath);
+    }
+    catch (error) {
+        throw new Error(`Failed to delete schema ${name} v${version}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * List all schema files in the working directory
+ * Only returns files that are NOT already complete schema files (i.e., files without $schema field)
+ * This allows processing of minimal import files while skipping already-processed schema files
+ * @returns Array of objects containing name, version, and file path for each schema
+ */
+async function listSchemaFiles() {
+    const fs = await BaseFileManager.getFs();
+    const path = BaseFileManager.getPathModule();
+    // Check if working directory exists
+    const workingDir = BaseFileManager.getWorkingDir();
+    try {
+        const files = await fs.promises.readdir(workingDir);
+        const schemas = [];
+        for (const file of files) {
+            // Match filename pattern: {name}-v{version}.json
+            const match = file.match(/^(.+)-v(\d+)\.json$/);
+            if (match) {
+                const [, name, versionStr] = match;
+                const version = parseInt(versionStr, 10);
+                if (!isNaN(version)) {
+                    const filePath = path.join(workingDir, file);
+                    // Check if this file is already a complete schema file (has $schema field)
+                    // If it is, skip it since it's already been processed
+                    try {
+                        const content = await BaseFileManager.readFileAsString(filePath);
+                        const data = JSON.parse(content);
+                        // Skip files that already have $schema (complete schema format)
+                        // These are already processed and don't need to be imported again
+                        if (data.$schema) {
+                            continue;
+                        }
+                    }
+                    catch (error) {
+                        // If we can't read/parse the file, skip it
+                        continue;
+                    }
+                    schemas.push({
+                        name,
+                        version,
+                        filePath,
+                    });
+                }
+            }
+        }
+        return schemas;
+    }
+    catch (error) {
+        throw new Error(`Failed to list schemas: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function listCompleteSchemaFiles() {
+    const fs = await BaseFileManager.getFs();
+    const path = BaseFileManager.getPathModule();
+    // Check if working directory exists
+    const workingDir = BaseFileManager.getWorkingDir();
+    try {
+        // Check if directory exists before trying to read it
+        const dirExists = await BaseFileManager.pathExists(workingDir);
+        if (!dirExists) {
+            // Directory doesn't exist yet - return empty array (not an error condition)
+            logger$3(`Working directory does not exist yet: ${workingDir}, returning empty schema list`);
+            return [];
+        }
+        const files = await fs.promises.readdir(workingDir);
+        const schemas = [];
+        for (const file of files) {
+            // Match filename pattern: {schemaFileId}_{schemaName}_v{version}.json
+            const match = file.match(/^(.+)_(.+)_v(\d+)\.json$/);
+            if (match) {
+                const [, schemaFileId, schemaName, versionStr] = match;
+                const version = parseInt(versionStr, 10);
+                if (!isNaN(version)) {
+                    const filePath = path.join(workingDir, file);
+                    // Check if this file is a complete schema file (has $schema field)
+                    try {
+                        const content = await BaseFileManager.readFileAsString(filePath);
+                        const data = JSON.parse(content);
+                        // Only include files that have $schema (complete schema format)
+                        if (data.$schema && data.metadata?.name) {
+                            // CRITICAL: Use schemaFileId from filename (source of truth), not from JSON content
+                            // The filename pattern is {schemaFileId}_{schemaName}_v{version}.json
+                            // The JSON content's id might be out of sync, but the filename tells us what file actually exists
+                            schemas.push({
+                                name: data.metadata.name,
+                                version: data.version || version,
+                                filePath,
+                                schemaFileId: schemaFileId, // Use from filename, not data.id
+                            });
+                        }
+                    }
+                    catch (error) {
+                        // If we can't read/parse the file, skip it
+                        continue;
+                    }
+                }
+            }
+        }
+        return schemas;
+    }
+    catch (error) {
+        throw new Error(`Failed to list complete schemas: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Find a schema by name (returns the latest version if multiple versions exist)
+ * @param name - The name of the schema
+ * @returns The schema with the highest version, or null if not found
+ */
+async function findSchemaByName(name) {
+    const schemas = await listCompleteSchemaFiles();
+    const matchingSchemas = schemas.filter((s) => s.name === name);
+    if (matchingSchemas.length === 0) {
+        return null;
+    }
+    // Find the schema with the highest version
+    const latest = matchingSchemas.reduce((prev, current) => current.version > prev.version ? current : prev);
+    if (!latest.schemaFileId) {
+        throw new Error(`Schema ${latest.name} v${latest.version} is missing schemaFileId`);
+    }
+    return readSchema(latest.name, latest.version, latest.schemaFileId);
+}
+/**
+ * Get the latest version number for a schema by name
+ * Only considers complete schema files (with $schema field)
+ * @param name - The name of the schema
+ * @returns The latest version number, or 0 if no schema found
+ */
+async function getLatestSchemaVersion(name) {
+    const completeSchemas = await listCompleteSchemaFiles();
+    const matchingSchemas = completeSchemas.filter((s) => s.name === name);
+    if (matchingSchemas.length === 0) {
+        return 0;
+    }
+    // Find the schema with the highest version
+    const latest = matchingSchemas.reduce((prev, current) => current.version > prev.version ? current : prev);
+    return latest.version;
+}
+/**
+ * Get only the latest version of each schema
+ * @returns Array of objects containing name, version, and file path for the latest version of each schema
+ */
+async function listLatestSchemaFiles() {
+    const completeSchemas = await listCompleteSchemaFiles();
+    // Group by schema name and keep only the latest version of each
+    const schemaMap = new Map();
+    for (const schema of completeSchemas) {
+        const existing = schemaMap.get(schema.name);
+        if (!existing || schema.version > existing.version) {
+            schemaMap.set(schema.name, schema);
+        }
+    }
+    return Array.from(schemaMap.values());
+}
+/**
+ * Filter an array of schemas to only include the latest version for each schema name
+ * Works with any object that has a name (via metadata.name or name property) and a version property
+ * @param schemas - Array of schema objects
+ * @returns Array containing only the latest version of each schema
+ */
+function filterLatestSchemas(schemas) {
+    // Group by schema name and keep only the latest version of each
+    const schemaMap = new Map();
+    for (const schema of schemas) {
+        const schemaName = schema.metadata?.name || schema.name;
+        if (!schemaName) {
+            continue; // Skip schemas without a name
+        }
+        const existing = schemaMap.get(schemaName);
+        if (!existing || schema.version > existing.version) {
+            schemaMap.set(schemaName, schema);
+        }
+    }
+    return Array.from(schemaMap.values());
+}
+async function loadAllSchemasFromDb() {
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        throw new Error('Database not found');
+    }
+    const result = [];
+    // STEP 1: Query all schemas from database
+    const dbSchemas = await db
+        .select()
+        .from(schemas)
+        .orderBy(schemas.name, desc(schemas.version));
+    const processedSchemaNames = new Set();
+    // List the schema files once. listCompleteSchemaFiles reads and parses every file in the working
+    // dir, so listing per schema made this O(files x schemas).
+    let completeSchemaFiles;
+    const getCompleteSchemaFiles = async () => {
+        if (!completeSchemaFiles) {
+            try {
+                completeSchemaFiles = await listCompleteSchemaFiles();
+            }
+            catch (error) {
+                // If we can't list schema files (e.g., directory doesn't exist yet), continue without file-based loading
+                logger$3(`Error listing complete schema files (continuing with DB data): ${error instanceof Error ? error.message : String(error)}`);
+                completeSchemaFiles = [];
+            }
+        }
+        return completeSchemaFiles;
+    };
+    // STEP 2: Process each database schema
+    for (const dbSchema of dbSchemas) {
+        const schemaName = dbSchema.name;
+        // Skip if we've already processed a newer version of this schema
+        if (processedSchemaNames.has(schemaName)) {
+            continue;
+        }
+        // If it's a draft, load from schemaData
+        if (dbSchema.isDraft === true && dbSchema.schemaData) {
+            try {
+                let schemaFile = JSON.parse(dbSchema.schemaData);
+                // Merge models from DB only when schemaData is incomplete. When schemaData has models (e.g. init),
+                // skip the expensive loadModelsFromDbForSchema - it can return 1000s of orphaned model_schemas rows
+                // and cause init to hang. The merge is for drafts where schemaData may be missing models.
+                const schemaModelCount = Object.keys(schemaFile.models || {}).length;
+                let mergedModels = { ...(schemaFile.models || {}) };
+                if (dbSchema.id && schemaModelCount === 0) {
+                    const dbModels = await loadModelsFromDbForSchema(dbSchema.id);
+                    if (Object.keys(dbModels).length > 0) {
+                        mergedModels = { ...mergedModels, ...dbModels };
+                        for (const [modelName, dbModel] of Object.entries(dbModels)) {
+                            if (mergedModels[modelName]) {
+                                mergedModels[modelName] = {
+                                    ...mergedModels[modelName],
+                                    properties: {
+                                        ...mergedModels[modelName].properties,
+                                        ...dbModel.properties,
+                                    },
+                                };
+                            }
+                        }
+                    }
+                }
+                schemaFile = {
+                    ...schemaFile,
+                    models: mergedModels,
+                };
+                result.push({
+                    schema: schemaFile,
+                    isDraft: true,
+                    source: 'db',
+                    schemaRecordId: dbSchema.id || undefined,
+                });
+                processedSchemaNames.add(schemaName);
+                continue;
+            }
+            catch (error) {
+                logger$3(`Error parsing schemaData for ${schemaName}:`, error);
+                // Fall through to file-based loading
+            }
+        }
+        // If it's not a draft and has schemaFileId, try to load from file
+        if (dbSchema.isDraft === false && dbSchema.schemaFileId) {
+            const completeSchemas = await getCompleteSchemaFiles();
+            const matchingSchemas = completeSchemas.filter((s) => s.name === schemaName);
+            if (matchingSchemas.length > 0) {
+                // Find the schema with the highest version
+                const latest = matchingSchemas.reduce((prev, current) => current.version > prev.version ? current : prev);
+                try {
+                    // Read the file directly to get SchemaFileFormat
+                    const content = await BaseFileManager.readFileAsString(latest.filePath);
+                    const schemaFile = JSON.parse(content);
+                    // Check if file is newer than DB record
+                    const fileUpdatedAt = new Date(schemaFile.metadata.updatedAt).getTime();
+                    const dbUpdatedAt = dbSchema.updatedAt || 0;
+                    const dbMatchesFile = schemaFile.id === dbSchema.schemaFileId &&
+                        schemaFile.version === dbSchema.version &&
+                        fileUpdatedAt <= dbUpdatedAt;
+                    // If file is newer, update DB with file content
+                    if (fileUpdatedAt > dbUpdatedAt && schemaFile.id === dbSchema.schemaFileId) {
+                        await addSchemaToDb({
+                            name: schemaName,
+                            version: schemaFile.version,
+                            createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
+                            updatedAt: fileUpdatedAt,
+                        }, schemaFile.id, JSON.stringify(schemaFile, null, 2), false);
+                    }
+                    result.push({
+                        schema: schemaFile,
+                        isDraft: false,
+                        source: 'db+file',
+                        schemaRecordId: dbSchema.id || undefined,
+                        filePath: latest.filePath,
+                        dbMatchesFile,
+                    });
+                    processedSchemaNames.add(schemaName);
+                    continue;
+                }
+                catch (error) {
+                    logger$3(`Error loading schema file for ${schemaName}:`, error);
+                    // Fall through to try loading from schemaData if available
+                }
+            }
+            // If file doesn't exist but we have schemaData, use that
+            if (dbSchema.schemaData) {
+                try {
+                    let schemaFile = JSON.parse(dbSchema.schemaData);
+                    // CRITICAL: Merge models from database (model_schemas join table) with models from schemaData
+                    // This ensures models added to the database are included even if they're not in schemaData
+                    // Build merged models without mutating schemaFile (read-only approach)
+                    const schemaModelCount = Object.keys(schemaFile.models || {}).length;
+                    let mergedModels = { ...(schemaFile.models || {}) };
+                    if (dbSchema.id && schemaModelCount === 0) {
+                        const dbModels = await loadModelsFromDbForSchema(dbSchema.id);
+                        if (Object.keys(dbModels).length > 0) {
+                            mergedModels = { ...mergedModels, ...dbModels };
+                            for (const [modelName, dbModel] of Object.entries(dbModels)) {
+                                if (mergedModels[modelName]) {
+                                    mergedModels[modelName] = {
+                                        ...mergedModels[modelName],
+                                        properties: {
+                                            ...mergedModels[modelName].properties,
+                                            ...dbModel.properties,
+                                        },
+                                    };
+                                }
+                            }
+                        }
+                    }
+                    schemaFile = {
+                        ...schemaFile,
+                        models: mergedModels,
+                    };
+                    result.push({
+                        schema: schemaFile,
+                        isDraft: false,
+                        source: 'db',
+                        schemaRecordId: dbSchema.id || undefined,
+                    });
+                    processedSchemaNames.add(schemaName);
+                    continue;
+                }
+                catch (error) {
+                    logger$3(`Error parsing schemaData for ${schemaName}:`, error);
+                }
+            }
+        }
+    }
+    // STEP 3: Find schema files not yet in database (for migration/backward compatibility)
+    const completeSchemas = await getCompleteSchemaFiles();
+    for (const schemaFileInfo of completeSchemas) {
+        // Only process if not already in result
+        if (!processedSchemaNames.has(schemaFileInfo.name)) {
+            if (isInternalSchema(schemaFileInfo.name, schemaFileInfo.schemaFileId)) {
+                logger$3(`STEP 3: skipping internal schema file: ${schemaFileInfo.filePath}`);
+                continue;
+            }
+            try {
+                logger$3(`STEP 3: processing schema file: ${schemaFileInfo.name} from ${schemaFileInfo.filePath}`);
+                const content = await BaseFileManager.readFileAsString(schemaFileInfo.filePath);
+                const schemaFile = JSON.parse(content);
+                // Import this schema to database (mark as non-draft since it's in a file)
+                const schemaRecord = await addSchemaToDb({
+                    name: schemaFile.metadata.name,
+                    version: schemaFile.version,
+                    createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
+                    updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
+                }, schemaFile.id, JSON.stringify(schemaFile, null, 2), false);
+                result.push({
+                    schema: schemaFile,
+                    isDraft: false,
+                    source: 'file',
+                    schemaRecordId: schemaRecord.id || undefined,
+                    filePath: schemaFileInfo.filePath,
+                });
+                processedSchemaNames.add(schemaFileInfo.name);
+            }
+            catch (error) {
+                logger$3(`Error loading schema file ${schemaFileInfo.filePath}:`, error);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Migration helper: Migrate existing file-based schemas to the database
+ * This function should be called once to migrate existing schema files to the new database-first approach
+ * All existing schemas will be marked as published (isDraft = false) since they already exist in files
+ * @returns Number of schemas migrated
+ */
+async function migrateFileSchemasToDb() {
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        throw new Error('Database not found');
+    }
+    logger$3('Starting migration of file-based schemas to database');
+    // Get all complete schema files
+    const completeSchemas = await listCompleteSchemaFiles();
+    let migratedCount = 0;
+    for (const schemaFileInfo of completeSchemas) {
+        try {
+            // Read the schema file
+            const content = await BaseFileManager.readFileAsString(schemaFileInfo.filePath);
+            const schemaFile = JSON.parse(content);
+            if (!schemaFile.$schema || !schemaFile.metadata?.name) {
+                logger$3(`Skipping invalid schema file: ${schemaFileInfo.filePath}`);
+                continue;
+            }
+            const schemaName = schemaFile.metadata.name;
+            // Check if schema already exists in database
+            const existingSchemas = await db
+                .select()
+                .from(schemas)
+                .where(eq(schemas.name, schemaName))
+                .limit(1);
+            // Only migrate if it doesn't exist or if existing record doesn't have schemaFileId
+            if (existingSchemas.length === 0 || !existingSchemas[0].schemaFileId) {
+                // Add schema to database as published (isDraft = false)
+                await addSchemaToDb({
+                    name: schemaName,
+                    version: schemaFile.version,
+                    createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
+                    updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
+                }, schemaFile.id, // schemaFileId
+                JSON.stringify(schemaFile, null, 2), // schemaData
+                false);
+                migratedCount++;
+                logger$3(`Migrated schema: ${schemaName} v${schemaFile.version}`);
+            }
+            else {
+                logger$3(`Schema ${schemaName} already exists in database, skipping`);
+            }
+        }
+        catch (error) {
+            logger$3(`Error migrating schema file ${schemaFileInfo.filePath}:`, error);
+        }
+    }
+    logger$3(`Migration complete: ${migratedCount} schemas migrated`);
+    return migratedCount;
+}
+/**
+ * Extract the schema name from a schemaId string
+ * @param schemaId - Schema ID in the format `${schemaName}-${schemaVersion}`
+ * @returns The schema name, or null if the format is invalid
+ */
+function getSchemaNameFromId(schemaId) {
+    if (!schemaId) {
+        return null;
+    }
+    const lastDashIndex = schemaId.lastIndexOf('-');
+    if (lastDashIndex === -1 || lastDashIndex === 0 || lastDashIndex === schemaId.length - 1) {
+        return null;
+    }
+    return schemaId.substring(0, lastDashIndex);
+}
+
+var schema = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    createSchema: createSchema,
+    deleteSchema: deleteSchema,
+    filterLatestSchemas: filterLatestSchemas,
+    findSchemaByName: findSchemaByName,
+    getLatestSchemaVersion: getLatestSchemaVersion,
+    getSchemaNameFromId: getSchemaNameFromId,
+    listCompleteSchemaFiles: listCompleteSchemaFiles,
+    listLatestSchemaFiles: listLatestSchemaFiles,
+    listSchemaFiles: listSchemaFiles,
+    loadAllSchemasFromDb: loadAllSchemasFromDb,
+    migrateFileSchemasToDb: migrateFileSchemasToDb,
+    readSchema: readSchema,
+    updateSchema: updateSchema
+});
+
+function toBytes(data) {
+    if (typeof data === 'string')
+        return utf8ToBytes(data);
+    if (data instanceof Uint8Array)
+        return data;
+    return new Uint8Array(data);
+}
+const getContentHash = async (data) => {
+    return bytesToHex(sha3_256(toBytes(data)));
+};
+/**
+ * Returns a function that maps `suffix` to `getDeterministicId(prefix + suffix)`, hashing `prefix` only
+ * once. Use it when deriving many ids from one long shared prefix (e.g. a whole serialized schema).
+ */
+const getDeterministicIdsWithPrefix = (prefix) => {
+    const prefixHash = sha3_256.create().update(utf8ToBytes(prefix));
+    return (suffix) => bytesToHex(prefixHash.clone().update(utf8ToBytes(suffix)).digest()).slice(0, 10);
+};
+
+const logger$2 = debug('seedSdk:imports:json');
+/**
+ * Get refValueType from a property object with case-insensitive key lookup.
+ * Handles refValueType, refvaluetype, ref_value_type, elementType, and legacy items.type / items.Type.
+ * Also handles items as string (e.g. items: "Relation").
+ */
+/**
+ * Normalize schema file format: convert models/properties arrays to objects if needed.
+ * Some tools output models/properties as arrays; we need object format keyed by name or index.
+ */
+function normalizeSchemaModels(models) {
+    if (!models || typeof models !== 'object')
+        return {};
+    if (!Array.isArray(models))
+        return models;
+    const result = {};
+    for (let i = 0; i < models.length; i++) {
+        const m = models[i];
+        const key = m?.name ?? m?.id ?? String(i);
+        const props = m?.properties;
+        let properties = {};
+        if (props && typeof props === 'object') {
+            if (Array.isArray(props)) {
+                for (let j = 0; j < props.length; j++) {
+                    const p = props[j];
+                    const pKey = p?.name ?? p?.id ?? String(j);
+                    properties[pKey] = p;
+                }
+            }
+            else {
+                properties = props;
+            }
+        }
+        result[key] = { ...m, properties };
+    }
+    return result;
+}
+/**
+ * Get refValueType from a property object with case-insensitive key lookup.
+ */
+function getRefValueType(prop) {
+    const refValueType = prop.refValueType ??
+        prop.refvaluetype ??
+        prop.RefValueType ??
+        prop.REFVALUETYPE ??
+        prop.ref_value_type;
+    if (refValueType != null && String(refValueType).trim() !== '') {
+        return String(refValueType);
+    }
+    const elementType = prop.elementType ?? prop.element_type;
+    if (elementType != null && String(elementType).trim() !== '') {
+        return String(elementType);
+    }
+    const items = prop.items;
+    if (items != null) {
+        if (typeof items === 'string' && items.trim() !== '') {
+            return items.trim();
+        }
+        if (items && typeof items === 'object') {
+            const itemsType = items.type ?? items.Type ?? items.TYPE;
+            if (itemsType != null && String(itemsType).trim() !== '') {
+                return String(itemsType);
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Verify that properties are persisted to the database for a given model
+ * This is important in browser environments where database writes may not be immediately visible
+ * @param db - Database instance
+ * @param modelId - Database ID of the model
+ * @param modelName - Name of the model (for logging)
+ * @param maxRetries - Maximum number of retry attempts
+ * @param retryDelay - Delay between retries in milliseconds
+ * @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-DRT09oVv.js');
+    const _ns_0 = _mod_0.N;
+    const modelSchemaMod = _ns_0;
+    const { properties: propertiesTable } = modelSchemaMod;
+    const drizzleMod = await import('drizzle-orm');
+    const { eq } = drizzleMod;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        const props = await db
+            .select()
+            .from(propertiesTable)
+            .where(eq(propertiesTable.modelId, modelId))
+            .limit(1);
+        if (props.length > 0) {
+            logger$2(`Verified properties exist for model "${modelName}" (modelId: ${modelId}) after ${attempt + 1} attempt(s)`);
+            return;
+        }
+        if (attempt < maxRetries - 1) {
+            logger$2(`Properties not yet visible for model "${modelName}" (modelId: ${modelId}), retrying in ${retryDelay}ms (attempt ${attempt + 1}/${maxRetries})`);
+            await new Promise(resolve => setTimeout(resolve, retryDelay));
+        }
+    }
+    throw new Error(`Properties not found for model "${modelName}" (modelId: ${modelId}) after ${maxRetries} attempts. This may indicate a database write issue in the browser environment.`);
+};
+/**
+ * Compare two schema files structurally, ignoring metadata timestamps
+ * This is used to determine if an existing schema file matches the schema being imported
+ * @param schema1 - First schema to compare
+ * @param schema2 - Second schema to compare
+ * @returns true if schemas are structurally equivalent, false otherwise
+ */
+function compareSchemasStructurally(schema1, schema2) {
+    // Compare basic fields
+    if (schema1.$schema !== schema2.$schema)
+        return false;
+    if (schema1.version !== schema2.version)
+        return false;
+    if (schema1.id !== schema2.id)
+        return false;
+    // Compare metadata (ignoring timestamps)
+    if (schema1.metadata?.name !== schema2.metadata?.name)
+        return false;
+    // Compare models structure
+    const models1 = schema1.models || {};
+    const models2 = schema2.models || {};
+    const modelNames1 = Object.keys(models1).sort();
+    const modelNames2 = Object.keys(models2).sort();
+    if (modelNames1.length !== modelNames2.length)
+        return false;
+    if (!modelNames1.every((name, i) => name === modelNames2[i]))
+        return false;
+    // Compare each model's structure
+    for (const modelName of modelNames1) {
+        const model1 = models1[modelName];
+        const model2 = models2[modelName];
+        // Compare model IDs if both have them
+        if (model1.id !== model2.id)
+            return false;
+        // Compare properties
+        const props1 = model1.properties || {};
+        const props2 = model2.properties || {};
+        const propNames1 = Object.keys(props1).sort();
+        const propNames2 = Object.keys(props2).sort();
+        if (propNames1.length !== propNames2.length)
+            return false;
+        if (!propNames1.every((name, i) => name === propNames2[i]))
+            return false;
+        // Compare each property's structure
+        for (const propName of propNames1) {
+            const prop1 = props1[propName];
+            const prop2 = props2[propName];
+            // Compare property IDs if both have them
+            if (prop1.id !== prop2.id)
+                return false;
+            // Compare property types
+            if (prop1.type !== prop2.type)
+                return false;
+            // Compare other relevant fields (ref, refValueType for List, etc.)
+            if (prop1.ref !== prop2.ref)
+                return false;
+            const refVal1 = prop1.refValueType ?? prop1.items?.type;
+            const refVal2 = prop2.refValueType ?? prop2.items?.type;
+            if (refVal1 !== refVal2)
+                return false;
+            const model1 = prop1.ref ?? prop1.items?.model;
+            const model2 = prop2.ref ?? prop2.items?.model;
+            if (model1 !== model2)
+                return false;
+        }
+    }
+    // Compare enums
+    const enums1 = schema1.enums || {};
+    const enums2 = schema2.enums || {};
+    const enumNames1 = Object.keys(enums1).sort();
+    const enumNames2 = Object.keys(enums2).sort();
+    if (enumNames1.length !== enumNames2.length)
+        return false;
+    if (!enumNames1.every((name, i) => name === enumNames2[i]))
+        return false;
+    // Note: We don't compare migrations as they're historical records
+    // and may differ even for the same schema structure
+    return true;
+}
+/**
+ * Create a canonical JSON string for schema comparison (ignores IDs and timestamps).
+ * Used to detect if schema content has changed via string comparison of schemaData.
+ */
+function getSchemaContentForComparison(schema) {
+    const normalized = {
+        name: schema.metadata?.name,
+        version: schema.version,
+        models: {},
+        enums: schema.enums || {},
+    };
+    for (const modelName of Object.keys(schema.models || {}).sort()) {
+        const model = schema.models[modelName];
+        const props = {};
+        for (const propName of Object.keys(model.properties || {}).sort()) {
+            const prop = model.properties[propName];
+            const items = prop.items;
+            props[propName] = {
+                type: prop.type ?? prop.dataType,
+                ref: prop.ref ?? prop.refModelName,
+                refValueType: prop.refValueType ?? items?.type,
+                model: prop.model ?? items?.model,
+                storage: prop.storage,
+            };
+        }
+        normalized.models[modelName] = {
+            description: model.description,
+            properties: props,
+        };
+    }
+    return JSON.stringify(normalized);
+}
+/**
+ * Compare two schemas by structure (ignoring IDs and timestamps).
+ * Returns true if schema content is equivalent.
+ */
+function compareSchemaContent(schema1, schema2) {
+    return getSchemaContentForComparison(schema1) === getSchemaContentForComparison(schema2);
+}
+/**
+ * Generate a deterministic schemaFileId from schema content.
+ * Same schema content always produces the same id, preventing duplicate schema files
+ * when processSchemaFiles runs multiple times (e.g. React StrictMode, app restarts).
+ */
+async function getDeterministicSchemaFileId(schemaFile) {
+    const content = getSchemaContentForComparison(schemaFile);
+    const hash = await getContentHash(content);
+    return hash.slice(0, 10);
+}
+/**
+ * Transform import JSON format to full schema file format
+ * @param importData - The JSON import data
+ * @param version - The version number for the schema (defaults to 1)
+ * @returns The transformed schema file format
+ */
+const transformImportToSchemaFile = (importData, version = 1) => {
+    const now = new Date().toISOString();
+    const schemaId = generateId();
+    // Generate IDs for models and properties
+    const modelsWithIds = {};
+    for (const [modelName, modelDef] of Object.entries(importData.models)) {
+        const modelId = generateId();
+        const propertiesWithIds = {};
+        for (const [propertyName, propertyDef] of Object.entries(modelDef.properties)) {
+            const propertyId = generateId();
+            const prop = propertyDef;
+            const isList = (prop.type ?? prop.dataType) === 'List';
+            let normalized = { ...prop, id: propertyId };
+            // Normalize List: convert legacy items to refValueType/ref (case-insensitive)
+            const existingRefValueType = getRefValueType(prop);
+            if (isList && existingRefValueType) {
+                normalized = { ...normalized, refValueType: normalizeDataType(existingRefValueType) };
+                const items = prop.items;
+                if (items?.model && !normalized.ref)
+                    normalized.ref = items.model;
+            }
+            propertiesWithIds[propertyName] = normalized;
+        }
+        modelsWithIds[modelName] = {
+            ...modelDef,
+            id: modelId,
+            properties: propertiesWithIds,
+        };
+    }
+    return {
+        $schema: 'https://seedprotocol.org/schemas/data-model/v1',
+        version,
+        id: schemaId,
+        metadata: {
+            name: importData.name,
+            createdAt: now,
+            updatedAt: now,
+        },
+        models: modelsWithIds,
+        enums: {},
+        migrations: [
+            {
+                version,
+                timestamp: now,
+                description: 'Initial schema',
+                changes: [],
+            },
+        ],
+    };
+};
+/**
+ * Parse JSON import content (string) into JsonImportSchema format
+ * Supports two formats:
+ * 1. Minimal format: { name: string, models: {...} }
+ * 2. Complete schema format: { $schema: string, metadata: { name: string }, models: {...}, ... }
+ * @param content - The JSON content as a string
+ * @returns The parsed JSON import data normalized to JsonImportSchema format
+ * @throws Error if content cannot be parsed
+ */
+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;
+        }
+        if (!schemaName) {
+            throw new Error('Schema name is required (either at top level or in metadata.name)');
+        }
+        // Return normalized JsonImportSchema format
+        const models = normalizeSchemaModels(data.models);
+        return {
+            name: schemaName,
+            models,
+        };
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON content: ${error.message}`);
+        }
+        throw new Error(`Failed to parse JSON import content: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+/**
+ * Read and parse a JSON import file
+ * Supports two formats:
+ * 1. Minimal format: { name: string, models: {...} }
+ * 2. Complete schema format: { $schema: string, metadata: { name: string }, models: {...}, ... }
+ * @param filePath - Path to the JSON import file
+ * @returns The parsed JSON import data normalized to JsonImportSchema format
+ * @throws Error if file cannot be read or parsed
+ */
+const readJsonImportFile = async (filePath) => {
+    try {
+        const workingDir = BaseFileManager.getWorkingDir();
+        let internalFilePath = filePath;
+        if (!filePath.startsWith(workingDir)) {
+            internalFilePath = `${workingDir}/${filePath}`;
+        }
+        const content = await BaseFileManager.readFileAsString(internalFilePath);
+        return parseJsonImportContent(content);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON in file ${filePath}: ${error.message}`);
+        }
+        throw new Error(`Failed to read JSON import file ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+/**
+ * Sanitize a schema name to be filesystem-safe
+ * Replaces all special characters (except alphanumeric, hyphens, underscores) with underscores
+ * Converts spaces to underscores
+ * Removes leading/trailing underscores
+ *
+ * @param name - Schema name to sanitize
+ * @returns Sanitized name safe for use in filenames
+ */
+const sanitizeSchemaName = (name) => {
+    return name
+        .replace(/[^a-zA-Z0-9\s_-]/g, '_') // Replace special chars (except spaces, hyphens, underscores) with underscore
+        .replace(/\s+/g, '_') // Convert spaces to underscores
+        .replace(/^_+|_+$/g, '') // Remove leading/trailing underscores
+        .replace(/_+/g, '_'); // Collapse multiple underscores to single
+};
+/**
+ * Get the full file path for a schema file
+ * Format: {schemaFileId}_{schemaName}_v{version}.json
+ *
+ * The ID-first format ensures all files for a schema group together when sorted alphabetically.
+ *
+ * @param workingDir - Working directory path
+ * @param name - Schema name
+ * @param version - Schema version
+ * @param schemaFileId - Schema file ID (required)
+ */
+const getSchemaFilePath = (workingDir, name, version, schemaFileId) => {
+    const path = BaseFileManager.getPathModule();
+    const sanitizedName = sanitizeSchemaName(name);
+    const filename = `${schemaFileId}_${sanitizedName}_v${version}.json`;
+    return path.join(workingDir, filename);
+};
+async function importJsonSchema(importFilePathOrContents, version = 1) {
+    // Determine if we have a file path or file contents
+    let importData;
+    let importFilePath;
+    let originalSchemaFile;
+    if (typeof importFilePathOrContents === 'string') {
+        // It's a file path
+        importFilePath = importFilePathOrContents;
+        importData = await readJsonImportFile(importFilePath);
+    }
+    else {
+        // It's file contents - check if it's already a complete schema format
+        try {
+            const parsed = JSON.parse(importFilePathOrContents.contents);
+            if (parsed.$schema && parsed.metadata) {
+                // It's already a complete schema format - preserve it (id may be missing, will be generated)
+                originalSchemaFile = parsed;
+                logger$2(`Input is complete schema format (${originalSchemaFile.id ? `preserving ID: ${originalSchemaFile.id}` : 'id will be generated'})`);
+            }
+        }
+        catch {
+            // Not valid JSON or not a complete schema, parse as import format
+        }
+        if (!originalSchemaFile) {
+            importData = parseJsonImportContent(importFilePathOrContents.contents);
+        }
+    }
+    // Use original schema file if available, otherwise transform from import format
+    let schemaFile;
+    if (originalSchemaFile) {
+        schemaFile = originalSchemaFile;
+        // Normalize models if provided as array (some tools output array format)
+        if (schemaFile.models) {
+            schemaFile.models = normalizeSchemaModels(schemaFile.models);
+        }
+        // Use provided version if different, otherwise use version from schema
+        if (version !== undefined && version !== schemaFile.version) {
+            schemaFile = { ...schemaFile, version };
+        }
+        // Check DB for existing schema by name+version (same as minimal path)
+        const db = BaseDb.getAppDb();
+        if (db) {
+            const _mod_1 = await import('./BasePathResolver-DRT09oVv.js');
+            const _ns_1 = _mod_1.Q;
+            const schemaSchemaMod = _ns_1;
+            const { schemas: schemasTable } = schemaSchemaMod;
+            const drizzleMod = await import('drizzle-orm');
+            const { eq, and, desc } = drizzleMod;
+            const existingByName = await db
+                .select()
+                .from(schemasTable)
+                .where(and(eq(schemasTable.name, schemaFile.metadata.name), eq(schemasTable.version, schemaFile.version ?? version)))
+                .orderBy(desc(schemasTable.isDraft))
+                .limit(1);
+            if (existingByName.length > 0 && existingByName[0].schemaData) {
+                const existing = existingByName[0];
+                logger$2(`Idempotency: found existing schema by name+version: ${schemaFile.metadata.name} v${schemaFile.version ?? version}`);
+                const existingSchema = JSON.parse(existing.schemaData);
+                const contentMatches = compareSchemaContent(schemaFile, existingSchema);
+                logger$2(`Idempotency: compareSchemaContent=${contentMatches} for ${schemaFile.metadata.name}`);
+                if (contentMatches) {
+                    if (existing.schemaFileId) {
+                        const workingDir = BaseFileManager.getWorkingDir();
+                        const existingFilePath = getSchemaFilePath(workingDir, schemaFile.metadata.name, schemaFile.version ?? version, existing.schemaFileId);
+                        if (await BaseFileManager.pathExists(existingFilePath)) {
+                            logger$2(`Schema ${schemaFile.metadata.name} v${schemaFile.version} already exists with same content, loading existing file`);
+                            return await loadSchemaFromFile(existingFilePath);
+                        }
+                        await BaseFileManager.createDirIfNotExists(workingDir);
+                        await BaseFileManager.saveFile(existingFilePath, existing.schemaData);
+                        await BaseFileManager.waitForFileWithContent(existingFilePath, 100, 5000);
+                        return await loadSchemaFromFile(existingFilePath);
+                    }
+                    logger$2(`Schema ${schemaFile.metadata.name} v${schemaFile.version} already exists with same content (no schemaFileId), using DB`);
+                    return '';
+                }
+            }
+        }
+        // Add metadata defaults when missing (prevents NaN in addSchemaToDb)
+        const now = new Date().toISOString();
+        if (!schemaFile.metadata.createdAt)
+            schemaFile.metadata.createdAt = now;
+        if (!schemaFile.metadata.updatedAt)
+            schemaFile.metadata.updatedAt = now;
+        // Generate missing IDs for complete schema files.
+        // Use deterministic id from content hash to prevent duplicate schema files when
+        // processSchemaFiles runs multiple times (React StrictMode, app restarts).
+        if (!schemaFile.id) {
+            schemaFile.id = await getDeterministicSchemaFileId(schemaFile);
+            logger$2(`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
+        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$2(`Schema file already exists with schemaFileId ${schemaFile.id}, loading it instead of creating new file`);
+            return await loadSchemaFromFile(existingFilePath);
+        }
+        // Generate missing model and property IDs.
+        // Use deterministic IDs (from schema content hash) so addModelsToDb finds existing
+        // records when processSchemaFiles runs multiple times with different DB/file contexts.
+        // Hash the schema content once: rehashing it per id is quadratic in schema size.
+        const getDeterministicId = getDeterministicIdsWithPrefix(getSchemaContentForComparison(schemaFile));
+        for (const [modelName, model] of Object.entries(schemaFile.models || {})) {
+            if (!model.id) {
+                model.id = getDeterministicId(modelName);
+                logger$2(`Generated deterministic model ID for ${modelName}:`, model.id);
+            }
+            for (const [propName, prop] of Object.entries(model.properties || {})) {
+                if (!prop.id) {
+                    prop.id = getDeterministicId(modelName + propName);
+                    logger$2(`Generated deterministic property ID for ${modelName}.${propName}:`, prop.id);
+                }
+            }
+        }
+    }
+    else {
+        if (!importData) {
+            throw new Error('Failed to parse import data: neither complete schema nor import format could be determined');
+        }
+        // For minimal imports: check DB for existing schema before creating new file
+        const db = BaseDb.getAppDb();
+        if (db) {
+            const _mod_2 = await import('./BasePathResolver-DRT09oVv.js');
+            const _ns_2 = _mod_2.Q;
+            const schemaSchemaMod = _ns_2;
+            const { schemas: schemasTable } = schemaSchemaMod;
+            const drizzleMod = await import('drizzle-orm');
+            const { eq, and, desc } = drizzleMod;
+            const existingByName = await db
+                .select()
+                .from(schemasTable)
+                .where(and(eq(schemasTable.name, importData.name), eq(schemasTable.version, version)))
+                .orderBy(desc(schemasTable.isDraft))
+                .limit(1);
+            if (existingByName.length > 0) {
+                const existing = existingByName[0];
+                const schemaFileForCompare = transformImportToSchemaFile(importData, version);
+                if (existing.schemaData) {
+                    try {
+                        const existingSchema = JSON.parse(existing.schemaData);
+                        if (compareSchemaContent(schemaFileForCompare, existingSchema)) {
+                            // Same content - use existing schema
+                            if (existing.schemaFileId) {
+                                const workingDir = BaseFileManager.getWorkingDir();
+                                const existingFilePath = getSchemaFilePath(workingDir, importData.name, version, existing.schemaFileId);
+                                if (await BaseFileManager.pathExists(existingFilePath)) {
+                                    logger$2(`Schema ${importData.name} v${version} already exists with same content, loading existing file`);
+                                    return await loadSchemaFromFile(existingFilePath);
+                                }
+                                // File missing but schemaData exists - restore file from schemaData
+                                await BaseFileManager.createDirIfNotExists(workingDir);
+                                await BaseFileManager.saveFile(existingFilePath, existing.schemaData);
+                                await BaseFileManager.waitForFileWithContent(existingFilePath, 100, 5000);
+                                logger$2(`Restored schema file from schemaData for ${importData.name} v${version}`);
+                                return await loadSchemaFromFile(existingFilePath);
+                            }
+                            // No schemaFileId - restore file from schemaData using id from parsed schema
+                            const schemaIdForPath = existingSchema.id || existing.schemaFileId;
+                            if (schemaIdForPath) {
+                                const workingDir = BaseFileManager.getWorkingDir();
+                                const existingFilePath = getSchemaFilePath(workingDir, importData.name, version, schemaIdForPath);
+                                await BaseFileManager.createDirIfNotExists(workingDir);
+                                await BaseFileManager.saveFile(existingFilePath, existing.schemaData);
+                                await BaseFileManager.waitForFileWithContent(existingFilePath, 100, 5000);
+                                logger$2(`Restored schema file from schemaData for ${importData.name} v${version}`);
+                                return await loadSchemaFromFile(existingFilePath);
+                            }
+                            logger$2(`Schema ${importData.name} v${version} already exists with same content (no id), using DB`);
+                            return '';
+                        }
+                        // Content differs - create new version
+                        const latestVersionRows = await db
+                            .select({ version: schemasTable.version })
+                            .from(schemasTable)
+                            .where(eq(schemasTable.name, importData.name))
+                            .orderBy(desc(schemasTable.version))
+                            .limit(1);
+                        const newVersion = latestVersionRows.length > 0 ? latestVersionRows[0].version + 1 : version;
+                        logger$2(`Schema ${importData.name} content changed, creating new version v${newVersion}`);
+                        schemaFile = transformImportToSchemaFile(importData, newVersion);
+                        version = newVersion;
+                    }
+                    catch {
+                        // Parse error - proceed with normal import
+                        schemaFile = schemaFileForCompare;
+                    }
+                }
+                else {
+                    schemaFile = schemaFileForCompare;
+                }
+            }
+            else {
+                schemaFile = transformImportToSchemaFile(importData, version);
+            }
+        }
+        else {
+            schemaFile = transformImportToSchemaFile(importData, version);
+        }
+    }
+    // Check if this is an internal SDK schema (should not create files in app directory)
+    const isInternal = isInternalSchema(schemaFile.metadata.name, schemaFile.id);
+    if (isInternal) {
+        logger$2(`Skipping file creation for internal schema: ${schemaFile.metadata.name}`);
+        // For internal schemas, just load to database and store, don't create file
+        // Extract schema name and version
+        const schemaName = schemaFile.metadata?.name;
+        const version = schemaFile.version;
+        if (!schemaName) {
+            throw new Error('Schema name is required in metadata.name');
+        }
+        // Convert to JsonImportSchema format for processing
+        const importDataForInternal = {
+            name: schemaName,
+            models: Object.fromEntries(Object.entries(schemaFile.models || {}).map(([modelName, model]) => [
+                modelName,
+                {
+                    ...model,
+                    // Remove id field for import format
+                    id: undefined,
+                    properties: Object.fromEntries(Object.entries(model.properties || {}).map(([propName, prop]) => {
+                        const schemaProp = prop;
+                        const jsonProp = {
+                            type: schemaProp.dataType || schemaProp.type,
+                            // Remove id field for import format
+                            id: undefined,
+                        };
+                        // Handle Relation type - convert ref to model (not for List)
+                        const rawDataType = (schemaProp.dataType ?? schemaProp.type ?? '').toString().toLowerCase();
+                        if (rawDataType !== 'list' && (schemaProp.ref || schemaProp.refModelName)) {
+                            jsonProp.model = schemaProp.refModelName || schemaProp.ref;
+                        }
+                        // Handle List type (support both refValueType and legacy items, case-insensitive dataType)
+                        if (rawDataType === 'list') {
+                            let refValueType = getRefValueType(schemaProp);
+                            // When ref is present but refValueType is not, derive refValueType as "Relation" (list of Relations)
+                            if (!refValueType && (schemaProp.ref ?? schemaProp.refModelName ?? schemaProp.items?.model)) {
+                                refValueType = 'Relation';
+                            }
+                            if (refValueType) {
+                                jsonProp.refValueType = refValueType;
+                                const ref = schemaProp.ref ?? schemaProp.refModelName ?? schemaProp.items?.model;
+                                if (ref)
+                                    jsonProp.ref = ref;
+                            }
+                        }
+                        // Copy other properties (storage, etc.)
+                        Object.keys(schemaProp).forEach(key => {
+                            if (key !== 'id' && key !== 'dataType' && key !== 'type' && key !== 'ref' && key !== 'refModelName' && key !== 'refValueType') {
+                                jsonProp[key] = schemaProp[key];
+                            }
+                        });
+                        return [propName, jsonProp];
+                    })),
+                },
+            ])),
+        };
+        // Use fixed internal schema ID if missing (never generate for internal)
+        if (!schemaFile.id) {
+            schemaFile.id = INTERNAL_SCHEMA_IDS[0];
+            logger$2('Using fixed internal schema ID:', schemaFile.id);
+        }
+        // Extract schemaFileIds from JSON file and generate missing ones BEFORE creating models
+        // This ensures Model instances are created with correct IDs
+        const modelFileIds = new Map();
+        const propertyFileIds = new Map();
+        for (const [modelName, model] of Object.entries(schemaFile.models || {})) {
+            // Generate model ID if missing
+            if (!model.id) {
+                model.id = generateId();
+                logger$2(`Generated model ID for ${modelName}:`, model.id);
+                // Update the schemaFile object so it's included in schemaData
+                schemaFile.models[modelName].id = model.id;
+            }
+            modelFileIds.set(modelName, model.id);
+            const propIds = new Map();
+            for (const [propName, prop] of Object.entries(model.properties || {})) {
+                // Generate property ID if missing
+                if (!prop.id) {
+                    prop.id = generateId();
+                    logger$2(`Generated property ID for ${modelName}.${propName}:`, prop.id);
+                    // Update the schemaFile object so it's included in schemaData
+                    schemaFile.models[modelName].properties[propName].id = prop.id;
+                }
+                propIds.set(propName, prop.id);
+            }
+            if (propIds.size > 0) {
+                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);
+        logger$2('loadSchemaFromFile (internal) - modelDefinitions length:', Object.keys(modelDefinitions).length);
+        // Convert schema file metadata to schema input for database
+        const schemaInput = {
+            name: schemaName,
+            version,
+            schemaFileId: schemaFile.id || null,
+            createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
+            updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
+        };
+        // Use dynamic import to break circular dependency
+        const _mod_3 = await import('./db-Lw0KVZmc.js');
+        const _ns_3 = _mod_3.Z;
+        const dbMod = _ns_3;
+        const { addSchemaToDb, addModelsToDb } = dbMod;
+        // Try to add schema and models to database if database is available
+        try {
+            const db = BaseDb.getAppDb();
+            if (db) {
+                // Store full schema data in database as fallback when file is not available
+                // schemaFile already has all IDs (from JSON file or generated), so we can use it directly
+                const schemaData = JSON.stringify(schemaFile, null, 2);
+                // Add schema to database (creates or returns existing) with schemaFileId and schemaData
+                const schemaRecord = await addSchemaToDb(schemaInput, schemaFile.id, schemaData, false);
+                // Add models to database and link them to the schema with schemaFileIds (only if there are models)
+                if (Object.keys(modelDefinitions).length > 0) {
+                    await addModelsToDb(modelDefinitions, schemaRecord, undefined, {
+                        schemaFileId: schemaFile.id,
+                        modelFileIds,
+                        propertyFileIds,
+                    });
+                    // Verify expected models are linked (single attempt - addModelsToDb already confirmed)
+                    const expectedModelNames = Object.keys(schemaFile.models || {});
+                    const _mod_4 = await import('./BasePathResolver-DRT09oVv.js');
+                    const _ns_4 = _mod_4.R;
+                    const modelSchemaSchemaMod = _ns_4;
+                    const { modelSchemas } = modelSchemaSchemaMod;
+                    const _mod_5 = await import('./BasePathResolver-DRT09oVv.js');
+                    const _ns_5 = _mod_5.N;
+                    const modelSchemaMod = _ns_5;
+                    const { models: modelsTable } = modelSchemaMod;
+                    const drizzleMod = await import('drizzle-orm');
+                    const { eq, and, isNull } = drizzleMod;
+                    const modelLinks = await db
+                        .select({
+                        modelId: modelSchemas.modelId,
+                        modelName: modelsTable.name,
+                    })
+                        .from(modelSchemas)
+                        .innerJoin(modelsTable, eq(modelSchemas.modelId, modelsTable.id))
+                        .where(eq(modelSchemas.schemaId, schemaRecord.id));
+                    const linkedModelNames = modelLinks
+                        .map((link) => link.modelName)
+                        .filter((n) => n !== null);
+                    const missingModels = expectedModelNames.filter(name => !linkedModelNames.includes(name));
+                    const allModelsLinked = missingModels.length === 0;
+                    if (!allModelsLinked) {
+                        console.warn(`[importJsonSchema] WARNING: Not all expected models are linked. Expected: ${expectedModelNames.join(', ')}, Linked: ${linkedModelNames.join(', ')}, Missing: ${missingModels.join(', ') || 'none'}`);
+                        // Try to link missing models directly by finding them in the database
+                        if (missingModels.length > 0) {
+                            for (const missingModelName of missingModels) {
+                                try {
+                                    const modelFileId = modelFileIds.get(missingModelName);
+                                    if (modelFileId) {
+                                        // Find model by schemaFileId
+                                        const missingModel = await db
+                                            .select()
+                                            .from(modelsTable)
+                                            .where(eq(modelsTable.schemaFileId, modelFileId))
+                                            .limit(1);
+                                        if (missingModel.length > 0 && missingModel[0].id) {
+                                            // Check if join entry already exists
+                                            const existingJoin = await db
+                                                .select()
+                                                .from(modelSchemas)
+                                                .where(and(eq(modelSchemas.modelId, missingModel[0].id), eq(modelSchemas.schemaId, schemaRecord.id)))
+                                                .limit(1);
+                                            if (existingJoin.length === 0) {
+                                                await linkModelToSchema(db, missingModel[0].id, schemaRecord.id);
+                                            }
+                                            else {
+                                            }
+                                        }
+                                        else {
+                                            console.warn(`[importJsonSchema] Could not find model "${missingModelName}" with schemaFileId "${modelFileId}" in database`);
+                                        }
+                                    }
+                                    else {
+                                        // Fallback: find by name, but only a stub no schema claims (model names are only
+                                        // unique per schema; an unlinked row with a schemaFileId is a deleted schema's leftover)
+                                        const missingModel = await db
+                                            .select({ id: modelsTable.id })
+                                            .from(modelsTable)
+                                            .leftJoin(modelSchemas, eq(modelsTable.id, modelSchemas.modelId))
+                                            .where(and(eq(modelsTable.name, missingModelName), isNull(modelSchemas.id), isNull(modelsTable.schemaFileId)))
+                                            .limit(1);
+                                        if (missingModel.length > 0 && missingModel[0].id) {
+                                            const existingJoin = await db
+                                                .select()
+                                                .from(modelSchemas)
+                                                .where(and(eq(modelSchemas.modelId, missingModel[0].id), eq(modelSchemas.schemaId, schemaRecord.id)))
+                                                .limit(1);
+                                            if (existingJoin.length === 0) {
+                                                await linkModelToSchema(db, missingModel[0].id, schemaRecord.id);
+                                            }
+                                        }
+                                        else {
+                                            console.warn(`[importJsonSchema] Could not find model "${missingModelName}" by name in database`);
+                                        }
+                                    }
+                                }
+                                catch (error) {
+                                    console.error(`[importJsonSchema] Error linking missing model "${missingModelName}":`, error?.message || String(error));
+                                }
+                            }
+                        }
+                    }
+                    // Skip expensive verifyPropertiesPersisted - addModelsToDb already persisted; verification was for browser quirks
+                    // Skip "After properties" block for internal schema: addSchemaToDb/addModelsToDb already stored
+                    // correct schemaData. The per-model ID sync (6 model + 6 property selects + schema update) is
+                    // redundant during init and causes slow OPFS writes. Ad-hoc loadSchemaFromFile uses the same
+                    // applySchemaToDb path but runs when DB is warm.
+                }
+            }
+        }
+        catch (dbError) {
+            // Database not available - log warning but continue
+            logger$2('Database not available, skipping database operations:', dbError instanceof Error ? dbError.message : String(dbError));
+        }
+        // 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)) {
+            logger$2('loadSchemaFromFile (internal) - model available:', modelName);
+        }
+        // Schema is now saved to database
+        // useSchemas hook will pick it up via database queries
+        return ''; // Return empty string to indicate no file was created
+    }
+    const workingDir = BaseFileManager.getWorkingDir();
+    const path = BaseFileManager.getPathModule();
+    // Ensure schema ID is defined (should always be set by this point, but check for safety)
+    if (!schemaFile.id) {
+        schemaFile.id = generateId();
+        logger$2('Generated schema ID before file path creation:', schemaFile.id);
+    }
+    // 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);
+    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
+        if (importFilePath) {
+            const normalizedImportPath = path.resolve(importFilePath);
+            const normalizedTargetPath = path.resolve(filePath);
+            if (normalizedImportPath === normalizedTargetPath) {
+                // Check if the file is already a complete schema
+                try {
+                    const content = await BaseFileManager.readFileAsString(importFilePath);
+                    const data = JSON.parse(content);
+                    if (data.$schema) {
+                        // File is already a complete schema, just load it
+                        logger$2(`Schema file ${filePath} already exists and is complete, loading it`);
+                        return await loadSchemaFromFile(filePath);
+                    }
+                }
+                catch (error) {
+                    // If we can't read the file, proceed with the error
+                }
+            }
+        }
+        // File exists - check if it matches the schema we're trying to import
+        try {
+            const existingContent = await BaseFileManager.readFileAsString(filePath);
+            const existingSchema = JSON.parse(existingContent);
+            // Verify it's a complete schema file
+            if (existingSchema.$schema) {
+                // Compare schemas structurally
+                if (compareSchemasStructurally(schemaFile, existingSchema)) {
+                    // Schemas match - just load the existing file
+                    logger$2(`Schema ${schemaFile.metadata.name} v${version} already exists with matching content, loading it`);
+                    return await loadSchemaFromFile(filePath);
+                }
+                else {
+                    // Schemas don't match - throw error to prevent data loss
+                    throw new Error(`Schema ${schemaFile.metadata.name} v${version} already exists with different content. ` +
+                        `To update the schema, delete the existing file first or use a different version.`);
+                }
+            }
+            else {
+                // File exists but is not a complete schema - this shouldn't happen with ID-based naming
+                // but we'll treat it as a conflict
+                throw new Error(`Schema ${schemaFile.metadata.name} v${version} already exists but file is not a complete schema`);
+            }
+        }
+        catch (error) {
+            // If error is already our custom error, re-throw it
+            if (error instanceof Error && error.message.includes('already exists')) {
+                throw error;
+            }
+            // If we can't read/parse the existing file, throw a generic error
+            throw new Error(`Schema ${schemaFile.metadata.name} v${version} already exists but could not be read: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Ensure working directory exists
+    await BaseFileManager.createDirIfNotExists(workingDir);
+    // Write schema to file
+    const content = JSON.stringify(schemaFile, null, 2);
+    await BaseFileManager.saveFile(filePath, content);
+    // Wait for the file to be available and readable before trying to read it
+    // This is necessary in browser environments where file writes may not be immediately readable
+    await BaseFileManager.waitForFileWithContent(filePath, 100, 5000);
+    // Load the schema file to process models and add them to the store
+    // This handles all model creation, database operations, and store updates
+    await loadSchemaFromFile(filePath);
+    // Schema is now saved to database
+    // useSchemas hook will pick it up via database queries
+    return filePath;
+}
+/**
+ * Apply schema and models to the database. Shared by loadSchemaFromFile and syncSchemaFromSource.
+ * @internal
+ */
+async function applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, propertyFileIds) {
+    const schemaName = schemaFile.metadata?.name;
+    const version = schemaFile.version;
+    if (!schemaName) {
+        throw new Error('Schema name is required in metadata.name');
+    }
+    const schemaInput = {
+        name: schemaName,
+        version,
+        schemaFileId: schemaFile.id || null,
+        createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
+        updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
+    };
+    const _mod_6 = await import('./db-Lw0KVZmc.js');
+    const _ns_6 = _mod_6.Z;
+    const dbMod = _ns_6;
+    const { addSchemaToDb, addModelsToDb } = dbMod;
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        throw new Error('Database not found');
+    }
+    const schemaData = JSON.stringify(schemaFile, null, 2);
+    const schemaRecord = await addSchemaToDb(schemaInput, schemaFile.id, schemaData, false);
+    if (Object.keys(modelDefinitions).length > 0) {
+        await addModelsToDb(modelDefinitions, schemaRecord, undefined, {
+            schemaFileId: schemaFile.id,
+            modelFileIds,
+            propertyFileIds,
+        });
+        await new Promise(resolve => setTimeout(resolve, 200));
+    }
+    return { schemaRecord };
+}
+/**
+ * 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.
+ * Called automatically at init when config.schema is provided.
+ *
+ * @param source - File path (string) or complete SchemaFileFormat object
+ */
+async function syncSchemaFromSource(source) {
+    if (typeof source === 'string') {
+        const path = BaseFileManager.getPathModule();
+        const resolvedPath = path.isAbsolute(source)
+            ? source
+            : isNode()
+                ? path.resolve(process.cwd(), source)
+                : path.join(BaseFileManager.getWorkingDir(), source);
+        const content = await BaseFileManager.readFileAsString(resolvedPath);
+        const parsed = JSON.parse(content);
+        const version = parsed?.version ?? 1;
+        await importJsonSchema({ contents: content }, version);
+    }
+    else {
+        const version = source.version ?? 1;
+        await importJsonSchema({ contents: JSON.stringify(source) }, version);
+    }
+}
+/**
+ * Load an existing complete schema file and process its models
+ * This is used to load models from already-processed schema files into the store
+ * @param schemaFilePath - Path to the complete schema file (must have $schema field)
+ * @returns The file path of the schema
+ * @throws Error if file cannot be read, parsed, or is not a complete schema
+ */
+const loadSchemaFromFile = async (schemaFilePath) => {
+    try {
+        // Read and parse the schema file
+        const content = await BaseFileManager.readFileAsString(schemaFilePath);
+        const schemaFile = JSON.parse(content);
+        // Normalize models if provided as array (some tools output array format)
+        if (schemaFile.models) {
+            schemaFile.models = normalizeSchemaModels(schemaFile.models);
+        }
+        // Verify it's a complete schema file
+        if (!schemaFile.$schema) {
+            throw new Error(`File ${schemaFilePath} is not a complete schema file (missing $schema field). Use importJsonSchema() for minimal format files.`);
+        }
+        // Extract schema name and version
+        const schemaName = schemaFile.metadata?.name;
+        const version = schemaFile.version;
+        if (!schemaName) {
+            throw new Error('Schema name is required in metadata.name');
+        }
+        // Convert to JsonImportSchema format for processing
+        // Remove id fields for JsonImportSchema format (they're not part of the import format)
+        const importData = {
+            name: schemaName,
+            models: Object.fromEntries(Object.entries(schemaFile.models || {}).map(([modelName, model]) => [
+                modelName,
+                {
+                    ...model,
+                    // Remove id field for import format
+                    id: undefined,
+                    properties: Object.fromEntries(Object.entries(model.properties).map(([propName, prop]) => {
+                        const schemaProp = prop;
+                        const jsonProp = {
+                            type: schemaProp.dataType || schemaProp.type,
+                            // Remove id field for import format
+                            id: undefined,
+                        };
+                        // Handle Relation type - convert ref to model (not for List)
+                        const rawDataType = (schemaProp.dataType ?? schemaProp.type ?? '').toString().toLowerCase();
+                        if (rawDataType !== 'list' && (schemaProp.ref || schemaProp.refModelName)) {
+                            jsonProp.model = schemaProp.refModelName || schemaProp.ref;
+                        }
+                        // Handle List type (support both refValueType and legacy items, case-insensitive dataType)
+                        if (rawDataType === 'list') {
+                            let refValueType = getRefValueType(schemaProp);
+                            // When ref is present but refValueType is not, derive refValueType as "Relation" (list of Relations)
+                            if (!refValueType && (schemaProp.ref ?? schemaProp.refModelName ?? schemaProp.items?.model)) {
+                                refValueType = 'Relation';
+                            }
+                            if (refValueType) {
+                                jsonProp.refValueType = refValueType;
+                                const ref = schemaProp.ref ?? schemaProp.refModelName ?? schemaProp.items?.model;
+                                if (ref)
+                                    jsonProp.ref = ref;
+                            }
+                        }
+                        // Copy other properties (storage, etc.)
+                        Object.keys(schemaProp).forEach(key => {
+                            if (key !== 'id' && key !== 'dataType' && key !== 'type' && key !== 'ref' && key !== 'refModelName' && key !== 'refValueType') {
+                                jsonProp[key] = schemaProp[key];
+                            }
+                        });
+                        return [propName, jsonProp];
+                    })),
+                },
+            ])),
+        };
+        // Generate schema ID if missing (before creating schemaInput)
+        if (!schemaFile.id) {
+            schemaFile.id = generateId();
+            logger$2('Generated schema ID for schema file:', schemaFile.id);
+        }
+        // Extract schemaFileIds from JSON file and generate missing ones BEFORE creating models
+        // This ensures Model instances are created with correct IDs
+        const modelFileIds = new Map();
+        const propertyFileIds = new Map();
+        for (const [modelName, model] of Object.entries(schemaFile.models || {})) {
+            // Generate model ID if missing
+            if (!model.id) {
+                model.id = generateId();
+                logger$2(`Generated model ID for ${modelName}:`, model.id);
+                // Update the schemaFile object so it's included in schemaData
+                schemaFile.models[modelName].id = model.id;
+            }
+            modelFileIds.set(modelName, model.id);
+            const propIds = new Map();
+            for (const [propName, prop] of Object.entries(model.properties)) {
+                // Generate property ID if missing
+                if (!prop.id) {
+                    prop.id = generateId();
+                    logger$2(`Generated property ID for ${modelName}.${propName}:`, prop.id);
+                    // Update the schemaFile object so it's included in schemaData
+                    schemaFile.models[modelName].properties[propName].id = prop.id;
+                }
+                propIds.set(propName, prop.id);
+            }
+            if (propIds.size > 0) {
+                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);
+        logger$2('loadSchemaFromFile - modelDefinitions length:', Object.keys(modelDefinitions).length);
+        // Try to add schema and models to database if database is available
+        try {
+            const db = BaseDb.getAppDb();
+            if (db) {
+                const { schemaRecord } = await applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, propertyFileIds);
+                // Query the database to get model IDs that were just created
+                const _mod_7 = await import('./BasePathResolver-DRT09oVv.js');
+                const _ns_7 = _mod_7.R;
+                const modelSchemaSchemaMod = _ns_7;
+                const { modelSchemas } = modelSchemaSchemaMod;
+                const _mod_8 = await import('./BasePathResolver-DRT09oVv.js');
+                const _ns_8 = _mod_8.N;
+                const modelSchemaMod = _ns_8;
+                const { models: modelsTable } = modelSchemaMod;
+                const drizzleMod = await import('drizzle-orm');
+                const { eq } = drizzleMod;
+                // Try to find models directly by schemaFileId first (more reliable than join table)
+                const seedModelId = modelFileIds.get('Seed');
+                let seedModel = [];
+                if (seedModelId) {
+                    // Retry querying for the model until it's visible
+                    for (let attempt = 0; attempt < 10; attempt++) {
+                        seedModel = await db
+                            .select()
+                            .from(modelsTable)
+                            .where(eq(modelsTable.schemaFileId, seedModelId))
+                            .limit(1);
+                        if (seedModel.length > 0 && seedModel[0].id) {
+                            break;
+                        }
+                        if (attempt < 9) {
+                            await new Promise(resolve => setTimeout(resolve, 100));
+                        }
+                    }
+                    if (seedModel.length > 0 && seedModel[0].id) {
+                        await verifyPropertiesPersisted(db, seedModel[0].id, 'Seed', 10, 100);
+                    }
+                }
+                // Also verify via join table if schemaRecord.id is available (for completeness)
+                if (schemaRecord.id) {
+                    // Retry querying join table until entries are visible
+                    let modelLinks = [];
+                    for (let attempt = 0; attempt < 10; attempt++) {
+                        modelLinks = await db
+                            .select({
+                            modelId: modelSchemas.modelId,
+                            modelName: modelsTable.name,
+                        })
+                            .from(modelSchemas)
+                            .innerJoin(modelsTable, eq(modelSchemas.modelId, modelsTable.id))
+                            .where(eq(modelSchemas.schemaId, schemaRecord.id));
+                        if (modelLinks.length > 0) {
+                            break;
+                        }
+                        if (attempt < 9) {
+                            await new Promise(resolve => setTimeout(resolve, 100));
+                        }
+                    }
+                    logger$2(`Verifying properties: found ${modelLinks.length} model links for schema ${schemaName} (id: ${schemaRecord.id})`);
+                    // If we didn't verify via direct lookup, verify via join table
+                    if (!seedModelId || (seedModel.length === 0 || !seedModel[0].id)) {
+                        const seedModelLink = modelLinks.find((link) => link.modelName === 'Seed');
+                        if (seedModelLink && seedModelLink.modelId) {
+                            logger$2(`Verifying properties for Seed model via join table (modelId: ${seedModelLink.modelId})`);
+                            await verifyPropertiesPersisted(db, seedModelLink.modelId, 'Seed', 10, 100);
+                        }
+                        else if (modelLinks.length > 0 && modelLinks[0].modelId) {
+                            // Fallback to first model if Seed not found
+                            logger$2(`Verifying properties for ${modelLinks[0].modelName} model via join table (modelId: ${modelLinks[0].modelId})`);
+                            await verifyPropertiesPersisted(db, modelLinks[0].modelId, modelLinks[0].modelName || 'unknown', 10, 100);
+                        }
+                    }
+                }
+                // 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-DRT09oVv.js');
+                const _ns_9 = _mod_9.N;
+                const modelSchemaMod2 = _ns_9;
+                const { properties: propertiesTable } = modelSchemaMod2;
+                let schemaFileUpdated = false;
+                for (const [modelName, modelFileId] of modelFileIds.entries()) {
+                    // Get model record to find modelId
+                    const modelRecords = await db
+                        .select()
+                        .from(modelsTable)
+                        .where(eq(modelsTable.schemaFileId, modelFileId))
+                        .limit(1);
+                    if (modelRecords.length > 0) {
+                        const modelId = modelRecords[0].id;
+                        // Get all properties for this model from database
+                        const propertyRecords = await db
+                            .select()
+                            .from(propertiesTable)
+                            .where(eq(propertiesTable.modelId, modelId));
+                        // Update schemaFile with actual database IDs (only if they differ)
+                        for (const propRecord of propertyRecords) {
+                            if (propRecord.schemaFileId && schemaFile.models[modelName]?.properties[propRecord.name]) {
+                                const currentId = schemaFile.models[modelName].properties[propRecord.name].id;
+                                if (currentId !== propRecord.schemaFileId) {
+                                    schemaFile.models[modelName].properties[propRecord.name].id = propRecord.schemaFileId;
+                                    logger$2(`Updated schemaFile property ID for ${modelName}.${propRecord.name} from ${currentId} to ${propRecord.schemaFileId}`);
+                                    schemaFileUpdated = true;
+                                }
+                            }
+                        }
+                    }
+                }
+                // Always update schemaData to ensure it matches the current schemaFile state
+                // 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-DRT09oVv.js');
+                const _ns_10 = _mod_10.Q;
+                const schemaSchemaMod = _ns_10;
+                const { schemas: schemasTable } = schemaSchemaMod;
+                await db
+                    .update(schemasTable)
+                    .set({ schemaData: updatedSchemaData })
+                    .where(eq(schemasTable.id, schemaRecord.id));
+                if (schemaFileUpdated) {
+                    logger$2(`Updated schemaData in database with actual property IDs for schema "${schemaName}"`);
+                }
+                else {
+                    logger$2(`Verified schemaData in database matches schemaFile for schema "${schemaName}"`);
+                }
+            }
+        }
+        catch (dbError) {
+            // Database not available - log warning but continue
+            logger$2('Database not available, skipping database operations:', dbError instanceof Error ? dbError.message : String(dbError));
+        }
+        // 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)) {
+            logger$2('loadSchemaFromFile - model available:', modelName);
+        }
+        return schemaFilePath;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON in file ${schemaFilePath}: ${error.message}`);
+        }
+        throw new Error(`Failed to load schema from file ${schemaFilePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+/**
+ * Create a Model class from a JSON model definition
+ * @param modelName - The name of the model
+ * @param modelDef - The JSON model definition
+ * @param schemaName - The name of the schema this model belongs to
+ * @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('./index-Y-yYyRBf.js');
+    const _ns_11 = _mod_11.f;
+    const modelMod = _ns_11;
+    const { Model } = modelMod;
+    // Convert JSON properties to schema format
+    const convertedProperties = {};
+    if (modelDef.properties) {
+        for (const [propName, propDef] of Object.entries(modelDef.properties)) {
+            // JSON import format: { type, model, items, storage: { type, path, extension } }
+            // Schema format: { dataType, ref, refValueType, storageType, localStorageDir, filenameSuffix }
+            const jsonProp = propDef;
+            const rawType = jsonProp.type ?? jsonProp.dataType;
+            const schemaProp = {
+                dataType: normalizeDataType(rawType),
+            };
+            // Include property ID if available from propertyFileIds map
+            // This ensures the property uses the correct ID from the schema file
+            const propertyFileId = propertyFileIds?.get(propName);
+            if (propertyFileId) {
+                schemaProp.id = propertyFileId;
+            }
+            // Handle Relation type
+            if (jsonProp.model && (rawType || '').toLowerCase() !== 'list') {
+                schemaProp.ref = jsonProp.model;
+                schemaProp.refModelName = jsonProp.model;
+            }
+            // Handle List type (case-insensitive): requires refValueType (or legacy items.type); ref when Relation
+            if ((rawType || '').toLowerCase() === 'list') {
+                let elementType = getRefValueType(jsonProp);
+                // When ref is present but refValueType is not, derive refValueType as "Relation" (list of Relations)
+                if ((!elementType || String(elementType).trim() === '') && (jsonProp.ref ?? jsonProp.items?.model ?? jsonProp.model)) {
+                    elementType = 'Relation';
+                }
+                if (!elementType || String(elementType).trim() === '') {
+                    const propKeys = Object.keys(jsonProp).join(', ');
+                    const propPreview = JSON.stringify(jsonProp).slice(0, 200);
+                    throw new Error(`List property "${propName}" in model "${modelName}" requires "refValueType" (e.g. refValueType: "Text" or refValueType: "Relation" with ref: "Tag"). ` +
+                        `Property has keys: [${propKeys}]. Raw property: ${propPreview}${propPreview.length >= 200 ? '...' : ''}`);
+                }
+                schemaProp.refValueType = normalizeDataType(elementType);
+                const modelRef = jsonProp.ref ?? jsonProp.items?.model ?? jsonProp.model;
+                if (modelRef) {
+                    schemaProp.ref = modelRef;
+                    schemaProp.refModelName = modelRef;
+                }
+            }
+            // Handle storage configuration
+            if (jsonProp.storage) {
+                schemaProp.storageType = jsonProp.storage.type === 'ItemStorage' ? 'ItemStorage' : 'PropertyStorage';
+                schemaProp.localStorageDir = jsonProp.storage.path;
+                schemaProp.filenameSuffix = jsonProp.storage.extension;
+            }
+            // Handle required (for Relation/Image properties)
+            if (jsonProp.required !== undefined) {
+                schemaProp.required = !!jsonProp.required;
+            }
+            // Preserve validation rules (enum, pattern, minLength, maxLength)
+            if (jsonProp.validation && typeof jsonProp.validation === 'object') {
+                schemaProp.validation = jsonProp.validation;
+            }
+            convertedProperties[propName] = schemaProp;
+        }
+    }
+    // Create Model instance with the definition
+    // Pass id (schemaFileId) if provided to ensure Model instance uses correct ID
+    // Note: indexes and description are ignored - they remain in JSON for schema file format compliance but are not used by Model instances
+    if (modelFileId) {
+        logger$2(`Creating schema model "${modelName}" with modelFileId: ${modelFileId}`);
+    }
+    else {
+        logger$2(`Warning: Creating schema model "${modelName}" without modelFileId - it will be renamed if duplicates exist`);
+    }
+    const modelInstance = Model.create(modelName, schemaName, {
+        modelFileId: modelFileId, // Pass modelFileId (preferred) as id (schemaFileId) from JSON file
+        id: modelFileId, // Also pass as id for backward compatibility
+        properties: convertedProperties,
+        waitForReady: false,
+    });
+    return modelInstance;
+};
+/**
+ * Convert JSON import schema to ModelDefinitions
+ * @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
+ * @returns ModelDefinitions object with Model classes
+ */
+const createModelsFromJson = async (importData, modelFileIds, propertyFileIds) => {
+    const modelDefinitions = {};
+    const schemaName = importData.name;
+    for (const [modelName, modelDef] of Object.entries(importData.models)) {
+        // Get modelFileId from map if available
+        const modelFileId = modelFileIds?.get(modelName);
+        // Use modelFileId from map (no fallback to modelDef.id as JsonImportSchema doesn't have id property)
+        const finalModelFileId = modelFileId;
+        if (!finalModelFileId) {
+            logger$2(`Warning: No modelFileId found for model "${modelName}" - model will be created without ID`);
+        }
+        // Get propertyFileIds for this model if available
+        const modelPropertyFileIds = propertyFileIds?.get(modelName);
+        const ModelClass = await createModelFromJson(modelName, modelDef, schemaName, finalModelFileId, modelPropertyFileIds);
+        modelDefinitions[modelName] = ModelClass;
+    }
+    return modelDefinitions;
+};
+/**
+ * Read a JSON import file and create Model classes from it.
+ * For complete schema files ($schema), extracts model/property IDs so Model instances
+ * use correct schemaFileIds - preventing duplicate models (Publication 1, etc.) when
+ * processSchemaFiles runs multiple times.
+ * @param filePath - Path to the JSON import file
+ * @returns ModelDefinitions with Model classes created from the JSON schema
+ */
+const createModelsFromJsonFile = async (filePath) => {
+    const workingDir = BaseFileManager.getWorkingDir();
+    const internalFilePath = filePath.startsWith(workingDir) ? filePath : `${workingDir}/${filePath}`;
+    const content = await BaseFileManager.readFileAsString(internalFilePath);
+    const parsed = JSON.parse(content);
+    const importData = parseJsonImportContent(content);
+    // Extract model and property IDs from complete schema format so createModelsFromJson
+    // can pass them - without these, Model instances get new random IDs and addModelsToDb
+    // creates duplicates (Publication 1, Identity 1, etc.)
+    let modelFileIds;
+    let propertyFileIds;
+    if (parsed?.$schema && parsed?.models) {
+        const models = normalizeSchemaModels(parsed.models);
+        modelFileIds = new Map();
+        propertyFileIds = new Map();
+        for (const [modelName, model] of Object.entries(models)) {
+            if (model?.id)
+                modelFileIds.set(modelName, model.id);
+            if (model?.properties) {
+                const propIds = new Map();
+                for (const [propName, prop] of Object.entries(model.properties)) {
+                    if (prop?.id)
+                        propIds.set(propName, prop.id);
+                }
+                if (propIds.size > 0)
+                    propertyFileIds.set(modelName, propIds);
+            }
+        }
+    }
+    return createModelsFromJson(importData, modelFileIds, propertyFileIds);
+};
+
+var $schema = "https://seedprotocol.org/schemas/data-model/v1";
+var version = 1;
+var id = "SEEDPROTOCOL";
+var metadata = {
+	name: "Seed Protocol",
+	description: "Internal Seed Protocol schema defining core models (Seed, Version, Metadata, Image, File, Html)",
+	createdAt: "2025-01-01T00:00:00Z",
+	updatedAt: "2025-01-01T00:00:00Z"
+};
+var models = {
+	Seed: {
+		id: "SEEDPROTOCOL_SEED",
+		description: "Core seed model representing the base entity in Seed Protocol",
+		properties: {
+			uid: {
+				type: "Text",
+				id: "SEEDPROTOCOL_SEED_uid"
+			},
+			type: {
+				type: "Text",
+				id: "SEEDPROTOCOL_SEED_type"
+			}
+		}
+	},
+	Version: {
+		id: "SEEDPROTOCOL_VERSION",
+		description: "Version model representing versions of seeds",
+		properties: {
+			seedUid: {
+				type: "Text",
+				id: "SEEDPROTOCOL_VERSION_seedUid"
+			},
+			note: {
+				type: "Text",
+				id: "SEEDPROTOCOL_VERSION_note"
+			}
+		}
+	},
+	Metadata: {
+		id: "SEEDPROTOCOL_METADATA",
+		description: "Metadata model for storing key-value pairs",
+		properties: {
+			key: {
+				type: "Text",
+				id: "SEEDPROTOCOL_METADATA_key"
+			},
+			value: {
+				type: "Text",
+				id: "SEEDPROTOCOL_METADATA_value"
+			}
+		}
+	},
+	Image: {
+		id: "SEEDPROTOCOL_IMAGE",
+		description: "Image model for storing image data and metadata",
+		properties: {
+			storageTransactionId: {
+				type: "Text",
+				id: "SEEDPROTOCOL_IMAGE_storageTransactionId"
+			},
+			uri: {
+				type: "Text",
+				id: "SEEDPROTOCOL_IMAGE_uri"
+			},
+			alt: {
+				type: "Text",
+				id: "SEEDPROTOCOL_IMAGE_alt"
+			}
+		}
+	},
+	File: {
+		id: "SEEDPROTOCOL_FILE",
+		description: "File model for storing file data and metadata",
+		properties: {
+			storageTransactionId: {
+				type: "Text",
+				id: "SEEDPROTOCOL_FILE_storageTransactionId"
+			},
+			uri: {
+				type: "Text",
+				id: "SEEDPROTOCOL_FILE_uri"
+			}
+		}
+	},
+	Html: {
+		id: "SEEDPROTOCOL_HTML",
+		description: "Html model for storing HTML content and metadata",
+		properties: {
+			storageTransactionId: {
+				type: "Text",
+				id: "SEEDPROTOCOL_HTML_storageTransactionId"
+			},
+			uri: {
+				type: "Text",
+				id: "SEEDPROTOCOL_HTML_uri"
+			}
+		}
+	}
+};
+var enums = {
+};
+var migrations = [
+	{
+		version: 1,
+		timestamp: "2025-01-01T00:00:00Z",
+		description: "Initial seed-protocol schema with Seed, Version, Metadata, and Image models",
+		changes: [
+		]
+	},
+	{
+		version: 2,
+		timestamp: "2025-02-14T00:00:00Z",
+		description: "Add File and Html models for storage seed types",
+		changes: [
+			"Add File model with storageTransactionId and uri",
+			"Add Html model with storageTransactionId and uri"
+		]
+	}
+];
+var internalSchema = {
+	$schema: $schema,
+	version: version,
+	id: id,
+	metadata: metadata,
+	models: models,
+	enums: enums,
+	migrations: migrations
+};
+
+var SEEDPROTOCOL_Seed_Protocol_v1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    $schema: $schema,
+    default: internalSchema,
+    enums: enums,
+    id: id,
+    metadata: metadata,
+    migrations: migrations,
+    models: models,
+    version: version
+});
+
+const logger$1 = debug('seedSdk:client:actors:processSchemaFiles');
+let processSchemaFilesChain = Promise.resolve();
+function resolveSchemaFilePath(schemaFile) {
+    const path = BaseFileManager.getPathModule();
+    if (path.isAbsolute(schemaFile)) {
+        return schemaFile;
+    }
+    if (isNode()) {
+        return path.resolve(process.cwd(), schemaFile);
+    }
+    const workingDir = BaseFileManager.getWorkingDir();
+    return path.join(workingDir, schemaFile);
+}
+/** Resolve schema display name from an inlined object or on-disk JSON path. */
+async function resolveSchemaNameFromSource(source) {
+    if (typeof source === 'object' && source?.metadata?.name) {
+        return String(source.metadata.name);
+    }
+    if (typeof source === 'string') {
+        try {
+            const resolvedPath = resolveSchemaFilePath(source);
+            const content = await BaseFileManager.readFileAsString(resolvedPath);
+            const parsed = JSON.parse(content);
+            if (parsed?.metadata?.name) {
+                return String(parsed.metadata.name);
+            }
+        }
+        catch (error) {
+            logger$1('Could not resolve schema name from path:', source, error);
+        }
+    }
+    return null;
+}
+// Timeout for the entire schema processing operation (120 seconds)
+// Schema processing can be slow with syncSchemaFromSource, loadAllSchemasFromDb, and OPFS file I/O
+const PROCESS_SCHEMA_FILES_TIMEOUT_MS = 120000;
+const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
+    logger$1('processSchemaFiles started');
+    let hasResponded = false;
+    let timeoutId = null;
+    const reportError = (error) => {
+        if (!hasResponded) {
+            hasResponded = true;
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+            logger$1('processSchemaFiles error:', error);
+            sendBack({
+                type: 'error',
+                error: error instanceof Error ? error : new Error(String(error))
+            });
+        }
+    };
+    const reportSuccess = () => {
+        if (!hasResponded) {
+            hasResponded = true;
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+            logger$1('processSchemaFiles completed');
+            sendBack({ type: ClientManagerEvents.PROCESS_SCHEMA_FILES_SUCCESS });
+        }
+    };
+    // Set up a single timeout for the entire operation
+    timeoutId = setTimeout(() => {
+        reportError(new Error(`processSchemaFiles timed out after ${PROCESS_SCHEMA_FILES_TIMEOUT_MS}ms`));
+    }, PROCESS_SCHEMA_FILES_TIMEOUT_MS);
+    const _processSchemaFiles = async () => {
+        // Schemas written (or confirmed present) this run — skip redundant loadSchemaFromFile later
+        const schemasWrittenThisRun = new Set();
+        // First, load the internal seed-protocol schema
+        logger$1('Loading internal seed-protocol schema');
+        const internalSchemaData = internalSchema;
+        const db = BaseDb.getAppDb();
+        const internalSchemaExists = db
+            ? (await db.select().from(schemas).where(eq(schemas.schemaFileId, INTERNAL_SCHEMA_IDS[0])).limit(1)).length > 0
+            : false;
+        // Always mark internal schema as written so the DB/file loop does not re-apply it
+        schemasWrittenThisRun.add(SEED_PROTOCOL_SCHEMA_NAME);
+        if (internalSchemaExists) {
+            logger$1('Internal seed-protocol schema already in DB, skipping import');
+        }
+        else {
+            try {
+                // Import the internal schema to database (will create models and add to store)
+                await importJsonSchema({ contents: JSON.stringify(internalSchemaData) }, internalSchemaData.version);
+                logger$1(`Loaded internal seed-protocol schema v${internalSchemaData.version}`);
+            }
+            catch (error) {
+                // If schema already exists, that's fine - it means it was already loaded
+                if (error?.message?.includes('already exists')) {
+                    logger$1('Internal seed-protocol schema already loaded');
+                }
+                else {
+                    logger$1('Error loading internal seed-protocol schema:', error);
+                    // Don't fail if internal schema can't be loaded - it might already be in DB
+                }
+            }
+        }
+        // If schema (canonical) is provided, sync it - takes precedence over schemaFile
+        if (context.schema) {
+            // Skip sync when schema is internal (already loaded above)
+            const schemaName = typeof context.schema === 'object' && context.schema?.metadata?.name
+                ? String(context.schema.metadata.name)
+                : '';
+            const schemaId = typeof context.schema === 'object' && context.schema?.id ? String(context.schema.id) : undefined;
+            if (isInternalSchema(schemaName, schemaId)) {
+                logger$1('Schema is internal (Seed Protocol), already loaded - skipping syncSchemaFromSource');
+            }
+            else {
+                try {
+                    const syncedName = await resolveSchemaNameFromSource(context.schema);
+                    await syncSchemaFromSource(context.schema);
+                    if (syncedName) {
+                        schemasWrittenThisRun.add(syncedName);
+                    }
+                    logger$1(`Synced canonical schema from ${typeof context.schema === 'string' ? context.schema : 'object'}`);
+                }
+                catch (error) {
+                    logger$1(`Error syncing canonical schema:`, error);
+                    // Don't fail init - schema might already be in DB
+                }
+            }
+        }
+        else if (context.schemaFile) {
+            // Legacy: schemaFile - load via importJsonSchema
+            try {
+                const resolvedPath = resolveSchemaFilePath(context.schemaFile);
+                const content = await BaseFileManager.readFileAsString(resolvedPath);
+                const parsed = JSON.parse(content);
+                await importJsonSchema({ contents: content });
+                if (parsed?.metadata?.name) {
+                    schemasWrittenThisRun.add(String(parsed.metadata.name));
+                }
+                logger$1(`Loaded schema from ${resolvedPath}`);
+            }
+            catch (error) {
+                logger$1(`Error loading schema file ${context.schemaFile}:`, error);
+                // Don't fail init - schema might already be in DB
+            }
+        }
+        // Process minimal import files (files without $schema) - skip when canonical schema is set
+        if (!context.schema) {
+            logger$1('Listing schema files');
+            let schemaFiles = [];
+            try {
+                schemaFiles = await listSchemaFiles();
+                logger$1(`Found ${schemaFiles.length} schema files to process`);
+            }
+            catch (error) {
+                logger$1('Error listing schema files (continuing anyway):', error);
+                schemaFiles = [];
+            }
+            for (const schemaFile of schemaFiles) {
+                try {
+                    await importJsonSchema(schemaFile.filePath);
+                    if (schemaFile.name) {
+                        schemasWrittenThisRun.add(schemaFile.name);
+                    }
+                }
+                catch (error) {
+                    logger$1(`Error importing schema file ${schemaFile.filePath}:`, error);
+                }
+            }
+        }
+        // Then, load all schemas using the unified database-first approach
+        logger$1('Loading schemas from database and files');
+        let allSchemasData = [];
+        try {
+            allSchemasData = await loadAllSchemasFromDb();
+            logger$1(`Loaded ${allSchemasData.length} schemas (${allSchemasData.filter(s => s.isDraft).length} drafts, ${allSchemasData.filter(s => !s.isDraft).length} published)`);
+        }
+        catch (error) {
+            logger$1('Error loading schemas from database (continuing anyway):', error);
+            // Continue with empty array - this is not critical for initialization
+            // Schemas can be loaded on-demand later
+            allSchemasData = [];
+        }
+        // Collect models to add to context (schemas are now loaded on-demand via database queries)
+        const allModels = { ...(context.models || {}) };
+        // Linked model count per schema row, to tell whether an earlier load already applied a file's models
+        const linkedModelCounts = new Map();
+        if (db) {
+            try {
+                const rows = await db
+                    .select({ schemaId: modelSchemas.schemaId, count: countDistinct(modelSchemas.modelId) })
+                    .from(modelSchemas)
+                    .groupBy(modelSchemas.schemaId);
+                for (const row of rows) {
+                    if (row.schemaId != null)
+                        linkedModelCounts.set(row.schemaId, Number(row.count));
+                }
+            }
+            catch (error) {
+                logger$1('Error counting linked models (re-applying all schema files):', error);
+            }
+        }
+        for (const schemaData of allSchemasData) {
+            const schema = schemaData.schema;
+            const schemaName = schema.metadata?.name || 'unknown';
+            logger$1(`Processing schema: ${schemaName} v${schema.version} (${schemaData.isDraft ? 'draft' : 'published'}, source: ${schemaData.source})`);
+            // For published schemas (not drafts), load models from file if available
+            if (!schemaData.isDraft && schema.id) {
+                // loadAllSchemasFromDb already picked the latest file for this schema (and read it)
+                const latestFilePath = schemaData.filePath;
+                if (latestFilePath) {
+                    try {
+                        // Skip loadSchemaFromFile when this schema was already written this run (or is
+                        // internal) — re-applying creates UNIQUE constraint races on properties.
+                        // Use createModelsFromJsonFile only to get model definitions for context.
+                        const alreadyWritten = schemasWrittenThisRun.has(schemaName) ||
+                            isInternalSchema(schemaName, schema.id);
+                        // Also skip when an earlier init already applied this file: the DB row matches it and
+                        // all its models are linked. Re-applying every published schema on every init made
+                        // init time grow with the number of schema files.
+                        const expectedModelCount = Object.keys(schema.models || {}).length;
+                        const alreadyApplied = schemaData.dbMatchesFile === true &&
+                            schemaData.schemaRecordId != null &&
+                            (linkedModelCounts.get(schemaData.schemaRecordId) ?? 0) >= expectedModelCount;
+                        if (alreadyWritten || alreadyApplied) {
+                            const modelDefinitions = await createModelsFromJsonFile(latestFilePath);
+                            Object.assign(allModels, modelDefinitions);
+                        }
+                        else {
+                            await loadSchemaFromFile(latestFilePath);
+                            const modelDefinitions = await createModelsFromJsonFile(latestFilePath);
+                            Object.assign(allModels, modelDefinitions);
+                        }
+                    }
+                    catch (error) {
+                        logger$1(`Error loading schema file for ${schemaName}:`, error);
+                    }
+                }
+                else {
+                    // File doesn't exist (e.g. schema passed via config.schema) - use schema data from loadAllSchemasFromDb
+                    try {
+                        const schemaModels = schema.models;
+                        if (schemaModels && Object.keys(schemaModels).length > 0) {
+                            const modelFileIds = new Map();
+                            const propertyFileIds = new Map();
+                            for (const [modelName, model] of Object.entries(schemaModels)) {
+                                const modelId = model.id;
+                                if (modelId)
+                                    modelFileIds.set(modelName, modelId);
+                                if (model.properties) {
+                                    const propIds = new Map();
+                                    for (const [propName, prop] of Object.entries(model.properties)) {
+                                        const propId = prop.id;
+                                        if (propId)
+                                            propIds.set(propName, propId);
+                                    }
+                                    if (propIds.size > 0)
+                                        propertyFileIds.set(modelName, propIds);
+                                }
+                            }
+                            const importData = {
+                                name: schemaName,
+                                models: Object.fromEntries(Object.entries(schemaModels).map(([modelName, model]) => [
+                                    modelName,
+                                    {
+                                        description: model.description,
+                                        properties: Object.fromEntries(Object.entries(model.properties || {}).map(([propName, prop]) => {
+                                            const p = prop;
+                                            return [
+                                                propName,
+                                                {
+                                                    type: p.dataType || p.type,
+                                                    model: p.refModelName || p.ref,
+                                                    refValueType: p.refValueType,
+                                                    ref: p.ref,
+                                                    ...p,
+                                                },
+                                            ];
+                                        })),
+                                    },
+                                ])),
+                            };
+                            const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds);
+                            Object.assign(allModels, modelDefinitions);
+                            logger$1(`Loaded ${Object.keys(modelDefinitions).length} models from schema data for ${schemaName}`);
+                        }
+                    }
+                    catch (error) {
+                        logger$1(`Error creating models from schema data for ${schemaName}:`, error);
+                    }
+                }
+            }
+            else if (schemaData.isDraft) {
+                // For drafts, create models from the schema data
+                try {
+                    const schemaModels = schema.models;
+                    if (schemaModels && Object.keys(schemaModels).length > 0) {
+                        const modelFileIds = new Map();
+                        const propertyFileIds = new Map();
+                        for (const [modelName, model] of Object.entries(schemaModels)) {
+                            const modelId = model.id;
+                            if (modelId)
+                                modelFileIds.set(modelName, modelId);
+                            if (model.properties) {
+                                const propIds = new Map();
+                                for (const [propName, prop] of Object.entries(model.properties)) {
+                                    const propId = prop.id;
+                                    if (propId)
+                                        propIds.set(propName, propId);
+                                }
+                                if (propIds.size > 0)
+                                    propertyFileIds.set(modelName, propIds);
+                            }
+                        }
+                        const importData = {
+                            name: schemaName,
+                            models: Object.fromEntries(Object.entries(schemaModels).map(([modelName, model]) => [
+                                modelName,
+                                {
+                                    description: model.description,
+                                    properties: Object.fromEntries(Object.entries(model.properties || {}).map(([propName, prop]) => {
+                                        const p = prop;
+                                        return [
+                                            propName,
+                                            {
+                                                type: p.dataType || p.type,
+                                                model: p.refModelName || p.ref,
+                                                refValueType: p.refValueType,
+                                                ref: p.ref,
+                                                ...p,
+                                            },
+                                        ];
+                                    })),
+                                },
+                            ])),
+                        };
+                        const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds);
+                        Object.assign(allModels, modelDefinitions);
+                        logger$1(`Loaded ${Object.keys(modelDefinitions).length} models from draft schema ${schemaName}`);
+                    }
+                }
+                catch (error) {
+                    logger$1(`Error creating models from draft schema ${schemaName}:`, error);
+                }
+            }
+            // Schemas are now loaded on-demand via database queries (useSchemas hook uses loadAllSchemasFromDb)
+            // No need to populate context.schemas
+        }
+        // Update context with models only (schemas are loaded on-demand via database queries)
+        sendBack({
+            type: ClientManagerEvents.UPDATE_CONTEXT,
+            context: {
+                models: allModels,
+            }
+        });
+    };
+    processSchemaFilesChain = processSchemaFilesChain
+        // Its schema and model inserts check for rows first, so tabs take turns (docs/MULTI_TAB.md).
+        .then(() => withSeedDbLock('init', context.filesDir, _processSchemaFiles))
+        .catch((err) => {
+        logger$1('processSchemaFiles chain error:', err);
+        throw err;
+    });
+    processSchemaFilesChain.then(reportSuccess).catch((error) => {
+        reportError(error instanceof Error ? error : new Error(String(error)));
+    });
+    // Cleanup function to clear timeout if actor is stopped
+    return () => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+        }
+    };
+});
+
+const { UNINITIALIZED, PLATFORM_CLASSES_INIT, FILE_SYSTEM_INIT, DB_INIT, SAVE_CONFIG, PROCESS_SCHEMA_FILES, ADD_MODELS_TO_STORE, ADD_MODELS_TO_DB, IDLE, INIT_FAILED, } = ClientManagerState;
+const { UPDATE_CONTEXT, PLATFORM_CLASSES_READY, FILE_SYSTEM_READY, DB_READY, SAVE_CONFIG_SUCCESS, SAVE_APP_STATE_SUCCESS, SAVE_APP_STATE_ERROR, SET_ADDRESSES, ADD_MODELS_TO_STORE_SUCCESS, ADD_MODELS_TO_DB_SUCCESS, PROCESS_SCHEMA_FILES_SUCCESS, } = ClientManagerEvents;
+const logSyncAfterAddressSave = debug("seedSdk:client:clientManagerMachine:syncAfterAddressSave");
+function addressesFromPersistedAddressValue(value) {
+    if (!value || typeof value !== "object")
+        return [];
+    const v = value;
+    const owned = Array.isArray(v.owned)
+        ? v.owned.filter((a) => typeof a === "string")
+        : [];
+    const watched = Array.isArray(v.watched)
+        ? v.watched.filter((a) => typeof a === "string")
+        : [];
+    const seen = new Set();
+    const out = [];
+    for (const a of [...owned, ...watched]) {
+        const k = a.toLowerCase();
+        if (!seen.has(k)) {
+            seen.add(k);
+            out.push(a);
+        }
+    }
+    return out;
+}
+function maybeRunSyncFromEasAfterAddressSave({ context, event, }) {
+    const merged = addressesFromPersistedAddressValue(event.value);
+    if (!context.syncFromEasOnAddressChange)
+        return;
+    if (event.key !== "addresses")
+        return;
+    if (merged.length === 0)
+        return;
+    try {
+        requestEasSyncFromAddressChange(merged);
+    }
+    catch (err) {
+        logSyncAfterAddressSave("requestEasSyncFromAddressChange after address save failed", err);
+    }
+}
+function emitAddressesPersistedIfAddressesKey(event) {
+    if (event.key !== "addresses")
+        return;
+    const payload = parseAddressesPersistedPayload(event.value);
+    emitAcrossTabs(ADDRESSES_PERSISTED_EVENT, payload);
+}
+function errorFromEvent(event, fallbackMessage) {
+    const error = event?.error;
+    if (error instanceof Error) {
+        return error;
+    }
+    return new Error(String(error ?? fallbackMessage));
+}
+const failInit = (fallbackMessage) => ({
+    target: INIT_FAILED,
+    actions: {
+        type: "assignInitError",
+        params: { fallbackMessage },
+    },
+});
+const clientManagerMachine = setup({
+    types: {
+        context: {},
+        input: {},
+    },
+    actors: {
+        platformClassesInit,
+        fileSystemInit,
+        dbInit,
+        saveConfig,
+        saveAppState,
+        addModelsToStore,
+        addModelsToDb,
+        processSchemaFiles,
+    },
+    actions: {
+        assignInitError: assign(({ event }, params) => ({
+            initError: errorFromEvent(event, params.fallbackMessage),
+            isInitialized: false,
+        })),
+    },
+}).createMachine({
+    id: MachineIds.CLIENT_MANAGER,
+    initial: UNINITIALIZED,
+    context: ({ input }) => input,
+    on: {
+        [UPDATE_CONTEXT]: {
+            actions: assign(({ event, context }) => {
+                return {
+                    ...context,
+                    ...event.context,
+                };
+            }),
+        },
+        init: {
+            target: `.${PLATFORM_CLASSES_INIT}`,
+            actions: assign({
+                isInitialized: false,
+                initError: undefined,
+                saveError: undefined,
+            }),
+        },
+    },
+    states: {
+        [UNINITIALIZED]: {
+            on: {
+                init: {
+                    target: PLATFORM_CLASSES_INIT,
+                },
+            },
+        },
+        [PLATFORM_CLASSES_INIT]: {
+            on: {
+                [PLATFORM_CLASSES_READY]: {
+                    target: FILE_SYSTEM_INIT,
+                },
+                error: failInit('Platform classes initialization failed'),
+            },
+            invoke: {
+                src: 'platformClassesInit',
+                input: ({ event, context }) => ({
+                    event: event,
+                    context
+                }),
+                onError: failInit('Platform classes initialization failed'),
+            },
+        },
+        [FILE_SYSTEM_INIT]: {
+            on: {
+                [FILE_SYSTEM_READY]: {
+                    target: DB_INIT,
+                },
+                error: failInit('File system initialization failed'),
+            },
+            invoke: {
+                src: 'fileSystemInit',
+                input: ({ context }) => ({ context }),
+                onError: failInit('File system initialization failed'),
+            },
+        },
+        [DB_INIT]: {
+            on: {
+                [DB_READY]: {
+                    target: SAVE_CONFIG,
+                },
+                error: failInit('Database initialization failed'),
+            },
+            invoke: {
+                src: 'dbInit',
+                input: ({ context }) => ({ context }),
+                onError: failInit('Database initialization failed'),
+            },
+        },
+        [SAVE_CONFIG]: {
+            on: {
+                [SAVE_CONFIG_SUCCESS]: {
+                    target: PROCESS_SCHEMA_FILES,
+                },
+                error: failInit('Saving config failed'),
+            },
+            invoke: {
+                src: 'saveConfig',
+                input: ({ context }) => ({ context }),
+                onError: failInit('Saving config failed'),
+            },
+        },
+        [PROCESS_SCHEMA_FILES]: {
+            on: {
+                [PROCESS_SCHEMA_FILES_SUCCESS]: {
+                    target: ADD_MODELS_TO_STORE,
+                },
+                error: failInit('Schema processing failed'),
+            },
+            invoke: {
+                src: 'processSchemaFiles',
+                input: ({ context }) => ({ context }),
+                onError: failInit('Schema processing failed'),
+            },
+        },
+        [ADD_MODELS_TO_STORE]: {
+            on: {
+                [ADD_MODELS_TO_STORE_SUCCESS]: {
+                    target: ADD_MODELS_TO_DB,
+                },
+                error: failInit('Adding models to store failed'),
+            },
+            invoke: {
+                src: 'addModelsToStore',
+                input: ({ context }) => ({ context }),
+                onError: failInit('Adding models to store failed'),
+            },
+        },
+        [ADD_MODELS_TO_DB]: {
+            on: {
+                [ADD_MODELS_TO_DB_SUCCESS]: {
+                    target: IDLE,
+                },
+                error: failInit('Adding models to database failed'),
+            },
+            invoke: {
+                src: 'addModelsToDb',
+                input: ({ context }) => ({ context }),
+                onError: failInit('Adding models to database failed'),
+            },
+        },
+        [INIT_FAILED]: {
+            entry: assign({
+                isInitialized: false,
+            }),
+            on: {
+                init: {
+                    target: PLATFORM_CLASSES_INIT,
+                    actions: assign({
+                        isInitialized: false,
+                        initError: undefined,
+                        saveError: undefined,
+                    }),
+                },
+            },
+        },
+        [IDLE]: {
+            entry: assign({
+                isInitialized: true,
+            }),
+            on: {
+                [SAVE_APP_STATE_SUCCESS]: {
+                    actions: [
+                        assign(() => {
+                            return {
+                                isSaving: false,
+                                saveError: undefined,
+                            };
+                        }),
+                        ({ context, event }) => maybeRunSyncFromEasAfterAddressSave({
+                            context,
+                            event: event,
+                        }),
+                        ({ event }) => emitAddressesPersistedIfAddressesKey(event),
+                    ],
+                },
+                [SAVE_APP_STATE_ERROR]: {
+                    actions: assign(({ event }) => ({
+                        isSaving: false,
+                        saveError: errorFromEvent(event, 'Failed to save app state'),
+                    })),
+                },
+                [SET_ADDRESSES]: {
+                    actions: [
+                        assign(({ event, spawn }) => {
+                            const { addresses } = event;
+                            const normalized = normalizeAddressConfig(addresses);
+                            spawn('saveAppState', {
+                                input: {
+                                    key: 'addresses',
+                                    value: { owned: normalized.owned, watched: normalized.watched },
+                                },
+                            });
+                            return {
+                                addresses: normalized.owned,
+                                ownedAddresses: normalized.owned,
+                                watchedAddresses: normalized.watched,
+                                isSaving: true,
+                                saveError: undefined,
+                            };
+                        })
+                    ],
+                },
+                init: {
+                    target: PLATFORM_CLASSES_INIT,
+                    actions: assign({
+                        isInitialized: false,
+                        initError: undefined,
+                        saveError: undefined,
+                    }),
+                },
+            },
+        },
+    },
+});
+
+/**
+ * Coalesce overlapping async init calls onto one in-flight promise.
+ * Skip when already successfully ready. Always clear in-flight on settle
+ * so a failed init can be retried.
+ */
+function createCoalescedAsync(run, shouldSkip) {
+    let inFlight = null;
+    return (arg) => {
+        if (inFlight) {
+            return inFlight;
+        }
+        if (shouldSkip(arg)) {
+            return Promise.resolve();
+        }
+        const pending = run(arg).finally(() => {
+            if (inFlight === pending) {
+                inFlight = null;
+            }
+        });
+        inFlight = pending;
+        return pending;
+    };
+}
+
+function msToUnixSeconds(ms) {
+    if (ms == null || !Number.isFinite(ms))
+        return 0;
+    // Heuristic: values already in seconds are small; ms are large
+    if (ms > 1e12)
+        return Math.floor(ms / 1000);
+    if (ms > 1e10)
+        return Math.floor(ms / 1000);
+    return Math.floor(ms);
+}
+function toSnakeCaseName(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
+        .toLowerCase();
+}
+function parsePropertyValue(raw) {
+    if (raw == null)
+        return '';
+    const t = raw.trim();
+    if ((t.startsWith('[') && t.endsWith(']')) ||
+        (t.startsWith('{') && t.endsWith('}'))) {
+        try {
+            return JSON.parse(t);
+        }
+        catch {
+            return raw;
+        }
+    }
+    return raw;
+}
+/**
+ * Revocation as this database knows it. `revoked_at` (unix seconds) is the local truth: sync keeps
+ * EAS's revocationTime there and unpublish stamps it before EAS's index catches up, while
+ * `attestation_raw` only records what EAS said when the row was fetched.
+ */
+function isRevokedLocally(revokedAt) {
+    return revokedAt != null && revokedAt !== 0;
+}
+/** Overrides the fetch-time `revoked`/`revocationTime` of a stored attestation with `revoked_at`. */
+function withLocalRevocation(att, revokedAt) {
+    const revoked = isRevokedLocally(revokedAt);
+    return { ...att, revoked, revocationTime: revoked ? revokedAt : 0 };
+}
+function attestationFromRaw(raw) {
+    if (!raw || !raw.trim())
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed.id === 'string')
+            return parsed;
+    }
+    catch {
+        // fall through
+    }
+    return null;
+}
+function seedRowToAttestation(row) {
+    if (!row.uid || !isValidEasAttestationUid(row.uid))
+        return null;
+    const fromRaw = attestationFromRaw(row.attestationRaw);
+    if (fromRaw) {
+        const schemaName = row.schemaName ??
+            fromRaw.schema?.schemaNames?.[0]?.name ??
+            row.type ??
+            'unknown';
+        return withLocalRevocation({
+            ...fromRaw,
+            id: row.uid,
+            schema: {
+                schemaNames: [{ name: schemaName }],
+            },
+            timeCreated: fromRaw.timeCreated ||
+                msToUnixSeconds(row.attestationCreatedAt),
+            attester: fromRaw.attester ?? row.publisher ?? undefined,
+            schemaId: fromRaw.schemaId || row.schemaUid || '',
+        }, row.revokedAt);
+    }
+    const schemaName = row.schemaName ?? row.type ?? 'unknown';
+    return withLocalRevocation({
+        id: row.uid,
+        decodedDataJson: '',
+        refUID: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        schemaId: row.schemaUid || '',
+        timeCreated: msToUnixSeconds(row.attestationCreatedAt),
+        attester: row.publisher ?? undefined,
+        schema: { schemaNames: [{ name: schemaName }] },
+    }, row.revokedAt);
+}
+function versionRowToAttestation(row) {
+    if (!row.uid || !isValidEasAttestationUid(row.uid))
+        return null;
+    if (!row.seedUid)
+        return null;
+    const fromRaw = attestationFromRaw(row.attestationRaw);
+    if (fromRaw) {
+        return withLocalRevocation({
+            ...fromRaw,
+            id: row.uid,
+            refUID: row.seedUid,
+            timeCreated: fromRaw.timeCreated ||
+                msToUnixSeconds(row.attestationCreatedAt),
+            attester: fromRaw.attester ?? row.publisher ?? undefined,
+        }, row.revokedAt);
+    }
+    return withLocalRevocation({
+        id: row.uid,
+        decodedDataJson: '',
+        refUID: row.seedUid,
+        schemaId: '',
+        timeCreated: msToUnixSeconds(row.attestationCreatedAt),
+        attester: row.publisher ?? undefined,
+    }, row.revokedAt);
+}
+function metadataRowToAttestation(row) {
+    if (!row.uid || !isValidEasAttestationUid(row.uid))
+        return null;
+    if (!row.versionUid)
+        return null;
+    const fromRaw = attestationFromRaw(row.attestationRaw);
+    if (fromRaw) {
+        return withLocalRevocation({
+            ...fromRaw,
+            id: row.uid,
+            refUID: row.versionUid,
+            schemaId: fromRaw.schemaId || row.schemaUid || '',
+            timeCreated: fromRaw.timeCreated ||
+                msToUnixSeconds(row.attestationCreatedAt),
+            attester: fromRaw.attester ?? row.publisher ?? undefined,
+        }, row.revokedAt);
+    }
+    const name = row.propertyName
+        ? toSnakeCaseName(row.propertyName)
+        : 'unknown';
+    const value = parsePropertyValue(row.propertyValue);
+    const type = row.easDataType || 'string';
+    return withLocalRevocation({
+        id: row.uid,
+        decodedDataJson: JSON.stringify([{ value: { name, value, type } }]),
+        refUID: row.versionUid,
+        schemaId: row.schemaUid || '',
+        timeCreated: msToUnixSeconds(row.attestationCreatedAt),
+        attester: row.publisher ?? undefined,
+    }, row.revokedAt);
+}
+async function resolveSchemaNameForSeedType(appDb, seedType, 
+/** seeds.model_file_id: the seed's own model (model names are only unique per schema). */
+modelFileId) {
+    if (!seedType)
+        return null;
+    const normalized = startCase(seedType);
+    try {
+        const schemaRows = await appDb
+            .select({ schemaName: schemas.name })
+            .from(models$1)
+            .innerJoin(modelSchemas, eq(models$1.id, modelSchemas.modelId))
+            .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
+            .where(modelFileId ? eq(models$1.schemaFileId, modelFileId) : eq(models$1.name, normalized))
+            .orderBy(desc(models$1.id))
+            .limit(1);
+        if (schemaRows[0]?.schemaName)
+            return schemaRows[0].schemaName;
+    }
+    catch {
+        // ignore
+    }
+    return seedType;
+}
+function monthBoundsUnix(year, month) {
+    const startDate = new Date(year, month - 1, 1);
+    const endDate = new Date(year, month, 0, 23, 59, 59);
+    const startTs = Math.floor(startDate.getTime() / 1000);
+    const endTs = Math.floor(endDate.getTime() / 1000) + 1;
+    return { startTs, endTs };
+}
+async function listPublishedSeedRows(schemaName, opts) {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb)
+        return [];
+    const snakeType = schemaName.includes('_')
+        ? schemaName
+        : schemaName.replace(/([A-Z])/g, (m, i) => i === 0 ? m.toLowerCase() : `_${m.toLowerCase()}`);
+    // Prefer exact type match (EAS schema names are usually lowercase singular)
+    const typeCandidates = Array.from(new Set([schemaName, schemaName.toLowerCase(), snakeType.toLowerCase()]));
+    const rows = await appDb
+        .select({
+        uid: seeds.uid,
+        schemaUid: seeds.schemaUid,
+        type: seeds.type,
+        modelFileId: seeds.modelFileId,
+        publisher: seeds.publisher,
+        attestationRaw: seeds.attestationRaw,
+        attestationCreatedAt: seeds.attestationCreatedAt,
+        revokedAt: seeds.revokedAt,
+        markedForDeletion: seeds._markedForDeletion,
+    })
+        .from(seeds)
+        .where(and(inArray(seeds.type, typeCandidates), isNotNull(seeds.uid), or(isNull(seeds.revokedAt), eq(seeds.revokedAt, 0)), or(isNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 0))))
+        .orderBy(desc(seeds.attestationCreatedAt));
+    const out = [];
+    for (const row of rows) {
+        if (!row.uid || !isValidEasAttestationUid(row.uid))
+            continue;
+        // Must have at least one published version that is not revoked: the SDK's latest published
+        // version skips revoked ones, so a seed whose versions were all revoked has none.
+        const versionRows = await appDb
+            .select({
+            uid: versions.uid,
+            revokedAt: versions.revokedAt,
+        })
+            .from(versions)
+            .where(eq(versions.seedUid, row.uid))
+            .orderBy(desc(versions.createdAt));
+        const hasPublished = versionRows.some((v) => v.uid && isValidEasAttestationUid(v.uid) && !isRevokedLocally(v.revokedAt));
+        if (!hasPublished)
+            continue;
+        const schemaResolved = await resolveSchemaNameForSeedType(appDb, row.type, row.modelFileId);
+        const att = seedRowToAttestation({
+            ...row,
+            schemaName: schemaResolved === schemaName ? schemaName : (schemaResolved ?? schemaName),
+        });
+        if (!att)
+            continue;
+        // Force requested schema name so assembleSeeds filters correctly
+        att.schema = { schemaNames: [{ name: schemaName }] };
+        if (opts?.startTs != null || opts?.endTs != null) {
+            const t = att.timeCreated;
+            if (opts.startTs != null && t < opts.startTs)
+                continue;
+            if (opts.endTs != null && t >= opts.endTs)
+                continue;
+        }
+        out.push(att);
+    }
+    return out;
+}
+/**
+ * SDK local QueryDataSource: published Seeds/Versions/metadata from SQLite.
+ *
+ * Revocation follows the local `revoked_at` columns, not the stored `attestation_raw`: rows with
+ * `revoked_at` set are left out (as the remote source leaves out revoked attestations) and returned
+ * attestations carry `revoked`/`revocationTime` from those columns.
+ */
+function createLocalQueryDataSource() {
+    return {
+        kind: 'local',
+        async getSeedByUid(seedUid) {
+            const appDb = BaseDb.getAppDb();
+            if (!appDb || !seedUid)
+                return null;
+            const rows = await appDb
+                .select({
+                uid: seeds.uid,
+                schemaUid: seeds.schemaUid,
+                type: seeds.type,
+                modelFileId: seeds.modelFileId,
+                publisher: seeds.publisher,
+                attestationRaw: seeds.attestationRaw,
+                attestationCreatedAt: seeds.attestationCreatedAt,
+                revokedAt: seeds.revokedAt,
+            })
+                .from(seeds)
+                .where(eq(seeds.uid, seedUid))
+                .limit(1);
+            const row = rows[0];
+            if (!row?.uid || !isValidEasAttestationUid(row.uid))
+                return null;
+            if (isRevokedLocally(row.revokedAt))
+                return null;
+            const schemaName = await resolveSchemaNameForSeedType(appDb, row.type, row.modelFileId);
+            return seedRowToAttestation({ ...row, schemaName });
+        },
+        async listSeedsBySchemaName(schemaName, opts) {
+            const all = await listPublishedSeedRows(schemaName);
+            return all.slice(opts.skip, opts.skip + opts.limit);
+        },
+        async listSeedsBySchemaNameForMonth(schemaName, year, month) {
+            const { startTs, endTs } = monthBoundsUnix(year, month);
+            return listPublishedSeedRows(schemaName, { startTs, endTs });
+        },
+        async getVersionsForSeed(seedUid) {
+            return this.getVersionsForSeeds([seedUid]);
+        },
+        async getVersionsForSeeds(seedUids, opts) {
+            const appDb = BaseDb.getAppDb();
+            if (!appDb || seedUids.length === 0)
+                return [];
+            const rows = await appDb
+                .select({
+                uid: versions.uid,
+                seedUid: versions.seedUid,
+                publisher: versions.publisher,
+                attestationRaw: versions.attestationRaw,
+                attestationCreatedAt: versions.attestationCreatedAt,
+                revokedAt: versions.revokedAt,
+            })
+                .from(versions)
+                .where(inArray(versions.seedUid, seedUids));
+            // Like the remote source (EAS queries exclude revoked attestations by default; with
+            // includeRevoked they come back marked `revoked`).
+            const out = [];
+            for (const row of rows) {
+                if (isRevokedLocally(row.revokedAt) && !opts?.includeRevoked)
+                    continue;
+                const att = versionRowToAttestation(row);
+                if (att)
+                    out.push(att);
+            }
+            return out;
+        },
+        async getPropertiesForVersionUids(versionUids) {
+            const appDb = BaseDb.getAppDb();
+            if (!appDb || versionUids.length === 0)
+                return [];
+            const rows = await appDb
+                .select({
+                uid: metadata$1.uid,
+                schemaUid: metadata$1.schemaUid,
+                propertyName: metadata$1.propertyName,
+                propertyValue: metadata$1.propertyValue,
+                easDataType: metadata$1.easDataType,
+                versionUid: metadata$1.versionUid,
+                publisher: metadata$1.publisher,
+                attestationRaw: metadata$1.attestationRaw,
+                attestationCreatedAt: metadata$1.attestationCreatedAt,
+                revokedAt: metadata$1.revokedAt,
+            })
+                .from(metadata$1)
+                .where(inArray(metadata$1.versionUid, versionUids));
+            // Like the remote source, revoked property attestations are left out, so the query layer's
+            // canonical pick (newest live per version and schema) matches the SDK's live-first readers.
+            const out = [];
+            for (const row of rows) {
+                if (isRevokedLocally(row.revokedAt))
+                    continue;
+                const att = metadataRowToAttestation(row);
+                if (att)
+                    out.push(att);
+            }
+            return out;
+        },
+        async getSeedsByUids(uids) {
+            const appDb = BaseDb.getAppDb();
+            if (!appDb || uids.length === 0)
+                return [];
+            const rows = await appDb
+                .select({
+                uid: seeds.uid,
+                schemaUid: seeds.schemaUid,
+                type: seeds.type,
+                modelFileId: seeds.modelFileId,
+                publisher: seeds.publisher,
+                attestationRaw: seeds.attestationRaw,
+                attestationCreatedAt: seeds.attestationCreatedAt,
+                revokedAt: seeds.revokedAt,
+            })
+                .from(seeds)
+                .where(inArray(seeds.uid, uids));
+            const out = [];
+            for (const row of rows) {
+                if (isRevokedLocally(row.revokedAt))
+                    continue;
+                const schemaName = await resolveSchemaNameForSeedType(appDb, row.type, row.modelFileId);
+                const att = seedRowToAttestation({ ...row, schemaName });
+                if (att)
+                    out.push(att);
+            }
+            return out;
+        },
+        async readStorageBody(ref) {
+            try {
+                if (ref.localPathHint) {
+                    const text = await BaseFileManager.readFileAsString(ref.localPathHint);
+                    if (text)
+                        return text;
+                }
+                // Common layout: html/{name}.html under filesDir
+                if (typeof ref.value === 'string') {
+                    const v = ref.value.trim();
+                    // Absolute or relative file path already on disk
+                    if (v.includes('/') && !v.startsWith('http')) {
+                        try {
+                            const text = await BaseFileManager.readFileAsString(v);
+                            if (text)
+                                return text;
+                        }
+                        catch {
+                            // try under html/
+                        }
+                    }
+                    const htmlPath = BaseFileManager.getFilesPath('html', v.endsWith('.html') ? v : `${v}.html`);
+                    try {
+                        const text = await BaseFileManager.readFileAsString(htmlPath);
+                        if (text)
+                            return text;
+                    }
+                    catch {
+                        // fall through
+                    }
+                }
+            }
+            catch {
+                return null;
+            }
+            return null;
+        },
+    };
+}
+
+let registered = false;
+/**
+ * Register the SDK SQLite/files adapter with `@seedprotocol/query`.
+ * Safe to call multiple times; re-registers with a fresh adapter instance.
+ * No-op when the app DB is not ready yet (unless `force`).
+ */
+function registerSeedQueryLocalSource(options) {
+    if (!options?.force && !BaseDb.isAppDbReady()) {
+        return false;
+    }
+    try {
+        registerLocalQuerySource(createLocalQueryDataSource());
+        registered = true;
+        return true;
+    }
+    catch (err) {
+        console.warn('[sdk/query] registerSeedQueryLocalSource failed:', err);
+        return false;
+    }
+}
+/** Unregister local query source (tests / client unload). */
+function unregisterSeedQueryLocalSource() {
+    clearLocalQuerySource();
+    registered = false;
+}
+function isSeedQueryLocalSourceRegistered() {
+    return registered;
+}
+/**
+ * Thin published-JSON helper: `getSeed` via the local (or auto) query source.
+ * Does not touch Item / drafts / liveQuery.
+ *
+ * Prefer this (or `@seedprotocol/query` `getSeed` / `queryBySchema`) for
+ * canonical published Seed JSON. Use `getItemData` / Item for draft-head authoring.
+ */
+async function getPublishedSeedRecord(seedUid, options) {
+    if (!registered) {
+        registerSeedQueryLocalSource();
+    }
+    const source = options?.source ?? 'local';
+    return getSeed(seedUid, { ...options, source });
+}
+
+const emptyResult$1 = () => ({
+    removedSeedLocalIds: [],
+    removedSeedUids: [],
+});
+function normalizeAddresses(addresses) {
+    return [
+        ...new Set(addresses
+            .filter((a) => typeof a === 'string' && a.length > 0)
+            .map((a) => a.toLowerCase())),
+    ];
+}
+/**
+ * Find local on-chain seed copies for the given publisher addresses (no delete).
+ * Drafts (no uid and no attestationRaw) are excluded.
+ */
+async function findLocalOnchainCopiesForAddresses(addresses) {
+    const normalized = normalizeAddresses(addresses);
+    if (normalized.length === 0) {
+        return emptyResult$1();
+    }
+    const appDb = BaseDb.getAppDb();
+    if (!appDb) {
+        return emptyResult$1();
+    }
+    const addressSet = new Set(normalized);
+    const candidateRows = (await appDb
+        .select({
+        localId: seeds.localId,
+        uid: seeds.uid,
+        publisher: seeds.publisher,
+        attestationRaw: seeds.attestationRaw,
+    })
+        .from(seeds)
+        .where(or(isNotNull(seeds.uid), isNotNull(seeds.attestationRaw))));
+    const matched = candidateRows.filter((row) => {
+        if (!row.localId)
+            return false;
+        const publisher = resolvePublisherFromSeedRow(row);
+        return publisher != null && addressSet.has(publisher.toLowerCase());
+    });
+    return {
+        removedSeedLocalIds: matched.map((r) => r.localId).filter(Boolean),
+        removedSeedUids: matched
+            .map((r) => r.uid)
+            .filter((u) => typeof u === 'string' && u.length > 0),
+    };
+}
+/**
+ * Hard-delete the given seed local ids and related local rows (cascade).
+ * Does not touch schemas, app_state, or chain.
+ */
+async function hardDeleteLocalSeedsByLocalIds(seedLocalIds) {
+    if (seedLocalIds.length === 0)
+        return;
+    const appDb = BaseDb.getAppDb();
+    if (!appDb)
+        return;
+    await appDb
+        .delete(htmlEmbeddedImageCoPublish)
+        .where(or(inArray(htmlEmbeddedImageCoPublish.parentSeedLocalId, seedLocalIds), inArray(htmlEmbeddedImageCoPublish.htmlSeedLocalId, seedLocalIds), inArray(htmlEmbeddedImageCoPublish.imageSeedLocalId, seedLocalIds)));
+    await appDb
+        .delete(arweaveL1FinalizeJobs)
+        .where(inArray(arweaveL1FinalizeJobs.seedLocalId, seedLocalIds));
+    await appDb
+        .delete(publishProcesses)
+        .where(inArray(publishProcesses.seedLocalId, seedLocalIds));
+    await appDb.delete(metadata$1).where(inArray(metadata$1.seedLocalId, seedLocalIds));
+    await appDb.delete(versions).where(inArray(versions.seedLocalId, seedLocalIds));
+    await appDb.delete(seeds).where(inArray(seeds.localId, seedLocalIds));
+}
+
+const emptyResult = () => ({
+    seeds: 0,
+    versions: 0,
+    metadata: 0,
+});
+/**
+ * Stamp local seeds/versions/metadata that have no publisher and no real uid.
+ * Does not touch sealed rows (real EAS uid or attestationRaw).
+ */
+async function claimUnpublishedDrafts(publisher) {
+    const normalized = normalizePublisher(publisher);
+    if (!normalized)
+        return emptyResult();
+    const appDb = BaseDb.getAppDb();
+    if (!appDb)
+        return emptyResult();
+    const now = Date.now();
+    const claimTable = async (table) => {
+        const rows = (await appDb
+            .select({
+            localId: table.localId,
+            uid: table.uid,
+            publisher: table.publisher,
+            attestationRaw: table.attestationRaw,
+        })
+            .from(table));
+        const ids = rows
+            .filter((row) => typeof row.localId === 'string' &&
+            row.localId !== '' &&
+            isLocalUnsealedDraft(row))
+            .map((row) => row.localId);
+        if (ids.length === 0)
+            return 0;
+        await appDb
+            .update(table)
+            .set({ publisher: normalized, updatedAt: now })
+            .where(inArray(table.localId, ids));
+        return ids.length;
+    };
+    const [seedCount, versionCount, metadataCount] = await Promise.all([
+        claimTable(seeds),
+        claimTable(versions),
+        claimTable(metadata$1),
+    ]);
+    return {
+        seeds: seedCount,
+        versions: versionCount,
+        metadata: metadataCount,
+    };
+}
+
+const logger = debug('seedSdk:client');
+const clientManager = createActor(clientManagerMachine, {
+    input: {
+        isInitialized: false,
+        addressesSet: false,
+        isSaving: false,
+        syncFromEasOnAddressChange: false,
+    }
+});
+const subscription = clientManager.subscribe((snapshot) => {
+    logger('ClientManager snapshot.value:', snapshot.value);
+    logger('ClientManager snapshot.context.isInitialized:', snapshot.context.isInitialized);
+});
+clientManager.start();
+const ensureInitialized = () => {
+    if (!clientManager.getSnapshot().context.isInitialized) {
+        throw new Error(CLIENT_NOT_INITIALIZED);
+    }
+};
+// Singleton instance - created once at module load time
+// ES modules cache exports, ensuring all imports get the same instance
+const clientInstance = {
+    isInitialized: () => {
+        return clientManager.getSnapshot().context.isInitialized;
+    },
+    getService: () => {
+        // ensureInitialized();
+        return clientManager;
+    },
+    init: createCoalescedAsync(async (options) => {
+        // If the actor is stopped (e.g., from a previous failed test), restart it
+        const snapshot = clientManager.getSnapshot();
+        const currentState = snapshot.value;
+        const isStopped = snapshot.status === 'stopped';
+        if (isStopped) {
+            logger('Client manager was stopped, restarting...');
+            clientManager.start();
+            // Wait for the actor to be ready
+            try {
+                await waitFor(clientManager, (snapshot) => snapshot.status !== 'stopped', { timeout: 1000 });
+            }
+            catch (e) {
+                logger('Timeout waiting for actor to restart, continuing anyway...');
+            }
+        }
+        // Clear any stale context from previous failed initializations
+        // This ensures we start with a clean slate before the new init updates it
+        if (currentState !== 'uninitialized') {
+            logger(`Client manager is in state ${currentState}, clearing stale context before re-init...`);
+            clientManager.send({
+                type: 'updateContext',
+                context: {
+                    isInitialized: false,
+                    addressesSet: false,
+                    isSaving: false,
+                    syncFromEasOnAddressChange: false,
+                    endpoints: undefined,
+                    addresses: undefined,
+                    ownedAddresses: undefined,
+                    watchedAddresses: undefined,
+                    models: undefined,
+                    arweaveDomain: undefined,
+                    filesDir: undefined,
+                    dbConfig: undefined,
+                    initError: undefined,
+                    saveError: undefined,
+                }
+            });
+            // Wait a moment for the context update to be processed
+            await new Promise(resolve => setTimeout(resolve, 10));
+        }
+        // Send init event - the root-level handler will transition to PLATFORM_CLASSES_INIT
+        // which will stop any running actors and start fresh with the new options
+        // The platformClassesInit actor will update the context with the correct endpoints from options
+        clientManager.send({ type: 'init', options });
+        // Wait for the state machine to transition to PLATFORM_CLASSES_INIT to ensure
+        // any old actors are stopped and the new initialization flow begins
+        try {
+            await waitFor(clientManager, (snapshot) => {
+                return snapshot.value === 'platformClassesInit' || snapshot.context.isInitialized;
+            }, { timeout: 1000 });
+        }
+        catch (e) {
+            // If we can't transition, continue anyway - the waitFor below will catch any errors
+            logger('Timeout waiting for state transition, continuing...');
+        }
+        try {
+            await waitFor(clientManager, (snapshot) => {
+                return snapshot.context.isInitialized || snapshot.context.initError != null;
+            }, { timeout: 120000 });
+            const initError = clientManager.getSnapshot().context.initError;
+            if (initError) {
+                throw initError instanceof Error ? initError : new Error(String(initError));
+            }
+        }
+        catch (error) {
+            // Ensure we never throw undefined
+            if (error === undefined || error === null) {
+                throw new Error('Initialization failed with undefined error');
+            }
+            throw error;
+        }
+        // Wire `@seedprotocol/query` local source once DB is ready
+        registerSeedQueryLocalSource({ force: true });
+    }, () => {
+        const snapshot = clientManager.getSnapshot();
+        return (snapshot.value === ClientManagerState.IDLE &&
+            snapshot.context.isInitialized === true &&
+            !snapshot.context.initError);
+    }),
+    setAddresses: async (addresses) => {
+        ensureInitialized();
+        logger('setAddresses', addresses);
+        clientManager.send({ type: 'setAddresses', addresses });
+        await waitFor(clientManager, (snapshot) => !snapshot.context.isSaving, { timeout: 10000 });
+        const saveError = clientManager.getSnapshot().context.saveError;
+        if (saveError) {
+            throw saveError instanceof Error ? saveError : new Error(String(saveError));
+        }
+        logger('setAddresses success', addresses);
+    },
+    getAddresses: async () => {
+        ensureInitialized();
+        const owned = await getOwnedAddressesFromDb();
+        const watched = await getWatchedAddressesFromDb();
+        return { owned, watched };
+    },
+    getOwnedAddresses: async () => {
+        ensureInitialized();
+        return getOwnedAddressesFromDb();
+    },
+    getWatchedAddresses: async () => {
+        ensureInitialized();
+        return getWatchedAddressesFromDb();
+    },
+    /**
+     * Stamp local seeds/versions/metadata that have no publisher and no real uid.
+     * Sealed rows (real EAS uid or attestationRaw) are left unchanged.
+     * Use after `setAddresses` on connect; `setPublishWallet` does this automatically.
+     */
+    claimUnpublishedDrafts: async (publisher) => {
+        ensureInitialized();
+        return claimUnpublishedDrafts(publisher);
+    },
+    /**
+     * Hard-delete local on-chain seed copies for the given publisher addresses.
+     * Drafts (no uid / attestationRaw) are kept. Chain is untouched; reconnect can rehydrate via syncFromEas.
+     */
+    removeLocalCopiesForAddresses: async (addresses) => {
+        ensureInitialized();
+        const list = Array.isArray(addresses) ? addresses : [];
+        const matched = await findLocalOnchainCopiesForAddresses(list);
+        const cacheIds = [
+            ...matched.removedSeedLocalIds,
+            ...matched.removedSeedUids,
+        ];
+        if (cacheIds.length > 0) {
+            Item.dropCachedInstancesForSeedIds(cacheIds);
+        }
+        await hardDeleteLocalSeedsByLocalIds(matched.removedSeedLocalIds);
+        // Other tabs drop their cached instances of the removed seeds too.
+        emitAcrossTabs(LOCAL_COPIES_REMOVED_EVENT, {
+            addresses: list,
+            removedSeedLocalIds: matched.removedSeedLocalIds,
+            removedSeedUids: matched.removedSeedUids,
+        });
+        return matched;
+    },
+    /**
+     * Syncs item attestations from EAS for the configured models and given addresses.
+     * Uses owned + watched addresses from DB when addresses are not provided.
+     */
+    syncFromEas: async (options) => {
+        ensureInitialized();
+        startEasSyncActor();
+        const correlationId = typeof globalThis.crypto?.randomUUID === 'function'
+            ? globalThis.crypto.randomUUID()
+            : `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        sendEasSyncClientRequest(correlationId, options);
+        await waitFor(easSyncActor, (snapshot) => snapshot.context.lastFinishedCorrelationIds?.includes(correlationId) ?? false);
+        const snap = easSyncActor.getSnapshot();
+        if (snap.context.lastFinishedStatus === 'failed') {
+            throw new Error(snap.context.lastFinishedError ?? 'EAS sync failed');
+        }
+    },
+    addModel: async (modelDef) => {
+        const db = await BaseDb.getAppDb();
+        const existingModels = await db.select().from(models$1).where(eq(models$1.name, modelDef.name));
+        if (existingModels.length > 0) {
+            return;
+        }
+        await db.insert(models$1).values({
+            name: modelDef.name
+        });
+        // Global service removed - model registration is now handled by ClientManager
+        // Models are added to DB during the ADD_MODELS_TO_DB state
+    },
+    onReady: (callback) => {
+        const subscription = clientManager.subscribe((snapshot) => {
+            if (snapshot.context.isInitialized) {
+                subscription.unsubscribe();
+                callback();
+            }
+        });
+    },
+    stop: () => {
+        ensureInitialized();
+        unregisterSeedQueryLocalSource();
+        clientManager.stop();
+    },
+    unload: () => {
+        ensureInitialized();
+        unregisterSeedQueryLocalSource();
+        clientManager.stop();
+        subscription.unsubscribe();
+    },
+};
+// Export the singleton instance
+// This ensures all imports across different files get the same instance
+const ClientManager = clientInstance;
+const getClient = () => {
+    return clientInstance;
+};
+
+var ClientManager$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ClientManager: ClientManager,
+    clientManager: clientManager,
+    getClient: getClient
+});
+
+export { startEasSyncActor as A, unregisterSeedQueryLocalSource as B, ClientManager as C, createModelsFromJson as D, EAS_CHAIN_ID_APP_STATE_KEY as E, getLatestSchemaVersion as F, schema as G, ClientManager$1 as H, SEEDPROTOCOL_Seed_Protocol_v1 as S, assertLocalDbChain as a, getRefValueType as b, claimUnpublishedDrafts as c, createLocalQueryDataSource as d, createSchema as e, easSyncActor as f, getContentHash as g, getClient as h, importJsonSchema as i, getPublishedSeedRecord as j, getSchemaNameFromId as k, loadSchemaFromFile as l, isSeedQueryLocalSourceRegistered as m, listCompleteSchemaFiles as n, loadAllSchemasFromDb as o, mergeEasSyncRequestIntents as p, readSchema as q, readJsonImportFile as r, syncSchemaFromSource as s, transformImportToSchemaFile as t, registerSeedQueryLocalSource as u, requestEasSyncFromAddressChange as v, waitForEasReadChain as w, requestEasSyncFromEventBus as x, requestEasSyncFromModelsInit as y, sendEasSyncClientRequest as z };
+//# sourceMappingURL=ClientManager-DngaZdw6.js.map