@seedprotocol/sdk 0.7.9-next.1189.g5e63267 → 0.7.9

package/dist/index-rOTW-2QZ.js

@@ -1,4760 +0,0 @@
-import debug from 'debug';
-import { isEasAttestationExplorerUrl, BaseArweaveClient, ensureReadGatewaySelected, getArweaveReadBaseUrls, getTransactionTagsByIds } from '@seedprotocol/arweave';
-import { VERSION_SCHEMA_UID, easName, DEFAULT_NAME_MATCH_LEVEL, compareNameMatchTiers, isNameMatchLevel, localNamesInBestMatchTier, BaseQueryClient, BaseEasClient, GET_FILES_METADATA } from '@seedprotocol/eas';
-import { waitFor } from 'xstate';
-import pluralize from 'pluralize';
-import { Type } from '@sinclair/typebox';
-import { sqliteTable, integer, text, unique, int, index, blob, uniqueIndex } from 'drizzle-orm/sqlite-core';
-import { relations, and, eq, inArray, desc, isNull, isNotNull, or } from 'drizzle-orm';
-import { customAlphabet } from 'nanoid';
-import { alphanumeric } from 'nanoid-dictionary';
-import { sha256 } from '@noble/hashes/sha256';
-import { sha3_256 } from '@noble/hashes/sha3';
-import { bytesToHex } from '@noble/hashes/utils';
-import { throttle } from 'lodash-es';
-
-const logger$5 = debug('seedSdk:browser:db:sqliteBusyRetry');
-/** Waits between attempts; about 1 s in total. */
-const SQLITE_BUSY_RETRY_DELAYS_MS = [25, 75, 150, 300, 450];
-/**
- * Another connection (usually another tab) holds the database lock. SQLite reports this as
- * SQLITE_BUSY ("database is locked") or SQLITE_LOCKED ("database table is locked").
- */
-function isSqliteBusyError(error) {
-    // Drizzle wraps a driver's error ("Failed query: ...") and keeps it as `cause`
-    for (let current = error, depth = 0; current != null && depth < 5; depth++) {
-        const message = current instanceof Error ? current.message : String(current);
-        if (/SQLITE_BUSY|SQLITE_LOCKED|database (table )?is locked/i.test(message))
-            return true;
-        current = current.cause;
-    }
-    return false;
-}
-/**
- * Retries a statement another tab's lock rejected. Safe for the SDK's writes because each is a
- * single autocommit statement: one that failed with SQLITE_BUSY didn't apply. Don't use this for
- * statements inside a transaction, where a retry would replay part of it.
- */
-function withSqliteBusyRetry(driver, delaysMs = SQLITE_BUSY_RETRY_DELAYS_MS) {
-    return async (...args) => {
-        for (let attempt = 0;; attempt++) {
-            try {
-                return await driver(...args);
-            }
-            catch (error) {
-                if (!isSqliteBusyError(error) || attempt >= delaysMs.length)
-                    throw error;
-                logger$5(`database busy (attempt ${attempt + 1}); retrying`);
-                await new Promise((resolve) => setTimeout(resolve, delaysMs[attempt]));
-            }
-        }
-    };
-}
-
-class BaseDb {
-    static configure(impl) {
-        if (!impl) {
-            throw new Error('Cannot configure Db with undefined or null. Ensure the platform-specific Db is properly created.');
-        }
-        BaseDb._impl = impl;
-    }
-    static requireImpl() {
-        if (!BaseDb._impl) {
-            throw new Error('Db not configured. Call BaseDb.configure() during platform init.');
-        }
-        return BaseDb._impl;
-    }
-    static getAppDb() {
-        return BaseDb.requireImpl().getAppDb();
-    }
-    static prepareDb(filesDir, config) {
-        return BaseDb.requireImpl().prepareDb(filesDir, config);
-    }
-    static isAppDbReady() {
-        if (!BaseDb._impl) {
-            return false;
-        }
-        return BaseDb._impl.isAppDbReady();
-    }
-    static connectToDb(pathToDir) {
-        return BaseDb.requireImpl().connectToDb(pathToDir);
-    }
-    static async migrate(pathToDbDir, dbName, dbId) {
-        return BaseDb.requireImpl().migrate(pathToDbDir, dbName, dbId);
-    }
-    /**
-     * Execute a reactive query that emits new results whenever the underlying data changes.
-     *
-     * Supports two usage patterns:
-     * 1. SQL tag function (browser only): liveQuery((sql) => sql`SELECT * FROM models`)
-     * 2. Drizzle query builder: liveQuery(db.select().from(models))
-     *
-     * On Node only the query builder works (a tag function throws), and it is re-run every second;
-     * the observable emits when the result changes.
-     */
-    static liveQuery(query) {
-        return BaseDb.requireImpl().liveQuery(query);
-    }
-    /**
-     * Runs `fn` in one transaction: every query it runs on `tx` (a Drizzle database, used like
-     * `getAppDb()`) commits together, or none does when `fn` throws. Queries on `getAppDb()` inside
-     * `fn` are not part of the transaction, and in the browser they wait for it to end, so don't
-     * call `getAppDb()` or `BaseDb.transaction` from `fn`.
-     *
-     * When another connection (another tab) holds the database lock, the whole transaction is
-     * retried, so `fn` must have no side effects outside `tx`.
-     */
-    static async transaction(fn) {
-        const impl = BaseDb.requireImpl();
-        for (let attempt = 0;; attempt++) {
-            try {
-                return await impl.transaction(fn);
-            }
-            catch (error) {
-                if (!isSqliteBusyError(error) || attempt >= SQLITE_BUSY_RETRY_DELAYS_MS.length)
-                    throw error;
-                await new Promise((resolve) => setTimeout(resolve, SQLITE_BUSY_RETRY_DELAYS_MS[attempt]));
-            }
-        }
-    }
-}
-BaseDb._impl = null;
-
-var BaseDb$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    BaseDb: BaseDb
-});
-
-const models = sqliteTable('models', {
-    id: integer('id').primaryKey({ autoIncrement: true }),
-    name: text('name').notNull(),
-    schemaFileId: text('schema_file_id'), // ID from JSON file for change tracking - must be unique
-    isEdited: integer('is_edited', { mode: 'boolean' }), // true if model has been edited locally, false if matches schema file
-}, (table) => {
-    return {
-        uniqueSchemaFileId: unique('unique_schema_file_id').on(table.schemaFileId),
-    };
-});
-const modelsRelations = relations(models, ({ many }) => ({
-    properties: many(properties),
-}));
-const properties = sqliteTable('properties', {
-    id: integer('id').primaryKey({ autoIncrement: true }),
-    name: text('name').notNull(),
-    dataType: text('data_type').notNull(),
-    modelId: integer('model_id')
-        .notNull()
-        .references(() => models.id),
-    refModelId: integer('ref_model_id').references(() => models.id),
-    refValueType: text('ref_value_type'),
-    schemaFileId: text('schema_file_id'), // ID from JSON file for change tracking
-    isEdited: integer('is_edited', { mode: 'boolean' }), // true if property has been edited locally, false if matches schema file
-    required: integer('required', { mode: 'boolean' }), // true if relation/image property is required (publish fails when related item not found)
-    // Storage settings from the schema file's `storage: { type, path, extension }`, in the internal
-    // shape ModelProperty uses. Null when the property has no storage config.
-    storageType: text('storage_type'), // 'ItemStorage' | 'PropertyStorage'
-    localStorageDir: text('local_storage_dir'), // storage.path, e.g. '/html'
-    filenameSuffix: text('filename_suffix'), // storage.extension, e.g. '.html'
-}, (table) => {
-    return {
-        uniqueNameModelId: unique('unique_name_model_id').on(table.name, table.modelId),
-        uniqueSchemaFileId: unique('unique_property_schema_file_id').on(table.schemaFileId),
-    };
-});
-const propertiesRelations = relations(properties, ({ one }) => ({
-    model: one(models),
-    refModel: one(models),
-}));
-
-var ModelSchema = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    models: models,
-    modelsRelations: modelsRelations,
-    properties: properties,
-    propertiesRelations: propertiesRelations
-});
-
-class BaseFileManager {
-    static configure(impl) {
-        if (!impl) {
-            throw new Error('Cannot configure FileManager with undefined or null. Ensure the platform-specific FileManager is properly created.');
-        }
-        BaseFileManager._impl = impl;
-    }
-    static requireImpl() {
-        if (!BaseFileManager._impl) {
-            throw new Error('FileManager not configured. Call BaseFileManager.configure() during platform init.');
-        }
-        return BaseFileManager._impl;
-    }
-    /**
-     * Clears FS init flags so a later call can retry. Used after a failed init
-     * and by tests. Does not unmount or delete any files.
-     */
-    static resetInitializationState() {
-        this.fileSystemInitialized = false;
-        this.initializing = false;
-        this.initializePromise = null;
-        this.workingDir = undefined;
-    }
-    static initializeFileSystem(workingDir) {
-        if (this.fileSystemInitialized) {
-            return Promise.resolve();
-        }
-        if (this.initializePromise) {
-            return this.initializePromise;
-        }
-        this.initializing = true;
-        const pending = this.runInitializeFileSystem(workingDir).finally(() => {
-            this.initializing = false;
-            if (this.initializePromise === pending) {
-                this.initializePromise = null;
-            }
-        });
-        this.initializePromise = pending;
-        return pending;
-    }
-    static async runInitializeFileSystem(workingDir) {
-        await BaseFileManager.requireImpl().initializeFileSystem(workingDir);
-        this.fileSystemInitialized = true;
-        this.workingDir = workingDir;
-    }
-    static getWorkingDir() {
-        if (!this.workingDir) {
-            throw new Error('Working directory is not set');
-        }
-        return this.workingDir;
-    }
-    /**
-     * Build a path under the configured files root (e.g. /app-files).
-     * Use this instead of hardcoding /files/ for images, html, json, etc.
-     * @param subpaths - path segments to join (e.g. 'images', fileName)
-     * @returns full path like /app-files/images/egg.jpg
-     */
-    static getFilesPath(...subpaths) {
-        const root = this.getWorkingDir().replace(/\/$/, '');
-        const parts = [root, ...subpaths].filter(Boolean);
-        return parts.join('/').replace(/\/+/g, '/');
-    }
-    static getContentUrlFromPath(path) {
-        return BaseFileManager.requireImpl().getContentUrlFromPath(path);
-    }
-    static downloadAllFiles(params) {
-        return BaseFileManager.requireImpl().downloadAllFiles(params);
-    }
-    static downloadFileByTransactionId({ transactionId, arweaveHost, arweaveBaseUrls, excludedTransactions, expectedContentHash, compositeChildPaths, skipExisting, }) {
-        return BaseFileManager.requireImpl().downloadAllFiles({
-            transactionIds: [transactionId],
-            arweaveHost,
-            arweaveBaseUrls,
-            excludedTransactions,
-            expectedContentHashes: expectedContentHash ? { [transactionId]: expectedContentHash } : undefined,
-            compositeChildPaths: compositeChildPaths ? { [transactionId]: compositeChildPaths } : undefined,
-            skipExisting,
-        });
-    }
-    static resizeImage({ filePath, width, height }) {
-        return BaseFileManager.requireImpl().resizeImage({ filePath, width, height });
-    }
-    static resizeAllImages({ width, height }) {
-        return BaseFileManager.requireImpl().resizeAllImages({ width, height });
-    }
-    static pathExists(filePath) {
-        return BaseFileManager.requireImpl().pathExists(filePath);
-    }
-    static invalidateCachedPaths(filePaths) {
-        return BaseFileManager.requireImpl().invalidateCachedPaths(filePaths);
-    }
-    /** File size in bytes, or null if the path does not exist / cannot be stated. */
-    static getFileSize(filePath) {
-        return BaseFileManager.requireImpl().getFileSize(filePath);
-    }
-    /**
-     * Returns a list of filenames in the given directory (e.g. 'images', 'files').
-     */
-    static listFiles(dir) {
-        return BaseFileManager.requireImpl().listFiles(dir);
-    }
-    /**
-     * Returns a list of image filenames in the images folder (originals only, excludes size subdirs).
-     * Use this to get all stored images without traversing 480/760/1024/1440/1920 subdirectories.
-     */
-    static listImageFiles() {
-        return this.listFiles('images');
-    }
-    static createDirIfNotExists(filePath) {
-        return BaseFileManager.requireImpl().createDirIfNotExists(filePath);
-    }
-    static async waitForFile(filePath) {
-        return BaseFileManager.requireImpl().waitForFile(filePath);
-    }
-    static async waitForFileWithContent(filePath, interval, timeout) {
-        return BaseFileManager.requireImpl().waitForFileWithContent(filePath, interval, timeout);
-    }
-    static async saveFile(filePath, content) {
-        return BaseFileManager.requireImpl().saveFile(filePath, content);
-    }
-    static saveFileSync(filePath, content) {
-        return BaseFileManager.requireImpl().saveFileSync(filePath, content);
-    }
-    static async readFile(filePath) {
-        return BaseFileManager.requireImpl().readFile(filePath);
-    }
-    static readFileSync(filePath) {
-        return BaseFileManager.requireImpl().readFileSync(filePath);
-    }
-    static async readFileAsBuffer(filePath) {
-        return BaseFileManager.requireImpl().readFileAsBuffer(filePath);
-    }
-    static async readFileAsString(filePath) {
-        return BaseFileManager.requireImpl().readFileAsString(filePath);
-    }
-    static async getFs() {
-        return BaseFileManager.requireImpl().getFs();
-    }
-    static getFsSync() {
-        return BaseFileManager.requireImpl().getFsSync();
-    }
-    static getPathModule() {
-        return BaseFileManager.requireImpl().getPathModule();
-    }
-    static getParentDirPath(filePath) {
-        return BaseFileManager.requireImpl().getParentDirPath(filePath);
-    }
-    static getFilenameFromPath(filePath) {
-        return BaseFileManager.requireImpl().getFilenameFromPath(filePath);
-    }
-}
-BaseFileManager.fileSystemInitialized = false;
-BaseFileManager.initializing = false;
-BaseFileManager._impl = null;
-BaseFileManager.initializePromise = null;
-
-var BaseFileManager$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    BaseFileManager: BaseFileManager
-});
-
-/** Default maximum length for Text properties when not explicitly set. Html holds arbitrary-length content and does not use this limit. */
-const DEFAULT_TEXT_MAX_LENGTH = 255;
-/**
- * TypeBox schema for ValidationRules
- */
-const TValidationRules = Type.Object({
-    pattern: Type.Optional(Type.String()),
-    minLength: Type.Optional(Type.Integer({ minimum: 0 })),
-    maxLength: Type.Optional(Type.Integer({ minimum: 1 })),
-    enum: Type.Optional(Type.Array(Type.Any())),
-    custom: Type.Optional(Type.String()),
-}, { additionalProperties: true });
-
-/**
- * Enum for all property data types
- */
-var ModelPropertyDataTypes;
-(function (ModelPropertyDataTypes) {
-    ModelPropertyDataTypes["Text"] = "Text";
-    ModelPropertyDataTypes["Number"] = "Number";
-    ModelPropertyDataTypes["List"] = "List";
-    ModelPropertyDataTypes["Relation"] = "Relation";
-    ModelPropertyDataTypes["Image"] = "Image";
-    ModelPropertyDataTypes["Json"] = "Json";
-    ModelPropertyDataTypes["File"] = "File";
-    ModelPropertyDataTypes["Boolean"] = "Boolean";
-    ModelPropertyDataTypes["Date"] = "Date";
-    ModelPropertyDataTypes["Html"] = "Html";
-})(ModelPropertyDataTypes || (ModelPropertyDataTypes = {}));
-/** Known data types in lowercase for normalization */
-const DATA_TYPE_LOWER_MAP = {
-    text: 'Text',
-    string: 'Text', // JSON Schema convention
-    number: 'Number',
-    list: 'List',
-    relation: 'Relation',
-    image: 'Image',
-    json: 'Json',
-    file: 'File',
-    boolean: 'Boolean',
-    date: 'Date',
-    html: 'Html',
-    blob: 'Blob',
-};
-/**
- * Normalize dataType to canonical PascalCase form.
- * Accepts lowercase (e.g. 'text') or mixed case and returns 'Text'.
- * Use when ingesting dataType from JSON schema files.
- */
-function normalizeDataType(value) {
-    if (!value || typeof value !== 'string')
-        return value ?? '';
-    const lower = value.toLowerCase().trim();
-    return DATA_TYPE_LOWER_MAP[lower] ?? value.charAt(0).toUpperCase() + value.slice(1).toLowerCase();
-}
-/**
- * Case-insensitive dataType check. Use instead of `dataType === 'List'` so schemas
- * (or existing DB rows) with lowercase types like "list" still match.
- */
-function isDataType(value, expected) {
-    if (!value)
-        return false;
-    return normalizeDataType(value) === expected;
-}
-/**
- * Normalize a property definition to the internal shape ItemProperty reads (`dataType`,
- * `refValueType`, `ref`, `storageType`, ...). Accepts schema-file shape (`type`, `model`,
- * `items`, `storage`) and any casing. Mirrors the conversion in imports/json createModelFromJson
- * for the fallback paths that read schema-file properties directly.
- */
-function normalizePropertyRecordSchema(def) {
-    if (!def || typeof def !== 'object')
-        return def;
-    const src = def;
-    const out = { ...src };
-    const rawType = src.dataType ?? src.type;
-    if (typeof rawType === 'string' && rawType)
-        out.dataType = normalizeDataType(rawType);
-    const ref = src.ref ?? src.refModelName ?? src.items?.model ?? src.model;
-    if (ref && !out.ref)
-        out.ref = ref;
-    if (ref && !out.refModelName)
-        out.refModelName = ref;
-    const rawRefValueType = src.refValueType ?? src.items?.type;
-    if (typeof rawRefValueType === 'string' && rawRefValueType) {
-        out.refValueType = normalizeDataType(rawRefValueType);
-    }
-    else if (out.dataType === ModelPropertyDataTypes.List && ref) {
-        out.refValueType = ModelPropertyDataTypes.Relation;
-    }
-    if (src.storage && typeof src.storage === 'object' && !out.storageType) {
-        out.storageType = src.storage.type === 'ItemStorage' ? 'ItemStorage' : 'PropertyStorage';
-        if (src.storage.path !== undefined && out.localStorageDir === undefined)
-            out.localStorageDir = src.storage.path;
-        if (src.storage.extension !== undefined && out.filenameSuffix === undefined)
-            out.filenameSuffix = src.storage.extension;
-    }
-    return out;
-}
-// String literals, not enum members: PropertyDataType must accept plain strings
-// such as `{ dataType: 'Text' }`. ModelPropertyDataTypes members still fit.
-const TPropertyDataType = Type.Union([
-    Type.Literal('Text'),
-    Type.Literal('Number'),
-    Type.Literal('List'),
-    Type.Literal('Relation'),
-    Type.Literal('Image'),
-    Type.Literal('Json'),
-    Type.Literal('File'),
-    Type.Literal('Boolean'),
-    Type.Literal('Date'),
-    Type.Literal('Html'),
-]);
-const TStorageType = Type.Union([
-    Type.Literal('ItemStorage'), // Looks for a storageTransactionId property on the item
-    Type.Literal('PropertyStorage'), // Looks for a storageTransactionId value on the property
-]);
-/** How publish handles `data:image/*` URIs inside Html storage. Only applies when `dataType === 'Html'`. */
-const THtmlEmbeddedDataUriPolicy = Type.Union([
-    Type.Literal('materialize'),
-    Type.Literal('preserve'),
-]);
-const TProperty = Type.Object({
-    id: Type.Optional(Type.String()), // schemaFileId (string) - public ID
-    _dbId: Type.Optional(Type.Number()), // Database integer ID - internal only
-    name: Type.Optional(Type.String()),
-    dataType: TPropertyDataType,
-    ref: Type.Optional(Type.String()),
-    // modelId: string (modelFileId) in code; number only for DB foreign keys when resolved
-    modelId: Type.Optional(Type.Union([Type.Number(), Type.String()])),
-    modelName: Type.Optional(Type.String()),
-    refModelId: Type.Optional(Type.Number()),
-    refModelName: Type.Optional(Type.String()),
-    refValueType: Type.Optional(TPropertyDataType),
-    storageType: Type.Optional(TStorageType),
-    localStorageDir: Type.Optional(Type.String()),
-    filenameSuffix: Type.Optional(Type.String()),
-    validation: Type.Optional(TValidationRules),
-    required: Type.Optional(Type.Boolean()),
-    /** When set on an Html property: `materialize` uploads embedded images as Image seeds and rewrites src; `preserve` leaves data URIs. */
-    htmlEmbeddedDataUriPolicy: Type.Optional(THtmlEmbeddedDataUriPolicy),
-});
-const TPropertyConstructor = Type.Function([
-    Type.Optional(Type.Union([Type.String(), TStorageType, Type.Undefined()])),
-    Type.Optional(Type.Union([Type.String(), TPropertyDataType])),
-    Type.Optional(Type.Union([Type.String(), Type.Boolean()])),
-], TProperty);
-const TPropertyDefs = Type.Record(TPropertyDataType, TPropertyConstructor);
-function htmlPropertyFactory(opts) {
-    return {
-        dataType: ModelPropertyDataTypes.Html,
-        ...(opts?.htmlEmbeddedDataUriPolicy
-            ? { htmlEmbeddedDataUriPolicy: opts.htmlEmbeddedDataUriPolicy }
-            : {}),
-    };
-}
-const Property = {
-    Text: (storageType, localStorageDir, filenameSuffix) => ({
-        dataType: ModelPropertyDataTypes.Text,
-        storageType,
-        localStorageDir,
-        filenameSuffix,
-        TObject: Type.String(),
-    }),
-    Json: () => ({ dataType: ModelPropertyDataTypes.Json }),
-    File: () => ({ dataType: ModelPropertyDataTypes.File }),
-    Number: () => ({ dataType: ModelPropertyDataTypes.Number }),
-    /**
-     * Create a List property. refValueType is required; ref is required only for list of relations.
-     * @param refValueType - Element type: 'Text', 'Number', 'Relation', etc.
-     * @param ref - Model name when refValueType is 'Relation' (optional for primitives)
-     * @example List('Text') - list of strings
-     * @example List('Relation', 'Tag') - list of relations to Tag model
-     */
-    List: (refValueType, ref) => ({
-        dataType: ModelPropertyDataTypes.List,
-        ref,
-        refValueType,
-    }),
-    Relation: (ref, refValueType, required) => ({
-        dataType: ModelPropertyDataTypes.Relation,
-        ref,
-        refValueType,
-        required,
-    }),
-    Image: () => ({ dataType: ModelPropertyDataTypes.Image }),
-    Boolean: () => ({ dataType: ModelPropertyDataTypes.Boolean }),
-    Date: () => ({ dataType: ModelPropertyDataTypes.Date }),
-    Html: htmlPropertyFactory,
-    /** `Html` opts are not representable in `TPropertyConstructor`; keep runtime shape via double assert. */
-};
-
-// Define zero constants ourselves since they're not exported from eas-sdk in newer versions
-const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
-const ZERO_BYTES = '0x';
-const ZERO_BYTES32 = '0x0000000000000000000000000000000000000000000000000000000000000000';
-const INTERNAL_DATA_TYPES = {
-    Text: {
-        eas: 'string',
-    },
-    // ADR 0010: decimal strings, so negatives, fractions and values above 255 publish.
-    Number: {
-        eas: 'string',
-    },
-    Image: {
-        eas: 'bytes32',
-    },
-    Relation: {
-        eas: 'bytes32',
-    },
-    List: {
-        eas: 'bytes32[]',
-    },
-    File: {
-        eas: 'bytes32',
-    },
-    Json: {
-        eas: 'bytes32',
-    },
-    Blob: {
-        eas: 'bytes32',
-    },
-    Boolean: {
-        eas: 'bool',
-    },
-    Date: {
-        eas: 'uint256',
-    },
-    Html: {
-        eas: 'bytes32',
-    },
-};
-/** Full property names ending in `Id` that must not be stripped to a “base” name for `allProperties` keys. */
-const PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP = new Set(['storageTransactionId']);
-const INTERNAL_PROPERTY_NAMES = [
-    'localId',
-    'uid',
-    'seedLocalId',
-    'seedUid',
-    'schemaUid',
-    'attestationCreatedAt',
-    'attestationRaw',
-    'createdAt',
-    'updatedAt',
-    'lastVersionPublishedAt',
-    'latestVersionLocalId',
-    'latestVersionUid',
-    'lastLocalUpdateAt',
-    'modelName',
-    'refSeedType',
-    'refValueType',
-    'refResolvedValue',
-    'refResolvedDisplayValue',
-    'type',
-    // Image
-    'src',
-    'alt',
-    //
-    'versionLocalId',
-    'versionsCount',
-    'versionUid',
-    '_markedForDeletion',
-    // SDK-internal: wallet address of attester; never publish as property attestation
-    'publisher',
-    // SDK-internal: Unix timestamp when attestations were revoked; never a schema field
-    'revokedAt',
-];
-/** @deprecated The UID is chain-independent. Use {@link VERSION_SCHEMA_UID}. */
-const VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA = VERSION_SCHEMA_UID;
-const defaultAttestationData = {
-    recipient: ZERO_ADDRESS,
-    revocable: true,
-    value: BigInt(0),
-    refUID: ZERO_BYTES32,
-    expirationTime: BigInt(0),
-    data: ZERO_BYTES,
-};
-var ImageSize;
-(function (ImageSize) {
-    ImageSize[ImageSize["EXTRA_SMALL"] = 480] = "EXTRA_SMALL";
-    ImageSize[ImageSize["SMALL"] = 760] = "SMALL";
-    ImageSize[ImageSize["MEDIUM"] = 1024] = "MEDIUM";
-    ImageSize[ImageSize["LARGE"] = 1440] = "LARGE";
-    ImageSize[ImageSize["EXTRA_LARGE"] = 1920] = "EXTRA_LARGE";
-})(ImageSize || (ImageSize = {}));
-const CLIENT_NOT_INITIALIZED = 'ClientManager is not initialized. Please call init() first.';
-var SeedModels;
-(function (SeedModels) {
-    SeedModels["Seed"] = "Seed";
-    SeedModels["Metadata"] = "Metadata";
-    SeedModels["Version"] = "Version";
-})(SeedModels || (SeedModels = {}));
-// Internal SDK schema that should not be created in app's files directory
-const SEED_PROTOCOL_SCHEMA_NAME = 'Seed Protocol';
-const INTERNAL_SCHEMA_IDS = ['SEEDPROTOCOL'];
-/** Fired after `syncDbWithEas` persists EAS seeds/versions/metadata to SQLite (see `Item.rehydrateCachedItemsFromDbAfterEasSync`). */
-const EAS_SEED_DATA_SYNCED_TO_DB_EVENT = 'easSeedDataSyncedToDb';
-/**
- * Check if a schema is an internal SDK schema that should not be created in app files
- */
-function isInternalSchema(schemaName, schemaId) {
-    return schemaName === SEED_PROTOCOL_SCHEMA_NAME ||
-        (schemaId !== undefined && INTERNAL_SCHEMA_IDS.includes(schemaId));
-}
-/**
- * Model ids (schemaFileId) of the internal Seed Protocol storage models. Storage seeds are always
- * these models, even if a user schema also defines a model named Image/File/Html.
- */
-const INTERNAL_STORAGE_MODEL_FILE_IDS = {
-    image: 'SEEDPROTOCOL_IMAGE',
-    file: 'SEEDPROTOCOL_FILE',
-    html: 'SEEDPROTOCOL_HTML',
-};
-
-/** Ref model name when propDef is a List of Relation, else undefined. */
-function listRelationRef(propDef) {
-    if (!propDef)
-        return undefined;
-    if (normalizeDataType(propDef.dataType) !== 'List')
-        return undefined;
-    return propDef.ref || propDef.refModelName || undefined;
-}
-/**
- * Storage/EAS name for a List-of-relation property (`authorIdentityIds`), given either its
- * schema key (`authors`) or its storage name. A name already in storage form is returned as-is,
- * so this is safe on ItemProperties built before their schema was known.
- * Returns undefined when propDef is not a List of Relation.
- */
-function listRelationEasPropertyName(propertyName, propDef) {
-    const ref = listRelationRef(propDef);
-    if (!ref || !propertyName)
-        return undefined;
-    if (propertyName.endsWith(`${ref}Ids`))
-        return propertyName;
-    return `${pluralize(propertyName, 1)}${ref}Ids`;
-}
-/**
- * For a schema property key like `authors` (List of Relation to Identity), returns the
- * internal storage/EAS name: `authorIdentityIds` (singular + ref + Ids).
- */
-function listRelationStoragePropertyName(propertySchemas, schemaPropertyKey) {
-    return listRelationEasPropertyName(schemaPropertyKey, propertySchemas[schemaPropertyKey]);
-}
-/**
- * Reverse of listRelationStoragePropertyName: maps DB/EAS name `authorIdentityIds` to schema key `authors`.
- */
-function resolveStorageNameToSchemaName(propertySchemas, storagePropertyName) {
-    for (const [schemaKey, propDef] of Object.entries(propertySchemas)) {
-        if (normalizeDataType(propDef?.dataType) !== 'List')
-            continue;
-        const ref = propDef.ref || propDef.refModelName;
-        if (!ref)
-            continue;
-        const internalName = `${pluralize(schemaKey, 1)}${ref}Ids`;
-        if (internalName === storagePropertyName) {
-            return schemaKey;
-        }
-    }
-    return undefined;
-}
-/** Internal property names that never use Id-suffix metadata convention */
-const ID_SUFFIX_EXCLUDE = new Set(['storageTransactionId', 'transactionId']);
-/** Data types that store metadata with Id suffix in DB */
-const METADATA_ID_SUFFIX_TYPES = ['Image', 'File', 'Html', 'Relation'];
-/**
- * Whether this type uses Id suffix in metadata table.
- */
-function needsMetadataIdSuffix(dataType, refValueType) {
-    const dt = normalizeDataType(dataType);
-    const rvt = normalizeDataType(refValueType);
-    return (METADATA_ID_SUFFIX_TYPES.includes(dt) ||
-        METADATA_ID_SUFFIX_TYPES.includes(rvt));
-}
-/**
- * Canonical metadata property name for WRITES.
- * Use when creating/updating metadata.
- */
-function toMetadataPropertyName(propertyName, dataType, refValueType) {
-    if (ID_SUFFIX_EXCLUDE.has(propertyName))
-        return propertyName;
-    if (propertyName.endsWith('Ids'))
-        return propertyName;
-    if (propertyName.endsWith('Id'))
-        return propertyName;
-    if (needsMetadataIdSuffix(dataType, refValueType)) {
-        return `${propertyName}Id`;
-    }
-    return propertyName;
-}
-/**
- * For READS: property names to include in OR query (both variants).
- * When dataType is undefined, includes all variants for safety (backwards compat with getPropertyData).
- */
-function getMetadataPropertyNamesForQuery(propertyName, dataType, refValueType) {
-    if (ID_SUFFIX_EXCLUDE.has(propertyName))
-        return [propertyName];
-    if (propertyName.endsWith('Ids'))
-        return [propertyName];
-    if (propertyName.endsWith('Id')) {
-        const base = propertyName.slice(0, -2);
-        return [propertyName, base];
-    }
-    const needsId = needsMetadataIdSuffix(dataType, refValueType) ||
-        (dataType === undefined && refValueType === undefined);
-    if (needsId) {
-        return [propertyName, `${propertyName}Id`, `${propertyName}Ids`];
-    }
-    return [propertyName];
-}
-/**
- * The name an item exposes a property under, from the name it is stored under: its alias when it
- * has one (List of relation), else `tagIds` → `tags`, `authorId` → `author`. Names in
- * PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP keep their `Id`.
- */
-function toItemPropertyKey(storedName, alias) {
-    if (alias)
-        return alias;
-    if (storedName.endsWith('Ids'))
-        return pluralize(storedName.slice(0, -3));
-    if (storedName.endsWith('Id') && !PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP.has(storedName)) {
-        return storedName.slice(0, -2);
-    }
-    return storedName;
-}
-/**
- * Schema property name from metadata name (strip Id/Ids suffix).
- */
-function toSchemaPropertyName(propertyName) {
-    if (propertyName.endsWith('Ids'))
-        return propertyName.slice(0, -3);
-    if (propertyName.endsWith('Id'))
-        return propertyName.slice(0, -2);
-    return undefined;
-}
-/**
- * Alternate property name for instance lookup (base <-> Id variant).
- */
-function getAlternatePropertyNameForInstanceLookup(propertyName) {
-    if (ID_SUFFIX_EXCLUDE.has(propertyName))
-        return undefined;
-    if (propertyName.endsWith('Id'))
-        return propertyName.slice(0, -2);
-    return `${propertyName}Id`;
-}
-/**
- * Resolve the best metadata record when multiple variants exist (base + Id).
- * For Image/File/Html: prefer the record with refResolvedValue (Id variant has filename).
- *
- * Records come newest first. Only each name's newest record counts, so an older record of the
- * same name (the value before a clear, or an earlier Version's) never wins. A cleared Id record (no
- * value, no file) wins over the base variant (ADR 0021).
- */
-function resolveMetadataRecord(records, preferredPropertyName, dataType, refValueType) {
-    if (records.length === 0)
-        throw new Error('No records to resolve');
-    records = records.filter((record, index) => records.findIndex((other) => other.propertyName === record.propertyName) === index);
-    if (records.length === 1)
-        return records[0];
-    const needsId = needsMetadataIdSuffix(dataType, refValueType) ||
-        (dataType === undefined && refValueType === undefined);
-    if (needsId) {
-        const cleared = records.find(
-        // A stored row holds null, not undefined, when it has no value
-        (r) => r.propertyName?.endsWith('Id') && r.propertyValue === null && !r.refResolvedValue);
-        if (cleared)
-            return cleared;
-    }
-    // For Image/File/Html: prefer the record with refResolvedValue (Id variant has filename)
-    if (needsId) {
-        const withRef = records.find((r) => r.refResolvedValue);
-        if (withRef)
-            return withRef;
-    }
-    // Also prefer by refSeedType when we need file ref
-    if (needsId) {
-        const byRefSeed = records.find((r) => r.refSeedType === 'image' ||
-            r.refSeedType === 'file' ||
-            r.refSeedType === 'html');
-        if (byRefSeed)
-            return byRefSeed;
-    }
-    // Fallback: prefer exact propertyName match, else first
-    return (records.find((r) => r.propertyName === preferredPropertyName) ?? records[0]);
-}
-/**
- * The EAS property name publish writes for an item property (ADR 0008 §3), already in EAS form:
- *
- * - List of relations: its `<name><Model>Ids` storage name (`author_identity_ids`).
- * - Single Relation, Image, File or Html: its schema key (`author`), never the local `<name>Id`
- *   storage name. The key is `propertyDef.name` when known, else `propertyName` without its `Id`.
- * - Anything else: the property name.
- */
-function easPropertyNameForPublish(propertyName, propertyDef) {
-    const listRelationName = listRelationEasPropertyName(propertyName, propertyDef ?? undefined);
-    if (listRelationName)
-        return easName(listRelationName);
-    if (propertyDef &&
-        normalizeDataType(propertyDef.dataType) !== 'List' &&
-        needsMetadataIdSuffix(propertyDef.dataType, propertyDef.refValueType) &&
-        !ID_SUFFIX_EXCLUDE.has(propertyName)) {
-        const key = propertyDef.name ?? (propertyName.endsWith('Id') ? propertyName.slice(0, -2) : propertyName);
-        return easName(key);
-    }
-    return easName(propertyName);
-}
-/**
- * The EAS schema definition publish attests a property under (`string title`, `bytes32 author`),
- * or undefined when its data type has no EAS type. Look schemas up by this, not by name: a name
- * can have schemas of several types (Optimism Sepolia has `bytes32 storage_transaction_id` beside
- * `string storage_transaction_id`).
- */
-function easSchemaDefinitionForProperty(propertyName, propertyDef) {
-    if (!propertyDef?.dataType)
-        return undefined;
-    const dataType = normalizeDataType(String(propertyDef.dataType));
-    const easType = INTERNAL_DATA_TYPES[dataType]?.eas;
-    if (!easType)
-        return undefined;
-    return `${easType} ${easPropertyNameForPublish(propertyName, propertyDef)}`;
-}
-
-/** Same rules as getCorrectId in helpers/index (avoid barrel circular import). */
-function parseLocalIdOrUid(localIdOrUid) {
-    const id = { localId: undefined, uid: undefined };
-    if (!localIdOrUid)
-        return id;
-    if (localIdOrUid.length === 10) {
-        id.localId = localIdOrUid;
-    }
-    if (localIdOrUid.startsWith('0x') && localIdOrUid.length === 66) {
-        id.uid = localIdOrUid;
-    }
-    return id;
-}
-/** Relation/image refs may be string ids or `{ seedLocalId?, seedUid? }`. */
-function normalizeRelationPropertyValue(value) {
-    if (value == null)
-        return undefined;
-    if (typeof value === 'string') {
-        const t = value.trim();
-        return t !== '' ? t : undefined;
-    }
-    if (typeof value === 'object' && value !== null) {
-        const o = value;
-        if (typeof o.seedLocalId === 'string' && o.seedLocalId.trim() !== '') {
-            return o.seedLocalId.trim();
-        }
-        if (typeof o.seedUid === 'string' && o.seedUid.trim() !== '') {
-            return o.seedUid.trim();
-        }
-    }
-    return undefined;
-}
-/** getCorrectId only accepts 10-char local ids and 0x66 uids; local seed refs can be up to 21 chars. */
-const LOCAL_SEED_REF = /^[a-zA-Z0-9_-]{10,21}$/;
-/** Resolve seed ids from a single string (context propertyValue or DB row). */
-function resolveSeedIdsFromRefString(s) {
-    const fromCorrect = parseLocalIdOrUid(s);
-    if (fromCorrect.localId || fromCorrect.uid) {
-        return { seedLocalId: fromCorrect.localId, seedUid: fromCorrect.uid };
-    }
-    if (LOCAL_SEED_REF.test(s) && !s.startsWith('0x')) {
-        return { seedLocalId: s };
-    }
-    return {};
-}
-/**
- * True when a relation ref is an attested seed uid (0x…) rather than a local id. A uid only exists once
- * the seed is on EAS, so publish can attest the uid as-is when no local copy exists (e.g. a server
- * publishing on someone's behalf that only holds the uids it was given). Callers must not walk into it.
- */
-function isPublishedSeedRef(value) {
-    const ref = normalizeRelationPropertyValue(value);
-    if (!ref)
-        return false;
-    const { seedLocalId, seedUid } = resolveSeedIdsFromRefString(ref);
-    return !!seedUid && !seedLocalId;
-}
-/**
- * Storage seed local id (nanoid) or 0x uid. Stricter than resolveSeedIdsFromRefString, which accepts
- * any 10-char string (so a 10-char html snippet like "<p>raw</p>" would pass as a local id).
- */
-const STORAGE_SEED_REF = /^(?:[A-Za-z0-9_-]{10,21}|0x[0-9a-fA-F]{64})$/;
-/** True when a File/Image/Html value is already a storage seed reference rather than raw content. */
-function isStorageSeedRef(value) {
-    return typeof value === 'string' && STORAGE_SEED_REF.test(value.trim());
-}
-
-const seeds = sqliteTable('seeds', {
-    localId: text('local_id').unique(),
-    uid: text('uid'),
-    schemaUid: text('schema_uid'),
-    type: text('type'),
-    // schemaFileId of the models row this item belongs to (= Model.id). Disambiguates items whose
-    // model name exists in more than one schema; null for legacy rows that couldn't be backfilled.
-    modelFileId: text('model_file_id'),
-    publisher: text('publisher'),
-    attestationRaw: text('attestation_raw'),
-    attestationCreatedAt: int('attestation_created_at'),
-    // Set on insert when the writer leaves it out. No $onUpdate: readers rank rows by
-    // COALESCE(attestation_created_at, created_at), and some writers move it on purpose.
-    createdAt: int('created_at').$defaultFn(() => Date.now()),
-    // Set on every insert and update unless the writer passes a value.
-    updatedAt: int('updated_at')
-        .$defaultFn(() => Date.now())
-        .$onUpdate(() => Date.now()),
-    _markedForDeletion: int('_marked_for_deletion'),
-    revokedAt: int('revoked_at'),
-}, (table) => [index('seeds_uid_idx').on(table.uid), index('seeds_type_idx').on(table.type)]);
-
-const versions = sqliteTable('versions', {
-    localId: text('local_id').unique(),
-    uid: text('uid'),
-    seedLocalId: text('seed_local_id'),
-    seedUid: text('seed_uid'),
-    seedType: text('seed_type'),
-    note: text('note'),
-    // Set on insert when the writer leaves it out. No $onUpdate: readers rank rows by
-    // COALESCE(attestation_created_at, created_at), and some writers move it on purpose.
-    createdAt: int('created_at').$defaultFn(() => Date.now()),
-    // Set on every insert and update unless the writer passes a value.
-    updatedAt: int('updated_at')
-        .$defaultFn(() => Date.now())
-        .$onUpdate(() => Date.now()),
-    attestationCreatedAt: int('attestation_created_at'),
-    attestationRaw: text('attestation_raw'),
-    publisher: text('publisher'),
-    /**
-     * When the version attestation was revoked, in Unix seconds (EAS `revocationTime`, or the local
-     * unpublish time until sync confirms it). Null while live or unpublished.
-     */
-    revokedAt: int('revoked_at'),
-}, (table) => [index('versions_seed_local_id_idx').on(table.seedLocalId)]);
-
-const metadata = sqliteTable('metadata', {
-    localId: text('local_id').unique(),
-    uid: text('uid'),
-    propertyId: integer('property_id').references(() => properties.id),
-    propertyName: text('property_name'),
-    propertyValue: text('property_value'),
-    schemaUid: text('schema_uid'),
-    modelType: text('model_type'),
-    seedLocalId: text('seed_local_id'),
-    seedUid: text('seed_uid'),
-    versionLocalId: text('version_local_id'),
-    versionUid: text('version_uid'),
-    easDataType: text('eas_data_type'),
-    refValueType: text('ref_value_type'),
-    refModelUid: text('ref_schema_uid'),
-    refSeedType: text('ref_seed_type'),
-    refResolvedValue: text('ref_resolved_value'),
-    refResolvedDisplayValue: text('ref_resolved_display_value'),
-    localStorageDir: text('local_storage_dir'),
-    attestationRaw: text('attestation_raw'),
-    attestationCreatedAt: int('attestation_created_at'),
-    contentHash: text('content_hash'),
-    // Set on insert when the writer leaves it out. No $onUpdate: readers rank rows by
-    // COALESCE(attestation_created_at, created_at), and some writers move it on purpose.
-    createdAt: int('created_at').$defaultFn(() => Date.now()),
-    // Set on every insert and update unless the writer passes a value.
-    updatedAt: int('updated_at')
-        .$defaultFn(() => Date.now())
-        .$onUpdate(() => Date.now()),
-    publisher: text('publisher'),
-    // Unix seconds when this row's attestation was revoked on EAS; null while it's live (or for a
-    // local, unpublished row). EAS sync keeps only the canonical attestation per (version, property
-    // schema): the newest live one, or the newest revoked one when all are revoked. So a non-null
-    // value marks a property kept only for its last value, not one that is present on the version.
-    revokedAt: int('revoked_at'),
-    // For a row EAS sync derived for an ItemStorage property from a `storage_transaction_id`
-    // attestation (uid null, ref_value_type 'file', value = the transaction id): that attestation's
-    // uid. Null for every other row. Marks the row as published content, not a local draft.
-    derivedFromUid: text('derived_from_uid'),
-    // On a cleared local row (null value): publish revokes the property's attestations instead of
-    // attesting the empty value (ADR 0021). Null on every other row.
-    retract: int('retract', { mode: 'boolean' }),
-}, (table) => [
-    index('metadata_seed_local_id_property_name_idx').on(table.seedLocalId, table.propertyName),
-    index('metadata_seed_uid_idx').on(table.seedUid),
-]);
-
-const appState = sqliteTable('appState', {
-    key: text('key').unique(),
-    value: text('value'),
-    createdAt: int('created_at'),
-    updatedAt: int('updated_at'),
-});
-
-const modelUids = sqliteTable('model_uids', {
-    id: int('id').primaryKey({ autoIncrement: true }),
-    uid: text('uid').notNull(),
-    modelId: int('model_id')
-        .notNull()
-        .unique()
-        .references(() => models.id),
-});
-const modelRelations = relations(modelUids, ({ one }) => ({
-    model: one(models),
-}));
-
-const propertyUids = sqliteTable('property_uids', {
-    id: int('id').primaryKey({ autoIncrement: true }),
-    uid: text('uid').notNull(),
-    propertyId: int('property_id')
-        .notNull()
-        .unique()
-        .references(() => properties.id),
-});
-const propertyUidRelations = relations(propertyUids, ({ one }) => ({
-    property: one(properties),
-}));
-
-const config = sqliteTable('config', {
-    id: integer('id').primaryKey({ autoIncrement: true }),
-    key: text('key').notNull(),
-    text: text('text'),
-    json: text('json'),
-    blob: blob('blob'),
-});
-
-const schemas = sqliteTable('schemas', {
-    id: integer('id').primaryKey({ autoIncrement: true }),
-    name: text('name').notNull(),
-    version: integer('version').notNull(),
-    schemaFileId: text('schema_file_id'), // ID from JSON file for change tracking - must be unique
-    schemaData: text('schema_data'), // Full JSON schema content (SchemaFileFormat as JSON string)
-    isDraft: integer('is_draft', { mode: 'boolean' }), // true if schema is in draft/editing state, false if published to file
-    isEdited: integer('is_edited', { mode: 'boolean' }), // true if schema has been edited locally, false if matches schema file
-    createdAt: int('created_at'),
-    updatedAt: int('updated_at'),
-}, (table) => {
-    return {
-        uniqueSchemaFileId: unique('unique_schema_schema_file_id').on(table.schemaFileId),
-    };
-});
-
-var SchemaSchema = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    schemas: schemas
-});
-
-const modelSchemas = sqliteTable('model_schemas', {
-    id: integer('id').primaryKey({ autoIncrement: true }),
-    modelId: integer('model_id').references(() => models.id),
-    schemaId: integer('schema_id').references(() => schemas.id),
-});
-
-var ModelSchemaSchema = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    modelSchemas: modelSchemas
-});
-
-const publishProcesses = sqliteTable('publish_processes', {
-    id: int('id').primaryKey({ autoIncrement: true }),
-    seedLocalId: text('seed_local_id').notNull(),
-    modelName: text('model_name').notNull(),
-    schemaId: text('schema_id'),
-    status: text('status').notNull(), // 'in_progress' | 'completed' | 'failed' | 'interrupted'
-    startedAt: int('started_at').notNull(),
-    completedAt: int('completed_at'),
-    errorMessage: text('error_message'),
-    errorStep: text('error_step'),
-    errorDetails: text('error_details'),
-    errorCode: text('error_code'), // e.g. ManagedAccountPublishError.code
-    persistedSnapshot: text('persisted_snapshot').notNull(),
-    seedId: text('seed_id'),
-    existingSeedUid: text('existing_seed_uid'),
-    createdAt: int('created_at'),
-    updatedAt: int('updated_at'),
-});
-
-const uploadProcesses = sqliteTable('upload_processes', {
-    id: int('id').primaryKey({ autoIncrement: true }),
-    reimbursementConfirmed: int('reimbursement_confirmed').notNull(), // 0 or 1 for boolean
-    reimbursementTransactionId: text('reimbursement_transaction_id'),
-    transactionKeys: text('transaction_keys'),
-    persistedSnapshot: text('persisted_snapshot').notNull(), // JSON string
-    createdAt: int('created_at'),
-    updatedAt: int('updated_at'),
-});
-
-/** Background job: resolve L1 tx id and wait for L1 confirmation after bundler publish. */
-const arweaveL1FinalizeJobs = sqliteTable('arweave_l1_finalize_jobs', {
-    id: int('id').primaryKey({ autoIncrement: true }),
-    seedLocalId: text('seed_local_id').notNull(),
-    dataItemId: text('data_item_id').notNull(),
-    /** L1 bundle / anchor transaction id from gateway GraphQL `bundledIn.id`. */
-    l1TransactionId: text('l1_transaction_id'),
-    bundleId: text('bundle_id'),
-    versionLocalId: text('version_local_id'),
-    itemPropertyName: text('item_property_name'),
-    /** `pending_l1` | `confirmed` | `failed` */
-    phase: text('phase').notNull(),
-    statusJson: text('status_json'),
-    errorMessage: text('error_message'),
-    createdAt: int('created_at').notNull(),
-    updatedAt: int('updated_at').notNull(),
-}, (table) => ({
-    dataItemIdUnique: uniqueIndex('arweave_l1_finalize_jobs_data_item_id_unique').on(table.dataItemId),
-}));
-
-const easSyncProcesses = sqliteTable('eas_sync_processes', {
-    id: int('id').primaryKey({ autoIncrement: true }),
-    status: text('status').notNull(), // 'in_progress' | 'completed' | 'failed'
-    startedAt: int('started_at').notNull(),
-    completedAt: int('completed_at'),
-    requestPayload: text('request_payload').notNull(),
-    errorMessage: text('error_message'),
-    errorDetails: text('error_details'),
-    persistedSnapshot: text('persisted_snapshot').notNull(),
-    createdAt: int('created_at'),
-    updatedAt: int('updated_at'),
-});
-
-/**
- * Links Image seeds materialized from Html `data:image/*` URIs to the parent Item seed for co-publish.
- * Rows are removed after a successful publish (see clearHtmlEmbeddedImageCoPublishRows).
- */
-const htmlEmbeddedImageCoPublish = sqliteTable('html_embedded_image_co_publish', {
-    id: int('id').primaryKey({ autoIncrement: true }),
-    parentSeedLocalId: text('parent_seed_local_id').notNull(),
-    htmlSeedLocalId: text('html_seed_local_id').notNull(),
-    imageSeedLocalId: text('image_seed_local_id').notNull(),
-    /** Stable dedup key (e.g. sha256 of data URI or normalized URI string). */
-    stableKey: text('stable_key').notNull(),
-    createdAt: int('created_at').notNull(),
-}, (t) => [
-    uniqueIndex('html_embed_co_pub_parent_html_stable').on(t.parentSeedLocalId, t.htmlSeedLocalId, t.stableKey),
-]);
-
-/**
- * The item write outbox (ADR 0019): one row per edit to an item, appended when the value is
- * assigned and applied to `seeds`, `versions` and `metadata` by the leader tab's drainer.
- */
-const pendingWrites = sqliteTable('pending_writes', {
-    id: int('id').primaryKey({ autoIncrement: true }),
-    /** Unique per op; the drainer and `save()` refer to an op by it. */
-    opId: text('op_id').notNull(),
-    /** Unused: nothing appends grouped ops. Kept until a migration drops it. */
-    groupId: text('group_id'),
-    seedLocalId: text('seed_local_id').notNull(),
-    /** Null for ops on the seed itself (`create`, `delete`). */
-    propertyName: text('property_name'),
-    /** `create` | `set` | `delete` | `storage` */
-    kind: text('kind').notNull(),
-    /** JSON-encoded value. */
-    value: text('value'),
-    /** Unused: a storage op's staged path is in its JSON value. Kept until a migration drops it. */
-    valueRef: text('value_ref'),
-    /** The stored metadata row the edit was made against, to detect a synced row written since. */
-    baseRowId: text('base_row_id'),
-    /** Unused: the base uid is read through base_row_id. Kept until a migration drops it. */
-    baseUid: text('base_uid'),
-    createdAt: int('created_at').notNull(),
-    /** The tab that appended the op. */
-    tabId: text('tab_id'),
-    /** `pending` | `applied` | `superseded` | `failed`. An op is claimed and applied in one transaction. */
-    status: text('status').notNull(),
-    error: text('error'),
-    /** The name of the error that failed the op (`OwnershipError`, say), so a waiter can tell why. */
-    errorName: text('error_name'),
-    attempts: int('attempts').notNull().default(0),
-    appliedAt: int('applied_at'),
-    /** JSON the applier recorded when the op applied (for a `set`: the metadata row written). */
-    result: text('result'),
-    /** JSON: the synced value this op was applied over, when there was one (ADR 0019). */
-    conflict: text('conflict'),
-    conflictResolvedAt: int('conflict_resolved_at'),
-}, (table) => ({
-    opIdUnique: uniqueIndex('pending_writes_op_id_unique').on(table.opId),
-    /** The drainer's order: per property, oldest first, among one status. */
-    drainOrder: index('pending_writes_drain_order').on(table.status, table.seedLocalId, table.propertyName, table.createdAt),
-}));
-
-/**
- * The entity change log (ADR 0020): one row per row written to `seeds`, `versions` or `metadata`,
- * inserted by triggers (migration 0023), so it commits or rolls back with the write. The browser's
- * change feed reads it to tell loaded Items and ItemProperties which seeds changed. Nothing else
- * writes it; the leader tab prunes rows older than 10 minutes.
- */
-const entityChanges = sqliteTable('entity_changes', {
-    seq: int('seq').primaryKey({ autoIncrement: true }),
-    /** `seeds` | `versions` | `metadata` */
-    tbl: text('tbl').notNull(),
-    seedLocalId: text('seed_local_id'),
-    seedUid: text('seed_uid'),
-    /** Set for `metadata` rows only. */
-    propertyName: text('property_name'),
-    /** Unix ms when the trigger ran. */
-    at: int('at').notNull(),
-}, (table) => ({
-    at: index('entity_changes_at').on(table.at),
-}));
-
-const seedUidToStorageTransactionId = new Map();
-const getStorageTransactionIdForSeedUid = async (seedUid) => {
-    if (seedUidToStorageTransactionId.has(seedUid)) {
-        return seedUidToStorageTransactionId.get(seedUid);
-    }
-    const appDb = BaseDb.getAppDb();
-    const results = (await appDb
-        .select({
-        storageTransactionId: metadata.propertyValue,
-    })
-        .from(metadata)
-        .where(and(eq(metadata.seedUid, seedUid), eq(metadata.propertyName, 'storageTransactionId'))));
-    if (!results || results.length === 0) {
-        return;
-    }
-    seedUidToStorageTransactionId.set(seedUid, results[0].storageTransactionId);
-    return results[0].storageTransactionId;
-};
-
-const logger$4 = debug('seedSdk:helpers:mediaRef');
-/** Typical Arweave transaction id: 43 URL-safe base64 characters. */
-const ARWEAVE_TX_ID = /^[a-zA-Z0-9_-]{43}$/;
-function trimOrEmpty(raw) {
-    if (raw == null)
-        return '';
-    return typeof raw === 'string' ? raw.trim() : String(raw).trim();
-}
-function coalesceStringField(item, key) {
-    const v = item[key];
-    if (v == null)
-        return '';
-    if (typeof v === 'string')
-        return v.trim();
-    if (typeof v === 'number' || typeof v === 'boolean')
-        return String(v);
-    return '';
-}
-/**
- * Try JSON relation payloads and plain relation id strings.
- */
-function unwrapRelationString(raw) {
-    const t = raw.trim();
-    if (!t)
-        return t;
-    try {
-        const parsed = JSON.parse(t);
-        const fromObj = normalizeRelationPropertyValue(parsed);
-        if (fromObj)
-            return fromObj;
-    }
-    catch {
-        // not JSON
-    }
-    return t;
-}
-/**
- * Pure, sync classification of a media-related string from feeds or XML.
- */
-function classifyMediaRef(raw, options) {
-    const s = trimOrEmpty(raw);
-    if (!s) {
-        return { kind: 'empty' };
-    }
-    const treatAs = options?.treatAs;
-    if (treatAs === 'url') {
-        return { kind: 'url', href: s };
-    }
-    if (treatAs === 'arweaveTx') {
-        return { kind: 'arweaveTxId', txId: s };
-    }
-    if (treatAs === 'seedUid') {
-        if (s.startsWith('0x') && s.length === 66) {
-            return { kind: 'seedUid', uid: s };
-        }
-        return { kind: 'unknown', raw: s };
-    }
-    if (s.startsWith('http://') || s.startsWith('https://') || s.startsWith('blob:') || s.startsWith('data:')) {
-        if (isEasAttestationExplorerUrl(s)) {
-            return { kind: 'nonMediaUrl', href: s };
-        }
-        return { kind: 'url', href: s };
-    }
-    const unwrapped = unwrapRelationString(s);
-    const ids = resolveSeedIdsFromRefString(unwrapped);
-    if (ids.seedUid) {
-        return { kind: 'seedUid', uid: ids.seedUid };
-    }
-    if (ids.seedLocalId) {
-        return { kind: 'seedLocalId', localId: ids.seedLocalId };
-    }
-    if (unwrapped.startsWith('0x') && unwrapped.length === 66) {
-        return { kind: 'seedUid', uid: unwrapped };
-    }
-    if (ARWEAVE_TX_ID.test(unwrapped) && !unwrapped.startsWith('0x')) {
-        return { kind: 'arweaveTxId', txId: unwrapped };
-    }
-    return { kind: 'unknown', raw: s };
-}
-/**
- * Same as convertTxIdToImage but local to this module to avoid circular imports with helpers/index.
- */
-async function tryLocalBlobUrlFromTxId(txId) {
-    const imageFilePath = BaseFileManager.getFilesPath('images', txId);
-    const fileExists = await BaseFileManager.pathExists(imageFilePath);
-    if (!fileExists) {
-        logger$4(`[tryLocalBlobUrlFromTxId] ${imageFilePath} does not exist`);
-        return undefined;
-    }
-    const buffer = await BaseFileManager.readFileAsBuffer(imageFilePath);
-    let arrayBuffer;
-    if (buffer instanceof Blob) {
-        arrayBuffer = await buffer.arrayBuffer();
-    }
-    else if (buffer instanceof ArrayBuffer) {
-        arrayBuffer = buffer;
-    }
-    else {
-        const sliced = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
-        if (sliced instanceof SharedArrayBuffer) {
-            const uint8Array = new Uint8Array(sliced);
-            arrayBuffer = uint8Array.buffer.slice(0);
-        }
-        else {
-            arrayBuffer = sliced;
-        }
-    }
-    const uint = new Uint8Array(arrayBuffer);
-    const imageBlob = new Blob([uint]);
-    return URL.createObjectURL(imageBlob);
-}
-async function resolveTxId(txId) {
-    const local = await tryLocalBlobUrlFromTxId(txId);
-    if (local) {
-        return { status: 'ready', href: local, source: 'localBlob' };
-    }
-    return {
-        status: 'ready',
-        href: BaseArweaveClient.getRawUrl(txId),
-        source: 'gateway',
-    };
-}
-/**
- * Resolve a classified media reference to a display URL (https/blob/data), using local files when present.
- */
-async function resolveMediaRef(raw, options) {
-    const classification = classifyMediaRef(raw, options);
-    switch (classification.kind) {
-        case 'empty':
-            return { status: 'empty' };
-        case 'url':
-            return {
-                status: 'ready',
-                href: classification.href,
-                source: 'direct',
-            };
-        case 'nonMediaUrl':
-            return {
-                status: 'unresolved',
-                reason: 'non_media_url',
-                classification,
-            };
-        case 'seedLocalId':
-            return {
-                status: 'unresolved',
-                reason: 'seed_local_id_not_portable',
-                classification,
-            };
-        case 'unknown':
-            return {
-                status: 'unresolved',
-                reason: 'unknown_ref',
-                classification,
-            };
-        case 'arweaveTxId':
-            return resolveTxId(classification.txId);
-        case 'seedUid': {
-            const appDb = BaseDb.getAppDb();
-            if (!appDb) {
-                return {
-                    status: 'unresolved',
-                    reason: 'seed_uid_requires_app_db',
-                    classification,
-                };
-            }
-            const storageTransactionId = await getStorageTransactionIdForSeedUid(classification.uid);
-            if (!storageTransactionId) {
-                return {
-                    status: 'unresolved',
-                    reason: 'seed_uid_no_storage_transaction',
-                    classification,
-                };
-            }
-            return resolveTxId(storageTransactionId);
-        }
-        default:
-            return {
-                status: 'unresolved',
-                reason: 'unknown_ref',
-                classification,
-            };
-    }
-}
-/**
- * Read a string field from a parsed item, trying camelCase and snake_case keys.
- */
-function getFeedItemStringField(item, key) {
-    const direct = coalesceStringField(item, key);
-    if (direct)
-        return direct;
-    const snake = key.replace(/[A-Z]/g, (l) => `_${l.toLowerCase()}`);
-    if (snake !== key) {
-        const alt = coalesceStringField(item, snake);
-        if (alt)
-            return alt;
-    }
-    const parts = key.split('_');
-    if (parts.length > 1) {
-        const camel = parts[0] + parts.slice(1).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join('');
-        const alt2 = coalesceStringField(item, camel);
-        if (alt2)
-            return alt2;
-    }
-    return '';
-}
-/**
- * Apply a field manifest to a plain feed item: classify media/file fields; pass through html/text.
- */
-function normalizeFeedItemFields(item, manifest) {
-    const out = {};
-    for (const [fieldKey, descriptor] of Object.entries(manifest)) {
-        const raw = getFeedItemStringField(item, fieldKey);
-        if (!raw) {
-            out[fieldKey] = undefined;
-            continue;
-        }
-        if (descriptor.role === 'html') {
-            out[fieldKey] = { role: 'html', raw };
-            continue;
-        }
-        if (descriptor.role === 'text') {
-            out[fieldKey] = { role: 'text', raw };
-            continue;
-        }
-        const classification = classifyMediaRef(raw, { treatAs: descriptor.treatAs });
-        out[fieldKey] = {
-            role: descriptor.role,
-            raw,
-            classification,
-        };
-    }
-    return out;
-}
-
-let refresher;
-function setCachedPropertyRefresher(fn) {
-    refresher = fn;
-}
-/** Give cached ModelProperty instances of these properties their rows' current values. */
-async function refreshCachedProperties(propertyFileIds) {
-    if (!refresher || propertyFileIds.length === 0)
-        return;
-    await refresher(propertyFileIds);
-}
-
-/**
- * Detect SQLite UNIQUE constraint failures across better-sqlite3 and drizzle/wasm wrappers.
- * Drizzle often surfaces `Failed query: insert into...` without "UNIQUE constraint" on message,
- * with the real SQLITE_CONSTRAINT_UNIQUE on cause / nested error.
- */
-function isSqliteUniqueConstraintError(error) {
-    const seen = new Set();
-    const queue = [error];
-    while (queue.length > 0) {
-        const current = queue.shift();
-        if (current == null || seen.has(current))
-            continue;
-        seen.add(current);
-        if (typeof current === 'string') {
-            if (matchesUniqueConstraintText(current))
-                return true;
-            continue;
-        }
-        if (typeof current !== 'object')
-            continue;
-        const err = current;
-        const code = err.code;
-        if (code === 'SQLITE_CONSTRAINT_UNIQUE' ||
-            code === 2067 ||
-            code === '2067') {
-            return true;
-        }
-        for (const key of ['message', 'msg', 'stack']) {
-            const raw = err[key];
-            const value = key === 'stack' && typeof raw === 'string' ? stackWithoutFrames(raw) : raw;
-            if (typeof value === 'string' && matchesUniqueConstraintText(value)) {
-                return true;
-            }
-        }
-        // Drizzle / wasm often nest the real SQLite error
-        for (const key of ['cause', 'reason', 'error', 'originalError', 'err']) {
-            if (err[key] != null)
-                queue.push(err[key]);
-        }
-    }
-    return false;
-}
-function matchesUniqueConstraintText(text) {
-    const lower = text.toLowerCase();
-    return (lower.includes('unique constraint') ||
-        lower.includes('sqlite_constraint_unique') ||
-        (lower.includes('constraint failed') && lower.includes('unique')) ||
-        /\brc\s*=\s*2067\b/i.test(text) ||
-        (text.includes('2067') && lower.includes('constraint')));
-}
-/**
- * A stack's message lines without its frames. Frames hold file names and line:column numbers, so
- * a frame in a file named like this one, with a 2067 in its position or URL timestamp, would match.
- */
-function stackWithoutFrames(stack) {
-    return stack
-        .split('\n')
-        .filter((line) => !/^\s*at\s/.test(line) && !/@\S*:\d+:\d+\s*$/.test(line))
-        .join('\n');
-}
-
-const level = (value) => (isNameMatchLevel(value) ? value : undefined);
-const tighter = (a, b) => a === undefined || compareNameMatchTiers(b, a) < 0 ? b : a;
-/** The levels in one schema file for one of its models, or undefined when the file lacks the model. */
-const modelLevelsFromFile = (file, modelName) => {
-    const modelDef = file.models?.[modelName];
-    if (!modelDef)
-        return undefined;
-    const model = level(modelDef.nameMatch) ?? level(file.nameMatch) ?? DEFAULT_NAME_MATCH_LEVEL;
-    const properties = new Map();
-    for (const [propertyName, def] of Object.entries(modelDef.properties ?? {})) {
-        properties.set(propertyName, level(def?.nameMatch) ?? model);
-    }
-    return { model, properties };
-};
-/**
- * Builds NameMatchLevels from the schema files that own each model row. Exported for tests;
- * use {@link nameMatchLevels}.
- */
-const nameMatchLevelsFromRows = (rows) => {
-    const byFileId = new Map();
-    const byName = new Map();
-    const parsed = new Map();
-    for (const row of rows) {
-        if (!row.schemaData)
-            continue;
-        if (!parsed.has(row.schemaData)) {
-            try {
-                parsed.set(row.schemaData, JSON.parse(row.schemaData));
-            }
-            catch {
-                parsed.set(row.schemaData, undefined);
-            }
-        }
-        const file = parsed.get(row.schemaData);
-        const levels = file && modelLevelsFromFile(file, row.modelName);
-        if (!levels)
-            continue;
-        if (row.modelFileId)
-            byFileId.set(row.modelFileId, levels);
-        const seen = byName.get(row.modelName);
-        if (!seen) {
-            byName.set(row.modelName, { model: levels.model, properties: new Map(levels.properties) });
-            continue;
-        }
-        seen.model = tighter(seen.model, levels.model);
-        for (const [name, value] of levels.properties)
-            seen.properties.set(name, tighter(seen.properties.get(name), value));
-    }
-    return {
-        model: (modelName) => byName.get(modelName)?.model ?? DEFAULT_NAME_MATCH_LEVEL,
-        property: (modelName, propertyName, modelFileId) => {
-            const levels = (modelFileId ? byFileId.get(modelFileId) : undefined) ?? byName.get(modelName);
-            return levels?.properties.get(propertyName) ?? levels?.model ?? DEFAULT_NAME_MATCH_LEVEL;
-        },
-    };
-};
-const DEFAULT_LEVELS = {
-    model: () => DEFAULT_NAME_MATCH_LEVEL,
-    property: () => DEFAULT_NAME_MATCH_LEVEL,
-};
-let current;
-let loading;
-/** Reads the levels from the schema files stored with each model's schema row (schemas.schema_data). */
-const loadNameMatchLevels = async (db = BaseDb.getAppDb()) => {
-    if (!db)
-        return DEFAULT_LEVELS;
-    const load = (async () => {
-        const rows = (await db
-            .select({ modelName: models.name, modelFileId: models.schemaFileId, schemaData: schemas.schemaData })
-            .from(models)
-            .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
-            .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id)));
-        return nameMatchLevelsFromRows(rows);
-    })();
-    loading = load;
-    try {
-        const levels = await load;
-        if (loading === load) {
-            current = levels;
-            previous = undefined;
-        }
-        return levels;
-    }
-    finally {
-        if (loading === load)
-            loading = undefined;
-    }
-};
-/** The levels, loaded once and reused until a schema write clears them. */
-const nameMatchLevels = async (db = BaseDb.getAppDb()) => current ?? loading ?? loadNameMatchLevels(db);
-/**
- * The last loaded levels, for synchronous callers (Model.findByModelType). Init loads them before
- * it reports ready. After a schema write clears them, this returns the levels from before the
- * write until the reload that clear starts finishes.
- */
-const currentNameMatchLevels = () => current ?? previous ?? DEFAULT_LEVELS;
-let previous;
-let reloadScheduled = false;
-/**
- * Called when a schema row or its models are written. The next {@link nameMatchLevels} read
- * reloads, and a reload starts on the next tick (one per burst of writes) for synchronous callers.
- */
-const clearNameMatchLevels = () => {
-    if (current)
-        previous = current;
-    current = undefined;
-    loading = undefined;
-    if (reloadScheduled)
-        return;
-    reloadScheduled = true;
-    setTimeout(() => {
-        reloadScheduled = false;
-        if (current || loading || !BaseDb.isAppDbReady())
-            return;
-        loadNameMatchLevels().catch(() => {
-            // The next nameMatchLevels() read retries.
-        });
-    }, 0);
-};
-/**
- * `nameMatch` values in a schema file that aren't a level. They are ignored (the next level up
- * applies); schema loads warn about them.
- */
-const invalidNameMatchValues = (file) => {
-    const problems = [];
-    const check = (where, value) => {
-        if (value !== undefined && !isNameMatchLevel(value)) {
-            problems.push(`${where} nameMatch ${JSON.stringify(value)} is not 'exact', 'normalized' or 'fuzzy'`);
-        }
-    };
-    check('schema', file.nameMatch);
-    for (const [modelName, modelDef] of Object.entries(file.models ?? {})) {
-        check(modelName, modelDef?.nameMatch);
-        for (const [propertyName, def] of Object.entries(modelDef?.properties ?? {})) {
-            check(`${modelName}.${propertyName}`, def?.nameMatch);
-        }
-    }
-    return problems;
-};
-/** Warns about {@link invalidNameMatchValues}. */
-const warnOnInvalidNameMatch = (file) => {
-    const problems = invalidNameMatchValues(file);
-    for (const problem of problems) {
-        console.warn(`[seed] schema ${file.metadata?.name ?? ''}: ${problem}; it is ignored.`);
-    }
-    return problems;
-};
-
-/**
- * Thrown when a model name exists in more than one schema and nothing says which one is meant.
- * Model names are only unique within a schema; pass `schemaName` (or `modelFileId`) to choose.
- */
-class AmbiguousModelError extends Error {
-    constructor(modelName, schemaNames) {
-        const names = [...new Set(schemaNames)].sort();
-        super(`Model "${modelName}" exists in schemas ${names.map((n) => `"${n}"`).join(', ')}; ` +
-            `pass schemaName (or modelFileId) to choose one.`);
-        this.name = 'AmbiguousModelError';
-        this.modelName = modelName;
-        this.schemaNames = names;
-    }
-}
-
-const columns = {
-    id: models.id,
-    name: models.name,
-    schemaFileId: models.schemaFileId,
-};
-/**
- * Resolve a models row from a model name plus whatever scope is known, most specific first:
- * modelFileId, modelId, then schemaId/schemaName + name, then the name alone. The name alone is
- * only accepted when it is unambiguous; otherwise this throws AmbiguousModelError.
- */
-const resolveModelRecord = async (modelName, scope = {}, db = BaseDb.getAppDb()) => {
-    if (!db)
-        return undefined;
-    if (scope.modelFileId) {
-        const rows = await db
-            .select(columns)
-            .from(models)
-            .where(eq(models.schemaFileId, scope.modelFileId))
-            .limit(1);
-        if (rows.length > 0)
-            return rows[0];
-    }
-    if (scope.modelId) {
-        const rows = await db.select(columns).from(models).where(eq(models.id, scope.modelId)).limit(1);
-        if (rows.length > 0)
-            return rows[0];
-    }
-    if (!modelName)
-        return undefined;
-    if (scope.schemaId || scope.schemaName) {
-        const rows = await db
-            .select(columns)
-            .from(models)
-            .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
-            .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
-            .where(and(eq(models.name, modelName), scope.schemaId ? eq(schemas.id, scope.schemaId) : eq(schemas.name, scope.schemaName)))
-            .limit(1);
-        if (rows.length > 0)
-            return rows[0];
-    }
-    return resolveModelRecordByNameOnly(modelName, db);
-};
-/**
- * Name-only resolution. Rows linked to a schema win over unlinked stubs (null-schemaFileId rows
- * from ref resolution); if more than one linked row has the name it is ambiguous and this throws.
- * `label` names the lookup in the error (defaults to the model name).
- */
-const resolveModelRecordByNameOnly = async (modelName, db, label = Array.isArray(modelName) ? modelName.join(', ') : modelName) => {
-    const rows = (await db
-        .select({ ...columns, schemaName: schemas.name })
-        .from(models)
-        .leftJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
-        .leftJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
-        .where(Array.isArray(modelName) ? inArray(models.name, modelName) : eq(models.name, modelName))
-        .orderBy(desc(models.id)));
-    if (rows.length === 0)
-        return undefined;
-    const linked = rows.filter((r) => r.schemaName);
-    const linkedIds = new Set(linked.map((r) => r.id));
-    if (linkedIds.size > 1) {
-        throw new AmbiguousModelError(label, linked.map((r) => r.schemaName));
-    }
-    const chosen = linked[0] ?? rows[0];
-    return { id: chosen.id, name: chosen.name, schemaFileId: chosen.schemaFileId };
-};
-/**
- * The model names a model name or EAS model type can refer to: the name itself, else the names
- * that match it in the tightest tier (ADR 0008, as Model.findByModelType matches): `new_model` →
- * "New model", `sync_storage_post` → "SyncStoragePost", `htmlpage` → "HTMLPage". Each name at its
- * nameMatch level (ADR 0009).
- */
-const modelNamesForNameOrType = async (nameOrType, db) => {
-    const rows = (await db.selectDistinct({ name: models.name }).from(models));
-    const names = rows.map((r) => r.name);
-    if (names.includes(nameOrType))
-        return [nameOrType];
-    const levels = await nameMatchLevels(db);
-    return [...localNamesInBestMatchTier(nameOrType, names, { level: (name) => levels.model(name) })];
-};
-/**
- * resolveModelRecord for a model name **or** an EAS model type (snake_case model name, what sync
- * stores in seeds.type): "New model" resolves from `new_model`. Scope and ambiguity behave as in
- * resolveModelRecord: modelFileId/modelId first, then the schema, then the name(s) alone, which throws
- * AmbiguousModelError when models in several schemas match.
- */
-const resolveModelRecordByNameOrType = async (nameOrType, scope = {}, db = BaseDb.getAppDb()) => {
-    if (!db)
-        return undefined;
-    if (scope.modelFileId || scope.modelId) {
-        const byId = await resolveModelRecord(undefined, scope, db);
-        if (byId)
-            return byId;
-    }
-    if (!nameOrType)
-        return undefined;
-    const names = await modelNamesForNameOrType(nameOrType, db);
-    if (names.length === 0)
-        return undefined;
-    if (names.length === 1)
-        return resolveModelRecord(names[0], { ...scope, modelFileId: undefined, modelId: undefined }, db);
-    // Several model names map to this type (e.g. "New model" and "NewModel" in different schemas).
-    if (scope.schemaId || scope.schemaName) {
-        const rows = (await db
-            .select(columns)
-            .from(models)
-            .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
-            .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
-            .where(and(inArray(models.name, names), scope.schemaId ? eq(schemas.id, scope.schemaId) : eq(schemas.name, scope.schemaName))));
-        if (new Set(rows.map((r) => r.id)).size === 1)
-            return rows[0];
-    }
-    return resolveModelRecordByNameOnly(names, db, nameOrType);
-};
-/**
- * Work out which model (schemaFileId) an item belongs to from whatever is at hand: an explicit
- * modelFileId, the seed's model_file_id, or a metadata row's property_id → properties.model_id.
- */
-const resolveItemModelFileId = async (hints, db = BaseDb.getAppDb()) => {
-    if (hints.modelFileId)
-        return hints.modelFileId;
-    if (!db)
-        return undefined;
-    if (hints.seedLocalId || hints.seedUid) {
-        const rows = await db
-            .select({ modelFileId: seeds.modelFileId })
-            .from(seeds)
-            .where(hints.seedLocalId ? eq(seeds.localId, hints.seedLocalId) : eq(seeds.uid, hints.seedUid))
-            .limit(1);
-        if (rows[0]?.modelFileId)
-            return rows[0].modelFileId;
-    }
-    if (hints.propertyId) {
-        const rows = await db
-            .select({ modelFileId: models.schemaFileId })
-            .from(properties)
-            .innerJoin(models, eq(properties.modelId, models.id))
-            .where(eq(properties.id, hints.propertyId))
-            .limit(1);
-        if (rows[0]?.modelFileId)
-            return rows[0].modelFileId;
-    }
-    return undefined;
-};
-/** ModelScope for an Item (or ItemProperty) instance: its recorded modelFileId (context or seed row) and schemaName. */
-const getItemModelScope = async (item) => {
-    let context;
-    try {
-        context = item.getService?.().getSnapshot().context;
-    }
-    catch {
-        context = undefined;
-    }
-    const modelFileId = await resolveItemModelFileId({
-        modelFileId: context?.modelFileId,
-        seedLocalId: item.seedLocalId ?? context?.seedLocalId,
-        seedUid: item.seedUid ?? context?.seedUid,
-        propertyId: context?.propertyId,
-    });
-    return { modelFileId, schemaName: context?.schemaName };
-};
-/**
- * Resolve a ref (e.g. a Relation's target model) by name from the schema(s) its owning model belongs
- * to, so "Tag" means the owner schema's Tag rather than any Tag. Falls back to resolveModelRecord.
- */
-const resolveRefModelRecord = async (refModelName, owner, db = BaseDb.getAppDb()) => {
-    if (!db || !refModelName)
-        return undefined;
-    const ownerRow = owner.modelFileId || owner.modelId ? await resolveModelRecord(undefined, owner, db) : undefined;
-    const schemaFilter = ownerRow
-        ? inArray(modelSchemas.schemaId, 
-        // any schema the owner is linked to
-        db.select({ schemaId: modelSchemas.schemaId }).from(modelSchemas).where(eq(modelSchemas.modelId, ownerRow.id)))
-        : owner.schemaId
-            ? eq(modelSchemas.schemaId, owner.schemaId)
-            : owner.schemaName
-                ? eq(schemas.name, owner.schemaName)
-                : undefined;
-    if (schemaFilter) {
-        const rows = await db
-            .select(columns)
-            .from(models)
-            .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
-            .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
-            .where(and(eq(models.name, refModelName), schemaFilter))
-            .limit(1);
-        if (rows.length > 0)
-            return rows[0];
-    }
-    return resolveModelRecord(refModelName, {}, db);
-};
-
-var resolveModelRecord$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    getItemModelScope: getItemModelScope,
-    resolveItemModelFileId: resolveItemModelFileId,
-    resolveModelRecord: resolveModelRecord,
-    resolveModelRecordByNameOrType: resolveModelRecordByNameOrType,
-    resolveRefModelRecord: resolveRefModelRecord
-});
-
-/**
- * Lowercase + trim an address for persist and compare.
- * Does not checksum or validate — test and placeholder addresses must keep working.
- */
-function normalizeHexAddress(addr) {
-    return addr.trim().toLowerCase();
-}
-/**
- * Lowercase, drop empties, and dedupe (first-seen order).
- */
-function normalizeAddressList(addrs) {
-    if (!addrs?.length)
-        return [];
-    const seen = new Set();
-    const out = [];
-    for (const addr of addrs) {
-        if (addr == null || addr === '')
-            continue;
-        const normalized = normalizeHexAddress(String(addr));
-        if (!normalized || seen.has(normalized))
-            continue;
-        seen.add(normalized);
-        out.push(normalized);
-    }
-    return out;
-}
-/**
- * Lowercase a publisher stamp. Empty / null → undefined (omit on write).
- */
-function normalizePublisher(publisher) {
-    if (publisher == null || publisher === '')
-        return undefined;
-    const normalized = normalizeHexAddress(publisher);
-    return normalized || undefined;
-}
-/**
- * Normalizes AddressConfiguration to { owned, watched }.
- * - string[] -> { owned: addresses, watched: [] }
- * - { owned, watched? } -> { owned, watched: watched ?? [] }
- * Addresses are lowercased and deduped.
- */
-function normalizeAddressConfig(addresses) {
-    if (!addresses) {
-        return { owned: [], watched: [] };
-    }
-    if (Array.isArray(addresses)) {
-        return { owned: normalizeAddressList(addresses), watched: [] };
-    }
-    return {
-        owned: normalizeAddressList(addresses.owned),
-        watched: normalizeAddressList(addresses.watched),
-    };
-}
-
-const pendingLinks = new Map();
-/**
- * Insert the `model_schemas` row linking a model to a schema, unless it already exists.
- *
- * `model_schemas` has no unique constraint, and several writers link the same model during one
- * import (importJsonSchema's addModelsToDb and the write service's writeModelToDb). Each used to
- * check-then-insert on its own, so concurrent writers inserted the link twice. The check and insert
- * run serialized per (model, schema) here.
- *
- * @returns true when this call inserted the link
- */
-function linkModelToSchema(db, modelId, schemaId) {
-    const key = `${modelId}:${schemaId}`;
-    const previous = pendingLinks.get(key) ?? Promise.resolve(false);
-    const current = previous
-        .catch(() => false)
-        .then(async () => {
-        const existing = await db
-            .select({ id: modelSchemas.id })
-            .from(modelSchemas)
-            .where(and(eq(modelSchemas.modelId, modelId), eq(modelSchemas.schemaId, schemaId)))
-            .limit(1);
-        if (existing.length > 0)
-            return false;
-        await db.insert(modelSchemas).values({ modelId, schemaId });
-        return true;
-    });
-    pendingLinks.set(key, current);
-    const cleanup = () => {
-        if (pendingLinks.get(key) === current)
-            pendingLinks.delete(key);
-    };
-    current.then(cleanup, cleanup);
-    return current;
-}
-
-const logger$3 = debug('seedSdk:helpers:db');
-/**
- * Posts one message and closes the channel. A message already posted is still delivered after its
- * sender closes, and an open BroadcastChannel keeps a Node process alive (each was a MessagePort
- * handle that stopped scripts exiting).
- */
-const postBroadcast = (channelName, message) => {
-    const channel = new BroadcastChannel(channelName);
-    try {
-        channel.postMessage(message);
-    }
-    finally {
-        channel.close();
-    }
-};
-/**
- * The `properties` storage columns for a property definition, in either the internal shape
- * (`storageType`, `localStorageDir`, `filenameSuffix`) or the schema-file shape
- * (`storage: { type, path, extension }`). All null when the definition has no storage config.
- */
-function propertyStorageColumns(def) {
-    const normalized = normalizePropertyRecordSchema((def ?? {}));
-    return {
-        storageType: normalized.storageType ?? null,
-        localStorageDir: normalized.localStorageDir ?? null,
-        filenameSuffix: normalized.filenameSuffix ?? null,
-    };
-}
-/** True when the definition carries any storage setting (so writing its columns can't wipe them by omission). */
-const hasStorageSettings = (columns) => columns.storageType != null || columns.localStorageDir != null || columns.filenameSuffix != null;
-/**
- * Resolve property_id (integer properties.id) from a property's schemaFileId (the string `id` in
- * schema files and propertyRecordSchema). Scoped to the model since schemaFileIds are per schema file.
- * Reads `db` (a transaction's `tx`, say), the app database by default.
- * @returns properties.id or null if not found
- */
-async function getPropertyIdForSchemaFileId(modelNameOrType, schemaFileId, scope = {}, db = BaseDb.getAppDb()) {
-    if (!db || !modelNameOrType || !schemaFileId)
-        return null;
-    const modelRecord = await resolveModelRecordByNameOrType(modelNameOrType, scope, db);
-    if (!modelRecord)
-        return null;
-    const rows = await db
-        .select({ id: properties.id })
-        .from(properties)
-        .where(and(eq(properties.modelId, modelRecord.id), eq(properties.schemaFileId, schemaFileId)))
-        .limit(1);
-    return rows[0]?.id ?? null;
-}
-/**
- * Resolve property_id from model name/type and property name.
- * Handles property name variants (e.g. htmlId -> html, avatarImageIds -> avatarImages).
- * @param modelNameOrType - Model name (PascalCase) or model type (snake_case)
- * @param propertyName - Property name as stored in metadata (may have Id/Ids suffix)
- * @param scope - Which model is meant when several schemas define one with this name
- * @param db - The database or transaction to read; the app database by default
- * @returns properties.id or null if not found
- */
-async function getPropertyIdForModelAndName(modelNameOrType, propertyName, scope = {}, db = BaseDb.getAppDb()) {
-    if (!db)
-        return null;
-    if (!modelNameOrType || !propertyName)
-        return null;
-    const modelRecord = await resolveModelRecordByNameOrType(modelNameOrType, scope, db);
-    if (!modelRecord)
-        return null;
-    const propertyNamesToTry = [propertyName];
-    if (propertyName.endsWith('Ids')) {
-        propertyNamesToTry.push(propertyName.slice(0, -3));
-    }
-    if (propertyName.endsWith('Id')) {
-        propertyNamesToTry.push(propertyName.slice(0, -2));
-    }
-    for (const pName of propertyNamesToTry) {
-        const rows = await db
-            .select({ id: properties.id })
-            .from(properties)
-            .where(and(eq(properties.modelId, modelRecord.id), eq(properties.name, pName)))
-            .limit(1);
-        if (rows.length > 0 && rows[0].id != null) {
-            return rows[0].id;
-        }
-    }
-    return null;
-}
-/**
- * A model's ItemStorage properties as stored in `properties` (storage_type 'ItemStorage'), with
- * their storage path and extension. Reads the table, not ModelProperty instances, so it doesn't
- * depend on whether (or from where) the model's property instances have loaded.
- */
-async function getItemStoragePropertiesForModel(modelNameOrType, scope = {}) {
-    const db = BaseDb.getAppDb();
-    if (!db || !modelNameOrType)
-        return [];
-    const modelRecord = await resolveModelRecordByNameOrType(modelNameOrType, scope, db);
-    if (!modelRecord)
-        return [];
-    return db
-        .select({
-        id: properties.id,
-        name: properties.name,
-        localStorageDir: properties.localStorageDir,
-        filenameSuffix: properties.filenameSuffix,
-    })
-        .from(properties)
-        .where(and(eq(properties.modelId, modelRecord.id), eq(properties.storageType, 'ItemStorage')));
-}
-/**
- * Migrate metadata rows when a property is renamed.
- * Updates metadata.propertyName from old to new for all rows that reference the renamed property.
- * Called from renameModelProperty to prevent duplicate ItemProperties.
- * @param modelName - Model name (PascalCase)
- * @param oldPropertyName - Current property name before rename
- * @param newPropertyName - New property name after rename
- * @param propertySchemaFileId - Optional schema file ID for the property (most reliable lookup)
- * @returns Count of metadata rows updated
- */
-async function migrateMetadataForPropertyRename(modelName, oldPropertyName, newPropertyName, propertySchemaFileId, scope = {}) {
-    const db = BaseDb.getAppDb();
-    if (!db) {
-        logger$3('[migrateMetadataForPropertyRename] Database not available, skipping');
-        return 0;
-    }
-    // Find the property row by schemaFileId (preferred) or by name
-    let propertyId = null;
-    if (propertySchemaFileId) {
-        propertyId = await getPropertyIdForSchemaFileId(modelName, propertySchemaFileId, scope);
-    }
-    if (propertyId == null) {
-        propertyId = await getPropertyIdForModelAndName(modelName, oldPropertyName, scope);
-    }
-    if (propertyId == null) {
-        logger$3(`[migrateMetadataForPropertyRename] Property not found: ${modelName}.${oldPropertyName}, skipping`);
-        return 0;
-    }
-    // Primary path: update metadata by propertyId
-    const toUpdateByPropertyId = await db
-        .select({ localId: metadata.localId })
-        .from(metadata)
-        .where(eq(metadata.propertyId, propertyId));
-    const updatedByPropertyId = toUpdateByPropertyId.length;
-    if (updatedByPropertyId > 0) {
-        await db
-            .update(metadata)
-            .set({ propertyName: newPropertyName })
-            .where(eq(metadata.propertyId, propertyId));
-    }
-    // Fallback: update metadata with null propertyId (legacy rows) by propertyName + modelType
-    const modelType = easName(modelName);
-    const toUpdateByFallback = await db
-        .select({ localId: metadata.localId })
-        .from(metadata)
-        .where(and(eq(metadata.propertyName, oldPropertyName), eq(metadata.modelType, modelType), isNull(metadata.propertyId)));
-    const updatedByFallback = toUpdateByFallback.length;
-    if (updatedByFallback > 0) {
-        await db
-            .update(metadata)
-            .set({ propertyName: newPropertyName })
-            .where(and(eq(metadata.propertyName, oldPropertyName), eq(metadata.modelType, modelType), isNull(metadata.propertyId)));
-    }
-    if (updatedByFallback > 0) {
-        logger$3(`[migrateMetadataForPropertyRename] Fallback updated ${updatedByFallback} rows (propertyId was null)`);
-    }
-    // Edits of the property still in the outbox (ADR 0019) apply under its new name
-    await db
-        .update(pendingWrites)
-        .set({ propertyName: newPropertyName })
-        .where(and(eq(pendingWrites.propertyName, oldPropertyName), eq(pendingWrites.status, 'pending'), inArray(pendingWrites.seedLocalId, db.select({ localId: seeds.localId }).from(seeds).where(eq(seeds.type, modelType)))));
-    const total = updatedByPropertyId + updatedByFallback;
-    if (total > 0) {
-        logger$3(`[migrateMetadataForPropertyRename] Migrated ${total} metadata rows for ${modelName}.${oldPropertyName} -> ${newPropertyName}`);
-    }
-    return total;
-}
-/**
- * Moves a renamed property's metadata rows to its new name: rows linked by propertyId, and legacy
- * rows without one by name and model type. Each stored form of the name moves to the same form of
- * the new one: the key (`author` → `writer`), a single relation's `<key>Id` (`authorId` →
- * `writerId`), a list relation's storage name (`authorIdentityIds` → `writerIdentityIds`).
- * Returns the number of rows moved.
- */
-async function moveMetadataToRenamedProperty(db, { propertyId, modelType, oldName, newName, propertyDef, }) {
-    const forms = (name) => [
-        name,
-        toMetadataPropertyName(name, propertyDef?.dataType, propertyDef?.refValueType),
-        listRelationEasPropertyName(name, propertyDef) ?? name,
-    ];
-    const oldForms = forms(oldName);
-    const newForms = forms(newName);
-    let moved = 0;
-    const seen = new Set();
-    for (let i = 0; i < oldForms.length; i++) {
-        const from = oldForms[i];
-        const to = newForms[i];
-        if (from === to || seen.has(from))
-            continue;
-        seen.add(from);
-        const byId = await db
-            .update(metadata)
-            .set({ propertyName: to })
-            .where(and(eq(metadata.propertyId, propertyId), eq(metadata.propertyName, from)))
-            .returning({ localId: metadata.localId });
-        const legacy = await db
-            .update(metadata)
-            .set({ propertyName: to })
-            .where(and(isNull(metadata.propertyId), eq(metadata.propertyName, from), eq(metadata.modelType, modelType)))
-            .returning({ localId: metadata.localId });
-        moved += byId.length + legacy.length;
-    }
-    if (moved > 0)
-        logger$3(`[moveMetadataToRenamedProperty] moved ${moved} metadata rows ${oldName} -> ${newName}`);
-    return moved;
-}
-/**
- * True when the models row is linked (model_schemas) to any schema other than schemaId.
- */
-const isModelLinkedToOtherSchema = async (db, modelId, schemaId) => {
-    const links = await db
-        .select({ schemaId: modelSchemas.schemaId })
-        .from(modelSchemas)
-        .where(eq(modelSchemas.modelId, modelId));
-    return links.some((l) => l.schemaId !== schemaId);
-};
-const isModelLinkedToAnySchema = async (db, modelId) => {
-    const links = await db
-        .select({ id: modelSchemas.id })
-        .from(modelSchemas)
-        .where(eq(modelSchemas.modelId, modelId))
-        .limit(1);
-    return links.length > 0;
-};
-/**
- * Find or create a models row by schemaFileId (preferred) or name.
- * Reuses an existing same-name row (especially schemaFileId=null stubs created via
- * ref resolution) instead of inserting a second row — models.name is not unique,
- * and duplicate names break name lookups (e.g. Resource.tags → Tag).
- *
- * When modelFileId is given, a same-name row that already carries a *different*
- * non-null schemaFileId is only adopted if no other schema is linked to it via
- * model_schemas. Otherwise it belongs to another schema (e.g. two schemas that each
- * define "Post"), and re-id'ing it would strand that schema's cached Model instance,
- * so a new row is inserted instead.
- */
-const findOrCreateModelRecord = async (db, modelName, modelFileId, schemaId) => {
-    if (modelFileId) {
-        const byFileId = await db
-            .select()
-            .from(models)
-            .where(eq(models.schemaFileId, modelFileId))
-            .limit(1);
-        if (byFileId.length > 0) {
-            const record = byFileId[0];
-            if (record.name !== modelName) {
-                await db
-                    .update(models)
-                    .set({ name: modelName })
-                    .where(eq(models.id, record.id));
-                return { ...record, name: modelName };
-            }
-            return record;
-        }
-    }
-    const byName = (await db
-        .select()
-        .from(models)
-        .where(eq(models.name, modelName)));
-    if (byName.length > 0) {
-        // Prefer exact file-id match, then (for refs without a file id) this schema's row, then an
-        // adoptable null schemaFileId stub, then any single row.
-        let chosen = modelFileId
-            ? byName.find((r) => r.schemaFileId === modelFileId)
-            : undefined;
-        if (!chosen && !modelFileId && schemaId && byName.length > 1) {
-            for (const candidate of byName) {
-                if (!(await isModelLinkedToOtherSchema(db, candidate.id, schemaId))) {
-                    const links = await db
-                        .select({ schemaId: modelSchemas.schemaId })
-                        .from(modelSchemas)
-                        .where(eq(modelSchemas.modelId, candidate.id));
-                    if (links.length > 0) {
-                        chosen = candidate;
-                        break;
-                    }
-                }
-            }
-        }
-        chosen ?? (chosen = byName.find((r) => !r.schemaFileId));
-        if (!chosen && modelFileId) {
-            // Every same-name row has a different file id. Only adopt one that no other
-            // schema claims; otherwise fall through and insert a row for this file id.
-            // A row with a file id that no schema links is a deleted schema's leftover (its old
-            // properties are still attached), not an unclaimed row: don't adopt it either.
-            for (const candidate of byName) {
-                if (candidate.schemaFileId && !(await isModelLinkedToAnySchema(db, candidate.id)))
-                    continue;
-                if (!(await isModelLinkedToOtherSchema(db, candidate.id, schemaId))) {
-                    chosen = candidate;
-                    break;
-                }
-            }
-        }
-        else if (!chosen) {
-            chosen =
-                (byName.length === 1 ? byName[0] : undefined) ||
-                    byName.find((r) => !!r.schemaFileId) ||
-                    byName[0];
-        }
-        if (chosen && modelFileId && chosen.schemaFileId !== modelFileId) {
-            const conflict = await db
-                .select()
-                .from(models)
-                .where(eq(models.schemaFileId, modelFileId))
-                .limit(1);
-            if (conflict.length > 0) {
-                return conflict[0];
-            }
-            // Adopt stub (null schemaFileId) or an unclaimed same-name row by attaching this file id.
-            await db
-                .update(models)
-                .set({ schemaFileId: modelFileId, isEdited: false })
-                .where(eq(models.id, chosen.id));
-            chosen = { ...chosen, schemaFileId: modelFileId, isEdited: false };
-            logger$3(`Adopted existing model "${modelName}" (id: ${chosen.id}) with schemaFileId "${modelFileId}"`);
-        }
-        if (chosen) {
-            return chosen;
-        }
-    }
-    try {
-        // A Model instance's own write can insert this file id between the lookups above and here
-        // (schema import writes each model twice at once). DO NOTHING instead of a failed statement,
-        // which sqlite-wasm logs as a warning even though the error is caught.
-        const inserted = await db
-            .insert(models)
-            .values({
-            name: modelName,
-            schemaFileId: modelFileId || null,
-            isEdited: false,
-        })
-            .onConflictDoNothing()
-            .returning();
-        if (inserted.length > 0) {
-            return inserted[0];
-        }
-        if (modelFileId) {
-            const existing = await db
-                .select()
-                .from(models)
-                .where(eq(models.schemaFileId, modelFileId))
-                .limit(1);
-            if (existing.length > 0) {
-                return existing[0];
-            }
-        }
-        throw new Error(`Model "${modelName}" was not inserted and no row has schemaFileId "${modelFileId}"`);
-    }
-    catch (error) {
-        if (isSqliteUniqueConstraintError(error) && modelFileId) {
-            const existing = await db
-                .select()
-                .from(models)
-                .where(eq(models.schemaFileId, modelFileId))
-                .limit(1);
-            if (existing.length > 0) {
-                return existing[0];
-            }
-        }
-        // Race: another writer inserted by name — reuse rather than throw on duplicates.
-        const raced = (await db
-            .select()
-            .from(models)
-            .where(eq(models.name, modelName)));
-        if (raced.length > 0) {
-            return ((modelFileId
-                ? raced.find((r) => r.schemaFileId === modelFileId)
-                : undefined) ||
-                raced.find((r) => !r.schemaFileId) ||
-                raced[0]);
-        }
-        throw error;
-    }
-};
-/**
- * Find or create the models row a Relation property on ownerModelId points to. Model names are only
- * unique per schema, so the ref is looked up in the owner's schema(s) first; a global name lookup
- * by name threw "Multiple records found" once two schemas defined the ref model.
- */
-const findOrCreateRefModelRecord = async (db, refModelName, ownerModelId) => {
-    try {
-        const ref = await resolveRefModelRecord(refModelName, { modelId: ownerModelId }, db);
-        if (ref)
-            return ref;
-    }
-    catch (error) {
-        // Not in the owner's schema and defined by several others: pick/create like an import does
-        if (!(error instanceof AmbiguousModelError))
-            throw error;
-    }
-    const [ownerLink] = await db
-        .select({ schemaId: modelSchemas.schemaId })
-        .from(modelSchemas)
-        .where(eq(modelSchemas.modelId, ownerModelId))
-        .limit(1);
-    return findOrCreateModelRecord(db, refModelName, undefined, ownerLink?.schemaId ?? undefined);
-};
-/**
- * Searches the database for an existing schema by schemaFileId (preferred) or name and creates it if it doesn't exist
- * @param schema - The schema to add to the database
- * @param schemaFileId - Optional schemaFileId from JSON file for change tracking
- * @param schemaData - Optional full schema content as JSON string (SchemaFileFormat)
- * @param isDraft - Optional flag indicating if schema is in draft state (default: false)
- * @param isEdited - Optional flag indicating if schema has been edited locally (default: false)
- * @returns The schema record (either existing or newly created)
- */
-const addSchemaToDb = async (schema, schemaFileId, schemaData, isDraft, isEdited) => {
-    const db = BaseDb.getAppDb();
-    if (!db) {
-        throw new Error('Database not found');
-    }
-    // The stored schema file may change its nameMatch levels (ADR 0009).
-    clearNameMatchLevels();
-    // First, try to find existing schema by schemaFileId (preferred for change tracking)
-    if (schemaFileId) {
-        const existingByFileId = await db
-            .select()
-            .from(schemas)
-            .where(eq(schemas.schemaFileId, schemaFileId))
-            .limit(1);
-        if (existingByFileId.length > 0) {
-            // Update fields if provided
-            const updates = {};
-            if (schemaFileId && !existingByFileId[0].schemaFileId) {
-                updates.schemaFileId = schemaFileId;
-            }
-            // Always update name if it's different (handles name changes)
-            if (schema.name && existingByFileId[0].name !== schema.name) {
-                updates.name = schema.name;
-            }
-            if (schemaData !== undefined) {
-                updates.schemaData = schemaData;
-            }
-            if (schema.version !== undefined && existingByFileId[0].version !== schema.version) {
-                updates.version = schema.version;
-            }
-            if (isDraft !== undefined && existingByFileId[0].isDraft !== isDraft) {
-                updates.isDraft = isDraft;
-            }
-            if (isEdited !== undefined && existingByFileId[0].isEdited !== isEdited) {
-                updates.isEdited = isEdited;
-            }
-            if (schema.updatedAt && existingByFileId[0].updatedAt !== schema.updatedAt) {
-                updates.updatedAt = schema.updatedAt;
-            }
-            if (Object.keys(updates).length > 0) {
-                await db
-                    .update(schemas)
-                    .set(updates)
-                    .where(eq(schemas.id, existingByFileId[0].id));
-                return { ...existingByFileId[0], ...updates };
-            }
-            return existingByFileId[0];
-        }
-    }
-    // For drafts, check if there's an existing draft by name (not by schemaFileId)
-    if (isDraft === true) {
-        const existingDrafts = await db
-            .select()
-            .from(schemas)
-            .where(eq(schemas.name, schema.name))
-            .limit(1);
-        if (existingDrafts.length > 0 && existingDrafts[0].isDraft === true) {
-            // Update existing draft
-            const updates = {};
-            // Update schemaFileId if provided and different from existing
-            if (schemaFileId && existingDrafts[0].schemaFileId !== schemaFileId) {
-                updates.schemaFileId = schemaFileId;
-            }
-            if (schemaData !== undefined) {
-                updates.schemaData = schemaData;
-            }
-            if (schema.version !== undefined) {
-                updates.version = schema.version;
-            }
-            updates.updatedAt = schema.updatedAt || Date.now();
-            if (Object.keys(updates).length > 0) {
-                await db
-                    .update(schemas)
-                    .set(updates)
-                    .where(eq(schemas.id, existingDrafts[0].id));
-                return { ...existingDrafts[0], ...updates };
-            }
-            return existingDrafts[0];
-        }
-    }
-    // Fallback: Search for existing schema by name
-    // BUT: If we have a schemaFileId, also check if any record with that schemaFileId exists
-    // (in case the name changed but we're looking up by the new name)
-    if (schemaFileId) {
-        // Double-check by schemaFileId - maybe the name changed and we're looking up by new name
-        const doubleCheckByFileId = await db
-            .select()
-            .from(schemas)
-            .where(eq(schemas.schemaFileId, schemaFileId))
-            .limit(1);
-        if (doubleCheckByFileId.length > 0) {
-            // Found by schemaFileId - update it (name might have changed)
-            const updates = {};
-            // Always update name if it's different (handles name changes)
-            if (schema.name && doubleCheckByFileId[0].name !== schema.name) {
-                updates.name = schema.name;
-            }
-            if (schemaData !== undefined) {
-                updates.schemaData = schemaData;
-            }
-            if (schema.version !== undefined && doubleCheckByFileId[0].version !== schema.version) {
-                updates.version = schema.version;
-            }
-            if (isDraft !== undefined && doubleCheckByFileId[0].isDraft !== isDraft) {
-                updates.isDraft = isDraft;
-            }
-            if (isEdited !== undefined && doubleCheckByFileId[0].isEdited !== isEdited) {
-                updates.isEdited = isEdited;
-            }
-            if (schema.updatedAt && doubleCheckByFileId[0].updatedAt !== schema.updatedAt) {
-                updates.updatedAt = schema.updatedAt;
-            }
-            if (Object.keys(updates).length > 0) {
-                await db
-                    .update(schemas)
-                    .set(updates)
-                    .where(eq(schemas.id, doubleCheckByFileId[0].id));
-                return { ...doubleCheckByFileId[0], ...updates };
-            }
-            return doubleCheckByFileId[0];
-        }
-    }
-    // Final fallback: Search by name (only if no schemaFileId or schemaFileId lookup failed)
-    // If isDraft is explicitly false, first try to find non-draft, but also check for drafts
-    // to handle the case where a draft exists and we're loading a non-draft version
-    let existingSchemas = await db
-        .select()
-        .from(schemas)
-        .where(isDraft === false
-        ? and(eq(schemas.name, schema.name), eq(schemas.isDraft, false))
-        : eq(schemas.name, schema.name))
-        .limit(1);
-    // If isDraft is false and we didn't find a non-draft, check for a draft with the same name
-    // This handles the case where a draft was created first and we're now loading the non-draft version
-    if (isDraft === false && existingSchemas.length === 0) {
-        const draftSchemas = await db
-            .select()
-            .from(schemas)
-            .where(and(eq(schemas.name, schema.name), eq(schemas.isDraft, true)))
-            .limit(1);
-        if (draftSchemas.length > 0) {
-            // Found a draft - we'll update it to non-draft below
-            logger$3(`Found draft schema "${schema.name}" with schemaFileId "${draftSchemas[0].schemaFileId}", will update to non-draft with schemaFileId "${schemaFileId}"`);
-            existingSchemas = draftSchemas;
-        }
-    }
-    if (existingSchemas.length > 0) {
-        // The row is per schema name and holds its latest version. A complete schema file can bring
-        // a version under its own id (SDK version bumps keep the id; imported files may not).
-        const isOtherVersionFile = !!schemaFileId &&
-            !!existingSchemas[0].schemaFileId &&
-            existingSchemas[0].schemaFileId !== schemaFileId &&
-            existingSchemas[0].isDraft !== true &&
-            schema.version !== undefined &&
-            schema.version !== existingSchemas[0].version;
-        if (isOtherVersionFile && schema.version < existingSchemas[0].version) {
-            // An older version's file: rolling the row back to it would leave the newer version's id
-            // pointing at the older version's data.
-            logger$3(`Keeping schema "${schema.name}" at v${existingSchemas[0].version}; not replacing it with older v${schema.version}`);
-            return existingSchemas[0];
-        }
-        // Update fields if provided
-        const updates = {};
-        // Update schemaFileId if provided and different from existing (or if existing doesn't have one or is null)
-        // This is important for preserving IDs from schema files when drafts exist
-        // BUT: Don't overwrite a non-draft schema's schemaFileId with a new generated one
-        // This prevents loadOrCreateSchema from overwriting correct IDs from fixture files
-        if (schemaFileId && existingSchemas[0].schemaFileId !== schemaFileId) {
-            // Only update if:
-            // 1. Existing schema is a draft (can be updated)
-            // 2. Existing schema has no schemaFileId (should be set)
-            // 3. We're explicitly setting isDraft to false (updating from draft to non-draft)
-            // 4. It's a newer version's file: the row takes that version's data, so it takes its id too
-            const shouldUpdate = existingSchemas[0].isDraft === true ||
-                !existingSchemas[0].schemaFileId ||
-                (isDraft === false && existingSchemas[0].isDraft === true) ||
-                isOtherVersionFile;
-            if (shouldUpdate) {
-                logger$3(`Updating schemaFileId from "${existingSchemas[0].schemaFileId}" to "${schemaFileId}" for schema "${schema.name}"`);
-                updates.schemaFileId = schemaFileId;
-            }
-            else {
-                logger$3(`Preserving existing schemaFileId "${existingSchemas[0].schemaFileId}" for non-draft schema "${schema.name}" (new schemaFileId "${schemaFileId}" would overwrite it)`);
-            }
-        }
-        // Always update name if it's different (handles name changes)
-        if (schema.name && existingSchemas[0].name !== schema.name) {
-            updates.name = schema.name;
-        }
-        if (schemaData !== undefined) {
-            updates.schemaData = schemaData;
-        }
-        if (schema.version !== undefined && existingSchemas[0].version !== schema.version) {
-            updates.version = schema.version;
-        }
-        // If isDraft is explicitly false and we found a draft, update it to non-draft
-        if (isDraft === false && existingSchemas[0].isDraft === true) {
-            updates.isDraft = false;
-        }
-        else if (isDraft !== undefined && existingSchemas[0].isDraft !== isDraft) {
-            updates.isDraft = isDraft;
-        }
-        if (isEdited !== undefined && existingSchemas[0].isEdited !== isEdited) {
-            updates.isEdited = isEdited;
-        }
-        if (schema.updatedAt && existingSchemas[0].updatedAt !== schema.updatedAt) {
-            updates.updatedAt = schema.updatedAt;
-        }
-        if (Object.keys(updates).length > 0) {
-            logger$3(`Applying updates to schema "${schema.name}" (id: ${existingSchemas[0].id}):`, Object.keys(updates));
-            await db
-                .update(schemas)
-                .set(updates)
-                .where(eq(schemas.id, existingSchemas[0].id));
-            const updated = { ...existingSchemas[0], ...updates };
-            logger$3(`Schema "${schema.name}" updated. New schemaFileId: "${updated.schemaFileId}", isDraft: ${updated.isDraft}`);
-            return updated;
-        }
-        logger$3(`No updates needed for schema "${schema.name}" (id: ${existingSchemas[0].id})`);
-        return existingSchemas[0];
-    }
-    const newSchema = await db.insert(schemas).values({
-        name: schema.name,
-        version: schema.version,
-        schemaFileId: schemaFileId || null,
-        schemaData: schemaData || null,
-        isDraft: isDraft ?? false,
-        isEdited: isEdited ?? false,
-        createdAt: schema.createdAt,
-        updatedAt: schema.updatedAt,
-    }).returning();
-    // Notify React useSchemas so it can invalidate; live query often doesn't re-run when schemas table is inserted.
-    if (typeof BroadcastChannel !== 'undefined') {
-        try {
-            await new Promise((r) => setTimeout(r, 10));
-            postBroadcast('seed-schemas-invalidate', {});
-        }
-        catch (_) { }
-    }
-    return newSchema[0];
-};
-/**
- * Rename a model in the database
- * Updates the model name and all properties that reference it
- * @param oldName - The current model name
- * @param newName - The new model name
- * @param schemaNameOrId - Schema name or schema ID to scope the rename (required when multiple schemas have models with the same name)
- * @returns The updated model record
- */
-const renameModelInDb = async (oldName, newName, schemaNameOrId) => {
-    const db = BaseDb.getAppDb();
-    if (!db) {
-        throw new Error('Database not found');
-    }
-    const { schemas: schemasTable } = await Promise.resolve().then(function () { return SchemaSchema; });
-    // Find the model by old name, optionally scoped by schema
-    let existingModels;
-    if (schemaNameOrId !== undefined) {
-        if (typeof schemaNameOrId === 'number') {
-            const rows = await db
-                .select({
-                id: models.id,
-                name: models.name,
-                schemaFileId: models.schemaFileId,
-                isEdited: models.isEdited,
-            })
-                .from(models)
-                .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
-                .where(and(eq(models.name, oldName), eq(modelSchemas.schemaId, schemaNameOrId)))
-                .limit(1);
-            existingModels = rows;
-        }
-        else {
-            const rows = await db
-                .select({
-                id: models.id,
-                name: models.name,
-                schemaFileId: models.schemaFileId,
-                isEdited: models.isEdited,
-            })
-                .from(models)
-                .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
-                .innerJoin(schemasTable, eq(modelSchemas.schemaId, schemasTable.id))
-                .where(and(eq(models.name, oldName), eq(schemasTable.name, schemaNameOrId)))
-                .limit(1);
-            existingModels = rows;
-        }
-    }
-    else {
-        existingModels = await db
-            .select({
-            id: models.id,
-            name: models.name,
-            schemaFileId: models.schemaFileId,
-            isEdited: models.isEdited,
-        })
-            .from(models)
-            .where(eq(models.name, oldName));
-        // Model names are only unique per schema: an unscoped rename must not pick one arbitrarily.
-        if (existingModels.length > 1) {
-            throw new Error(`Model "${oldName}" exists in more than one schema; pass the schema name or id to rename it`);
-        }
-    }
-    if (existingModels.length === 0) {
-        if (schemaNameOrId !== undefined) {
-            throw new Error(`Model "${oldName}" not found in schema "${schemaNameOrId}"`);
-        }
-        // Backward compat: model doesn't exist, create it with new name
-        const newModel = await db.insert(models).values({ name: newName }).returning();
-        return newModel[0];
-    }
-    const modelToRename = existingModels[0];
-    // Check if a model with the new name already exists in the same schema
-    let existingWithNewName;
-    if (schemaNameOrId !== undefined) {
-        if (typeof schemaNameOrId === 'number') {
-            existingWithNewName = await db
-                .select({
-                id: models.id,
-                name: models.name,
-                schemaFileId: models.schemaFileId,
-                isEdited: models.isEdited,
-            })
-                .from(models)
-                .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
-                .where(and(eq(models.name, newName), eq(modelSchemas.schemaId, schemaNameOrId)))
-                .limit(1);
-        }
-        else {
-            existingWithNewName = await db
-                .select({
-                id: models.id,
-                name: models.name,
-                schemaFileId: models.schemaFileId,
-                isEdited: models.isEdited,
-            })
-                .from(models)
-                .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
-                .innerJoin(schemasTable, eq(modelSchemas.schemaId, schemasTable.id))
-                .where(and(eq(models.name, newName), eq(schemasTable.name, schemaNameOrId)))
-                .limit(1);
-        }
-    }
-    else {
-        existingWithNewName = await db
-            .select({
-            id: models.id,
-            name: models.name,
-            schemaFileId: models.schemaFileId,
-            isEdited: models.isEdited,
-        })
-            .from(models)
-            .where(eq(models.name, newName))
-            .limit(1);
-    }
-    if (existingWithNewName.length > 0) {
-        // New name already exists in this schema, return it
-        return existingWithNewName[0];
-    }
-    // Update the model name
-    await db
-        .update(models)
-        .set({ name: newName })
-        .where(eq(models.id, modelToRename.id));
-    return { ...modelToRename, name: newName };
-};
-/**
- * Adds models and their properties to the database.
- * Optionally connects models to a schema via join records.
- * @param models - The model definitions to add
- * @param schema - Optional schema to connect models to
- * @param modelRenames - Optional map of old model names to new model names for handling renames
- * @param schemaFileData - Optional object containing schemaFileId mappings from JSON file: { schemaFileId, modelFileIds: Map<modelName, id>, propertyFileIds: Map<modelName, Map<propertyName, id>> }
- */
-const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) => {
-    const db = BaseDb.getAppDb();
-    if (!db) {
-        throw new Error('Database not found');
-    }
-    // Model rows and their schema links decide which schema file's nameMatch applies (ADR 0009).
-    clearNameMatchLevels();
-    // If schema is provided, add it to the database
-    // Note: schema might already be a database record (with id) if passed from importJsonSchema
-    let schemaRecord;
-    if (schema) {
-        // Check if schema already has an id (it's already a database record)
-        // SchemaType includes id, so check if it's set
-        if (schema.id !== null && schema.id !== undefined) {
-            schemaRecord = schema;
-            logger$3(`Using existing schema record with id: ${schemaRecord.id}`);
-        }
-        else {
-            schemaRecord = await addSchemaToDb(schema, schemaFileData?.schemaFileId);
-            logger$3(`Created/found schema record with id: ${schemaRecord.id}`);
-        }
-    }
-    // Handle model renames first if provided
-    if (modelRenames && schemaRecord) {
-        const schemaNameOrId = schemaRecord.name ?? schemaRecord.id;
-        for (const [oldName, newName] of modelRenames.entries()) {
-            await renameModelInDb(oldName, newName, schemaNameOrId);
-        }
-    }
-    // Search for all models by schemaFileId (preferred) or name and create them if they don't exist
-    const modelRecords = new Map();
-    const modelProcessingErrors = [];
-    // Property rows this call changed, so cached ModelProperty instances can be given the new values
-    const updatedPropertyFileIds = [];
-    for (const [modelName, modelClass] of Object.entries(models$1)) {
-        try {
-            const modelFileId = schemaFileData?.modelFileIds?.get(modelName);
-            let modelRecord = await findOrCreateModelRecord(db, modelName, modelFileId, schemaRecord?.id);
-            // Keep schemaFileId aligned when findOrCreate returned a row that still needs adoption
-            // (rare: findOrCreate handles stubs and unclaimed same-name rows itself).
-            if (modelFileId && modelRecord.schemaFileId !== modelFileId) {
-                const existingWithFileId = await db
-                    .select()
-                    .from(models)
-                    .where(eq(models.schemaFileId, modelFileId))
-                    .limit(1);
-                if (existingWithFileId.length > 0 && existingWithFileId[0].id !== modelRecord.id) {
-                    logger$3(`WARNING: Model "${modelName}" (id: ${modelRecord.id}) conflicts with existing model "${existingWithFileId[0].name}" (id: ${existingWithFileId[0].id}) both trying to use schemaFileId "${modelFileId}"`);
-                    modelRecord = existingWithFileId[0];
-                }
-                else if (!modelRecord.schemaFileId) {
-                    await db
-                        .update(models)
-                        .set({ schemaFileId: modelFileId })
-                        .where(eq(models.id, modelRecord.id));
-                    modelRecord = { ...modelRecord, schemaFileId: modelFileId };
-                }
-            }
-            modelRecords.set(modelName, modelRecord);
-            // Get all existing properties for this model upfront to handle renamed properties
-            const allDbProperties = await db
-                .select()
-                .from(properties)
-                .where(eq(properties.modelId, modelRecord.id));
-            // Track which DB properties have been matched to schema properties
-            const matchedDbPropertyIds = new Set();
-            // Get properties from Model context (where they're stored as an object when Model is created)
-            // modelClass.properties returns ModelProperty instances from DB, but we need the context properties
-            // which are stored as an object when Model.create() is called with properties
-            const modelContext = modelClass._getSnapshotContext?.() || {};
-            const contextProperties = modelContext.properties || {};
-            // When models are created from JSON, properties are stored as _pendingPropertyDefinitions
-            const pendingProperties = modelContext._pendingPropertyDefinitions || {};
-            // If context properties are empty, try modelClass.properties (for backward compatibility)
-            // but convert ModelProperty instances to object format
-            // Property definitions read from the schema file win: a cached Model keeps the properties it
-            // was created with, so after a rename its context still has the old name.
-            const filePropertyDefinitions = schemaFileData?.propertyDefinitions?.get(modelName);
-            let schema = {};
-            if (filePropertyDefinitions) {
-                schema = filePropertyDefinitions;
-            }
-            else if (Object.keys(contextProperties).length > 0) {
-                schema = contextProperties;
-            }
-            else if (Object.keys(pendingProperties).length > 0) {
-                // Use pending property definitions (from JSON import)
-                schema = pendingProperties;
-            }
-            else {
-                const modelHelpersMod = await import('./model-oHA3YhOd.js');
-                const { modelPropertiesToObject } = modelHelpersMod;
-                const modelProperties = modelClass.properties || [];
-                schema = modelPropertiesToObject(modelProperties);
-            }
-            // Search for all properties and create them if they don't exist
-            // Properties are unique by name + modelId, so we search using both
-            const schemaEntries = Object.entries(schema);
-            for (let index = 0; index < schemaEntries.length; index++) {
-                const [propertyName, propertyValues] = schemaEntries[index];
-                if (!propertyValues) {
-                    throw new Error(`Property values not found for ${propertyName}`);
-                }
-                // Get property schemaFileId if available
-                let propertyFileId = schemaFileData?.propertyFileIds?.get(modelName)?.get(propertyName);
-                const propertyFileIdGenerated = !propertyFileId;
-                // If no propertyFileId from map, generate a random ID
-                // IDs should be generated in the import process before calling addModelsToDb
-                if (!propertyFileId) {
-                    const { generateId } = await Promise.resolve().then(function () { return generateId$1; });
-                    propertyFileId = generateId();
-                    logger$3(`Generated propertyFileId "${propertyFileId}" for property "${modelName}:${propertyName}" (not found in propertyFileIds map)`);
-                }
-                // First, try to find by schemaFileId (preferred for change tracking)
-                let existingProperty;
-                if (propertyFileId) {
-                    existingProperty = allDbProperties.find((p) => p.schemaFileId === propertyFileId && !matchedDbPropertyIds.has(p.id));
-                }
-                // Fallback: check if property exists by name + modelId
-                if (!existingProperty) {
-                    existingProperty = allDbProperties.find((p) => p.name === propertyName && !matchedDbPropertyIds.has(p.id));
-                }
-                // Prepare property values
-                const propertyData = {
-                    name: propertyName,
-                    modelId: modelRecord.id,
-                    dataType: normalizeDataType(propertyValues.dataType),
-                    schemaFileId: propertyFileId || null,
-                    required: propertyValues.required ?? false,
-                    // The schema file is the source of truth here: no storage config means none.
-                    ...propertyStorageColumns(propertyValues),
-                };
-                // Handle ref property - create ref model if needed
-                // Check both ref and refModelName (refModelName is set by createModelFromJson)
-                const refModelName = propertyValues.ref || propertyValues.refModelName;
-                if (refModelName) {
-                    // When ref model was already processed in this batch, use it (avoids db round-trip)
-                    const cachedRef = modelRecords.get(refModelName);
-                    const refModelFileId = schemaFileData?.modelFileIds?.get(refModelName);
-                    const refModel = cachedRef
-                        ? cachedRef
-                        : await findOrCreateModelRecord(db, refModelName, refModelFileId, schemaRecord?.id);
-                    if (!cachedRef) {
-                        modelRecords.set(refModelName, refModel);
-                    }
-                    propertyData.refModelId = refModel.id ?? null;
-                }
-                else {
-                    // If it's not a Relation type, ensure refModelId is null
-                    propertyData.refModelId = null;
-                }
-                if (propertyValues.refValueType) {
-                    propertyData.refValueType = normalizeDataType(propertyValues.refValueType);
-                }
-                else {
-                    // If refValueType is not set, ensure it's null
-                    propertyData.refValueType = null;
-                }
-                // ADR 0008: a rename needs the property's id. A name that matches no stored property by id
-                // or name is a new property, even if one of the same type was removed in the same edit.
-                if (existingProperty) {
-                    // Mark this DB property as matched
-                    matchedDbPropertyIds.add(existingProperty.id);
-                    // A property edited locally keeps its row.
-                    const isPropertyEdited = existingProperty.isEdited === true;
-                    if (isPropertyEdited) {
-                        // Property has been locally edited - skip update to preserve local changes
-                        logger$3(`Skipping update for property ${modelName}:${existingProperty.name} -> ${propertyName} - it has been locally edited and will be preserved`);
-                        continue;
-                    }
-                    // Property exists (possibly with different name) - update it with new values from schema file
-                    // This handles both regular updates and renames
-                    // Ensure schemaFileId is updated if we have it
-                    // Preserve existing isEdited value if it was true (local edits take precedence)
-                    const updateData = { ...propertyData };
-                    // A generated id must not replace the one the row already has from its schema file
-                    if (propertyFileIdGenerated && existingProperty.schemaFileId) {
-                        updateData.schemaFileId = existingProperty.schemaFileId;
-                    }
-                    if (existingProperty.isEdited === true) {
-                        // Preserve isEdited = true if property was locally edited
-                        delete updateData.isEdited;
-                    }
-                    else {
-                        updateData.isEdited = false;
-                    }
-                    // Skip db.update when data unchanged (avoids slow OPFS writes in browser)
-                    const unchanged = existingProperty.name === updateData.name &&
-                        existingProperty.dataType === updateData.dataType &&
-                        existingProperty.schemaFileId === (updateData.schemaFileId ?? null) &&
-                        existingProperty.required === (updateData.required ?? false) &&
-                        existingProperty.refModelId === (updateData.refModelId ?? null) &&
-                        existingProperty.refValueType === (updateData.refValueType ?? null) &&
-                        (existingProperty.storageType ?? null) === (updateData.storageType ?? null) &&
-                        (existingProperty.localStorageDir ?? null) === (updateData.localStorageDir ?? null) &&
-                        (existingProperty.filenameSuffix ?? null) === (updateData.filenameSuffix ?? null) &&
-                        existingProperty.isEdited === (updateData.isEdited ?? false);
-                    if (!unchanged) {
-                        await db
-                            .update(properties)
-                            .set(updateData)
-                            .where(eq(properties.id, existingProperty.id));
-                        const updatedFileId = updateData.schemaFileId ?? existingProperty.schemaFileId;
-                        if (updatedFileId)
-                            updatedPropertyFileIds.push(updatedFileId);
-                    }
-                    if (existingProperty.name !== propertyName) {
-                        // Renamed (matched by id): its values move to the new name.
-                        await moveMetadataToRenamedProperty(db, {
-                            propertyId: existingProperty.id,
-                            modelType: easName(modelName),
-                            oldName: existingProperty.name,
-                            newName: propertyName,
-                            propertyDef: propertyValues,
-                        });
-                    }
-                }
-                else {
-                    // Property doesn't exist, create it with schemaFileId
-                    // Set isEdited = false when loading from schema file
-                    const propertyDataWithIsEdited = {
-                        ...propertyData,
-                        isEdited: false,
-                    };
-                    // Global schemaFileId lookup (unique across all models) before insert — avoids
-                    // UNIQUE races when the property already exists on another model row or from a prior pass.
-                    if (propertyFileId) {
-                        const existingByFileId = await db
-                            .select()
-                            .from(properties)
-                            .where(eq(properties.schemaFileId, propertyFileId))
-                            .limit(1);
-                        if (existingByFileId.length > 0) {
-                            const found = existingByFileId[0];
-                            matchedDbPropertyIds.add(found.id);
-                            logger$3(`Property ${modelName}:${propertyName} already exists by schemaFileId "${propertyFileId}" (id: ${found.id}), skipping insert`);
-                            continue;
-                        }
-                    }
-                    logger$3(`Creating new property ${modelName}:${propertyName} with schemaFileId: ${propertyData.schemaFileId}`);
-                    // A conflict means the row already exists: the schema import's Model instances write their
-                    // properties at the same time as this. DO NOTHING keeps sqlite-wasm from logging a failed insert.
-                    const inserted = await db
-                        .insert(properties)
-                        .values(propertyDataWithIsEdited)
-                        .onConflictDoNothing()
-                        .returning({ id: properties.id });
-                    if (inserted.length === 0) {
-                        logger$3(`Property ${modelName}:${propertyName} already exists (UNIQUE constraint), treating as success`);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            const errorMessage = error?.message || String(error);
-            logger$3(`Error processing model "${modelName}": ${errorMessage}`);
-            modelProcessingErrors.push({ modelName, error: errorMessage });
-            // Continue processing other models even if one fails
-        }
-    }
-    if (modelProcessingErrors.length > 0) {
-        console.warn(`[addModelsToDb] Errors occurred while processing ${modelProcessingErrors.length} model(s):`, modelProcessingErrors.map(e => `${e.modelName}: ${e.error}`).join('; '));
-        logger$3(`Errors processing models: ${modelProcessingErrors.map(e => e.modelName).join(', ')}`);
-    }
-    // If schema was provided, create modelSchema join records to connect models to the schema
-    if (schemaRecord && schemaRecord.id) {
-        const modelIds = [...modelRecords.entries()]
-            .filter(([, r]) => r.id)
-            .map(([name, r]) => ({ modelName: name, modelId: r.id }));
-        if (modelIds.length === 0) {
-            logger$3('No model IDs to link, skipping schema linking');
-        }
-        else {
-            // Single batch query: get all existing joins for this schema
-            const existingJoins = await db
-                .select({ modelId: modelSchemas.modelId })
-                .from(modelSchemas)
-                .where(eq(modelSchemas.schemaId, schemaRecord.id));
-            const existingSet = new Set(existingJoins.map((r) => r.modelId));
-            const toInsert = modelIds.filter(({ modelId }) => !existingSet.has(modelId));
-            if (toInsert.length > 0) {
-                for (const { modelName, modelId } of toInsert) {
-                    if (!(await linkModelToSchema(db, modelId, schemaRecord.id)))
-                        continue;
-                    logger$3(`Created join table entry for model ${modelName} (id: ${modelId}) to schema (id: ${schemaRecord.id})`);
-                }
-            }
-        }
-    }
-    else if (schemaRecord && !schemaRecord.id) {
-        logger$3(`Warning: schemaRecord provided but has no id, cannot create join table entries`);
-    }
-    // A cached instance is otherwise never re-read from its row (createById returns it as is)
-    await refreshCachedProperties(updatedPropertyFileIds);
-};
-/**
- * Loads models from the database for a given schema by querying the model_schemas join table.
- * This ensures that models added to the database (via model_schemas) are included even if
- * they're not in the schemaData JSON.
- * @param schemaId - The ID of the schema record in the database
- * @returns A map of model names to model data (compatible with SchemaFileFormat.models)
- */
-const loadModelsFromDbForSchema = async (schemaId) => {
-    const db = BaseDb.getAppDb();
-    if (!db) {
-        logger$3('Database not found, cannot load models from DB');
-        return {};
-    }
-    try {
-        // Query model_schemas join table to find all models linked to this schema
-        const modelSchemaRecords = await db
-            .select({
-            modelId: modelSchemas.modelId,
-            modelName: models.name,
-            schemaFileId: models.schemaFileId,
-        })
-            .from(modelSchemas)
-            .innerJoin(models, eq(modelSchemas.modelId, models.id))
-            .where(eq(modelSchemas.schemaId, schemaId));
-        const models$1 = {};
-        // For each model, load its properties
-        for (const { modelId, modelName, schemaFileId } of modelSchemaRecords) {
-            if (!modelId || !modelName)
-                continue;
-            // Get all properties for this model
-            const propertyRecords = await db
-                .select()
-                .from(properties)
-                .where(eq(properties.modelId, modelId));
-            // Reconstruct properties object
-            const modelProperties = {};
-            for (const prop of propertyRecords) {
-                // Build a basic property structure from database fields
-                // Note: This is a simplified reconstruction - full property schemas
-                // (like Relation details, List configs, etc.) should come from schemaData
-                const propertyData = {
-                    dataType: normalizeDataType(prop.dataType ?? undefined),
-                };
-                if (prop.schemaFileId) {
-                    propertyData.schemaFileId = prop.schemaFileId;
-                }
-                // Add ref information if it's a relation
-                if (prop.refModelId) {
-                    // Get the referenced model name
-                    const refModelRecords = await db
-                        .select({ name: models.name })
-                        .from(models)
-                        .where(eq(models.id, prop.refModelId))
-                        .limit(1);
-                    if (refModelRecords.length > 0) {
-                        propertyData.ref = refModelRecords[0].name;
-                    }
-                }
-                if (prop.refValueType) {
-                    propertyData.refValueType = normalizeDataType(prop.refValueType ?? undefined);
-                }
-                if (prop.storageType)
-                    propertyData.storageType = prop.storageType;
-                if (prop.localStorageDir)
-                    propertyData.localStorageDir = prop.localStorageDir;
-                if (prop.filenameSuffix)
-                    propertyData.filenameSuffix = prop.filenameSuffix;
-                modelProperties[prop.name] = propertyData;
-            }
-            // Create model structure. Include id (schemaFileId) so processSchemaFiles can populate
-            // modelFileIds and Model.create can skip duplicate-name logic, preventing model
-            // duplication on reload (Post 1 1, Post 2 1, etc.).
-            models$1[modelName] = {
-                properties: modelProperties,
-                ...(schemaFileId ? { id: schemaFileId } : {}),
-                // Note: description would need to be stored separately
-                // or reconstructed from schemaData if available
-            };
-        }
-        logger$3(`Loaded ${Object.keys(models$1).length} models from database for schema ${schemaId}`);
-        return models$1;
-    }
-    catch (error) {
-        logger$3(`Error loading models from database for schema ${schemaId}:`, error);
-        return {};
-    }
-};
-/**
- * Merges the models {@link loadModelsFromDbForSchema} read from the database into a schema's
- * models. The database decides which models and properties exist and their stored fields; the
- * schema keeps what only it holds (nameMatch, description, validation, ...), found by id first so
- * a property renamed in the database keeps them. A schema property whose id a database property
- * has is dropped under its old name.
- */
-const mergeDbModelsIntoSchemaModels = (schemaModels, dbModels) => {
-    const merged = { ...(schemaModels ?? {}) };
-    for (const [modelName, dbModel] of Object.entries(dbModels)) {
-        const schemaModel = schemaModels?.[modelName];
-        if (!schemaModel) {
-            merged[modelName] = dbModel;
-            continue;
-        }
-        const schemaProps = schemaModel.properties ?? {};
-        const dbProps = dbModel.properties ?? {};
-        const schemaNameById = new Map();
-        for (const [name, prop] of Object.entries(schemaProps)) {
-            const id = prop?.id ?? prop?.schemaFileId;
-            if (id)
-                schemaNameById.set(id, name);
-        }
-        const properties = {};
-        const matched = new Set();
-        for (const [name, dbProp] of Object.entries(dbProps)) {
-            const byId = dbProp?.schemaFileId ? schemaNameById.get(dbProp.schemaFileId) : undefined;
-            const byName = schemaProps[name];
-            const byNameId = byName?.id ?? byName?.schemaFileId;
-            // By name only when the ids don't say it's another property.
-            const schemaName = byId ?? (byName && !(byNameId && dbProp?.schemaFileId && byNameId !== dbProp.schemaFileId) ? name : undefined);
-            const schemaProp = schemaName ? schemaProps[schemaName] : undefined;
-            if (schemaName && schemaProp)
-                matched.add(schemaName);
-            // The database's dataType and ref replace the file's type and model.
-            const { type, model, ...fromSchema } = schemaProp ?? {};
-            properties[name] = {
-                ...fromSchema,
-                ...(dbProp?.dataType === undefined && type !== undefined ? { type } : {}),
-                ...(dbProp?.ref === undefined && model !== undefined ? { model } : {}),
-                ...dbProp,
-            };
-        }
-        const unmatched = Object.fromEntries(Object.entries(schemaProps).filter(([name]) => !matched.has(name)));
-        merged[modelName] = { ...schemaModel, ...dbModel, properties: { ...unmatched, ...properties } };
-    }
-    return merged;
-};
-/**
- * Returns model name by database model ID.
- */
-async function getModelNameByModelId(modelId) {
-    const db = BaseDb.getAppDb();
-    if (!db)
-        return undefined;
-    try {
-        const rows = await db
-            .select({ name: models.name })
-            .from(models)
-            .where(eq(models.id, modelId))
-            .limit(1);
-        return rows.length > 0 ? rows[0].name : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Resolves modelName and dataType for a property by its schemaFileId (e.g. context.id).
- * Used when machine context lacks these (e.g. just-created property renamed before full context is set).
- */
-async function getPropertyModelNameAndDataType(schemaFileId) {
-    const db = BaseDb.getAppDb();
-    if (!db || !schemaFileId)
-        return undefined;
-    try {
-        const rows = await db
-            .select({
-            dataType: properties.dataType,
-            modelId: properties.modelId,
-        })
-            .from(properties)
-            .where(eq(properties.schemaFileId, schemaFileId))
-            .limit(1);
-        if (rows.length === 0)
-            return undefined;
-        const modelRows = await db
-            .select({ name: models.name })
-            .from(models)
-            .where(eq(models.id, rows[0].modelId))
-            .limit(1);
-        if (modelRows.length === 0)
-            return undefined;
-        return {
-            modelName: modelRows[0].name,
-            dataType: rows[0].dataType ?? '',
-        };
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Saves a property's changes to the database without updating the JSON schema file.
- * This is used when properties are edited but the schema hasn't been saved as a new version yet.
- * @param property - The ModelPropertyMachineContext with updated values
- */
-const savePropertyToDb = async (property) => {
-    const db = BaseDb.getAppDb();
-    if (!db) {
-        throw new Error('Database not found');
-    }
-    if (!property.name) {
-        throw new Error('Property name is required');
-    }
-    // Find the model: prefer modelId (reliable), then modelName as name, then modelName as schemaFileId
-    // (context.modelName can be a model schemaFileId when schema uses that as identifier)
-    let modelRecord;
-    if (property.modelId != null && typeof property.modelId === 'number') {
-        const byId = await db
-            .select()
-            .from(models)
-            .where(eq(models.id, property.modelId))
-            .limit(1);
-        modelRecord = byId[0];
-    }
-    if (!modelRecord && property.modelName) {
-        // Model names are only unique per schema: scope by the property's schema when known
-        modelRecord = await resolveModelRecord(property.modelName, { schemaName: property._schemaName }, db);
-    }
-    if (!modelRecord && property.modelName) {
-        const bySchemaFileId = await db
-            .select()
-            .from(models)
-            .where(eq(models.schemaFileId, property.modelName))
-            .limit(1);
-        modelRecord = bySchemaFileId[0];
-    }
-    // Fallback: resolve model from existing property row (by schemaFileId) when modelName is wrong
-    const schemaFileId = property._propertyFileId || (typeof property.id === 'string' ? property.id : undefined);
-    if (!modelRecord && schemaFileId) {
-        const propRows = await db
-            .select({ modelId: properties.modelId })
-            .from(properties)
-            .where(eq(properties.schemaFileId, schemaFileId))
-            .limit(1);
-        if (propRows.length > 0 && propRows[0].modelId) {
-            const byPropModelId = await db
-                .select()
-                .from(models)
-                .where(eq(models.id, propRows[0].modelId))
-                .limit(1);
-            modelRecord = byPropModelId[0];
-        }
-    }
-    if (!modelRecord) {
-        throw new Error(`Model not found in database (modelId=${property.modelId}, modelName=${property.modelName})`);
-    }
-    // Find existing property - try multiple strategies to handle name changes
-    // 1. First try by schemaFileId (most reliable - doesn't change when name changes)
-    let existingProperties = [];
-    logger$3(`[savePropertyToDb] Looking for property ${property.modelName}:${property.name} (schemaFileId: ${schemaFileId}, originalName: ${property._originalValues?.name})`);
-    if (schemaFileId) {
-        existingProperties = await db
-            .select()
-            .from(properties)
-            .where(and(eq(properties.schemaFileId, schemaFileId), eq(properties.modelId, modelRecord.id)))
-            .limit(1);
-        logger$3(`[savePropertyToDb] Found ${existingProperties.length} properties by schemaFileId`);
-    }
-    // 2. If not found by schemaFileId, try by original name (if name was changed)
-    if (existingProperties.length === 0 && property._originalValues?.name && property._originalValues.name !== property.name) {
-        logger$3(`[savePropertyToDb] Trying to find by original name: ${property._originalValues.name}`);
-        existingProperties = await db
-            .select()
-            .from(properties)
-            .where(and(eq(properties.name, property._originalValues.name), eq(properties.modelId, modelRecord.id)))
-            .limit(1);
-        logger$3(`[savePropertyToDb] Found ${existingProperties.length} properties by original name`);
-    }
-    // 3. Fallback: try by current name
-    if (existingProperties.length === 0) {
-        logger$3(`[savePropertyToDb] Trying to find by current name: ${property.name}`);
-        existingProperties = await db
-            .select()
-            .from(properties)
-            .where(and(eq(properties.name, property.name), eq(properties.modelId, modelRecord.id)))
-            .limit(1);
-        logger$3(`[savePropertyToDb] Found ${existingProperties.length} properties by current name`);
-    }
-    // Prepare property data
-    const propertyData = {
-        name: property.name,
-        modelId: modelRecord.id,
-        dataType: normalizeDataType(property.dataType),
-    };
-    // Preserve schemaFileId if we have it
-    if (schemaFileId) {
-        propertyData.schemaFileId = schemaFileId;
-    }
-    // Handle ref property - create ref model if needed
-    if (property.refModelName) {
-        const refModel = await findOrCreateRefModelRecord(db, property.refModelName, modelRecord.id);
-        propertyData.refModelId = refModel.id;
-    }
-    else if (property.refModelId) {
-        propertyData.refModelId = property.refModelId;
-    }
-    else {
-        // If it's not a Relation type, ensure refModelId is null
-        propertyData.refModelId = null;
-    }
-    if (property.refValueType) {
-        propertyData.refValueType = normalizeDataType(property.refValueType);
-    }
-    else {
-        // If refValueType is not set, ensure it's null
-        propertyData.refValueType = null;
-    }
-    propertyData.required = property.required ?? false;
-    // Only when the context has storage settings: a context built without them (e.g. loaded before
-    // they were stored) must not clear the row's.
-    const storage = propertyStorageColumns(property);
-    if (hasStorageSettings(storage)) {
-        Object.assign(propertyData, storage);
-    }
-    if (existingProperties.length > 0) {
-        // Property exists, update it with new values (including new name)
-        // Set isEdited = true when property is edited
-        const existingProperty = existingProperties[0];
-        await db
-            .update(properties)
-            .set({
-            ...propertyData,
-            isEdited: true, // Mark as edited when saving changes
-        })
-            .where(eq(properties.id, existingProperty.id));
-        logger$3(`Updated property ${property.modelName}:${property._originalValues?.name || 'unknown'} -> ${property.name} in database`);
-    }
-    else {
-        // Property doesn't exist, create it
-        // Set isEdited = true for runtime-created properties
-        // A conflict means the row already exists (concurrent addModelsToDb or another write): treat as success
-        const inserted = await db
-            .insert(properties)
-            .values({
-            ...propertyData,
-            isEdited: true, // Runtime-created properties are edited
-        })
-            .onConflictDoNothing()
-            .returning({ id: properties.id });
-        if (inserted.length > 0) {
-            logger$3(`Created property ${property.modelName}:${property.name} in database`);
-        }
-        else {
-            logger$3(`Property ${property.modelName}:${property.name} already exists (UNIQUE constraint), treating as success`);
-        }
-    }
-};
-function parseAddressConfig(value) {
-    if (!value)
-        return null;
-    try {
-        const parsed = JSON.parse(value);
-        if (Array.isArray(parsed)) {
-            return normalizeAddressConfig(parsed);
-        }
-        if (parsed && typeof parsed === 'object' && Array.isArray(parsed.owned)) {
-            return normalizeAddressConfig({
-                owned: parsed.owned,
-                watched: Array.isArray(parsed.watched) ? parsed.watched : [],
-            });
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-const getOwnedAddressesFromDb = async () => {
-    const config = await getAddressConfigFromDb();
-    return config?.owned ?? [];
-};
-const getWatchedAddressesFromDb = async () => {
-    const config = await getAddressConfigFromDb();
-    return config?.watched ?? [];
-};
-/**
- * Returns persisted owned or watched addresses for list filters.
- * Does not include `getAdditionalSyncAddresses` (those are extra EAS indexers).
- */
-const getAddressesForItemsFilter = async (addressFilter) => {
-    if (addressFilter === 'owned') {
-        return getOwnedAddressesFromDb();
-    }
-    return getWatchedAddressesFromDb();
-};
-/**
- * Returns owned + watched addresses. Use for EAS sync and file download.
- */
-const getAllAddressesFromDb = async () => {
-    const config = await getAddressConfigFromDb();
-    if (!config)
-        return [];
-    return [...config.owned, ...config.watched];
-};
-async function getAddressConfigFromDb() {
-    const appDb = BaseDb.getAppDb();
-    if (!appDb) {
-        return new Promise((resolve) => {
-            setTimeout(async () => {
-                resolve(await getAddressConfigFromDb());
-            }, 500);
-        });
-    }
-    const appStatesRecords = await appDb
-        .select()
-        .from(appState)
-        .where(eq(appState.key, 'addresses'))
-        .limit(1);
-    if (!appStatesRecords || appStatesRecords.length === 0) {
-        return null;
-    }
-    const addressArrayString = appStatesRecords[0].value;
-    return parseAddressConfig(addressArrayString);
-}
-/**
- * Write model to database and create model_schemas join entry
- * @param modelFileId - The model file ID (schema_file_id)
- * @param data - Model data including modelName, schemaId, and optional properties
- */
-async function writeModelToDb(modelFileId, data) {
-    const db = BaseDb.getAppDb();
-    if (!db)
-        throw new Error('Database not available');
-    // Find or create model record
-    const modelRecords = await db
-        .select()
-        .from(models)
-        .where(eq(models.schemaFileId, modelFileId))
-        .limit(1);
-    let modelId;
-    if (modelRecords.length === 0) {
-        // Create new model record
-        // Check again right before insert to avoid race conditions
-        const doubleCheck = await db
-            .select()
-            .from(models)
-            .where(eq(models.schemaFileId, modelFileId))
-            .limit(1);
-        if (doubleCheck.length > 0) {
-            // Another process created it, use existing
-            modelId = doubleCheck[0].id;
-            logger$3(`Model with schemaFileId "${modelFileId}" was created by another process, using existing record (id: ${modelId})`);
-        }
-        else {
-            // DO NOTHING on conflict: addModelsToDb writes the same row during schema import, and a failed
-            // insert is logged by sqlite-wasm even when caught.
-            const newModel = await db
-                .insert(models)
-                .values({
-                name: data.modelName,
-                schemaFileId: modelFileId,
-                isEdited: true, // Runtime-created models are edited
-            })
-                .onConflictDoNothing()
-                .returning();
-            if (newModel.length > 0) {
-                modelId = newModel[0].id;
-            }
-            else {
-                const existing = await db
-                    .select()
-                    .from(models)
-                    .where(eq(models.schemaFileId, modelFileId))
-                    .limit(1);
-                if (existing.length === 0) {
-                    throw new Error(`Failed to create or find model "${data.modelName}" with schemaFileId "${modelFileId}"`);
-                }
-                modelId = existing[0].id;
-                logger$3(`Found existing model with schemaFileId "${modelFileId}" (id: ${modelId}) after insert conflict`);
-            }
-        }
-    }
-    else {
-        // Update existing model record
-        modelId = modelRecords[0].id;
-        const updates = {};
-        if (data.modelName !== modelRecords[0].name) {
-            updates.name = data.modelName;
-        }
-        if (Object.keys(updates).length > 0) {
-            await db
-                .update(models)
-                .set(updates)
-                .where(eq(models.id, modelId));
-        }
-    }
-    // Validate that modelId and schemaId are valid before creating join entry
-    if (!modelId || !Number.isInteger(modelId) || modelId <= 0) {
-        throw new Error(`Invalid modelId: ${modelId}. Model record must be created successfully before creating join entry.`);
-    }
-    if (!data.schemaId || !Number.isInteger(data.schemaId) || data.schemaId <= 0) {
-        throw new Error(`Invalid schemaId: ${data.schemaId}. Schema record must exist before creating join entry.`);
-    }
-    // Create model_schemas join entry
-    // CRITICAL: This must happen AFTER the model record is fully saved and committed
-    // The modelId comes from .returning() which ensures the record is committed
-    const existingJoin = await db
-        .select()
-        .from(modelSchemas)
-        .where(and(eq(modelSchemas.modelId, modelId), eq(modelSchemas.schemaId, data.schemaId)))
-        .limit(1);
-    if (existingJoin.length === 0) {
-        // Only provide modelId and schemaId - id is auto-increment and should not be included
-        // Don't use type cast - let Drizzle infer the correct type without id
-        // Verify both modelId and schemaId exist before inserting join record
-        try {
-            // Verify modelId exists
-            const modelCheck = await db
-                .select({ id: models.id })
-                .from(models)
-                .where(eq(models.id, modelId))
-                .limit(1);
-            if (modelCheck.length === 0) {
-                throw new Error(`Model with id ${modelId} does not exist in database. Cannot create join record.`);
-            }
-            // Verify schemaId exists and get name/fileId for invalidation broadcast
-            const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
-            const { schemas: schemasTable } = schemaSchemaMod;
-            const schemaCheck = await db
-                .select({
-                id: schemasTable.id,
-                name: schemasTable.name,
-                schemaFileId: schemasTable.schemaFileId,
-            })
-                .from(schemasTable)
-                .where(eq(schemasTable.id, data.schemaId))
-                .limit(1);
-            if (schemaCheck.length === 0) {
-                throw new Error(`Schema with id ${data.schemaId} does not exist in database. Cannot create join record.`);
-            }
-            logger$3(`Creating join record: modelId=${modelId}, schemaId=${data.schemaId} (both verified to exist)`);
-            await linkModelToSchema(db, modelId, data.schemaId);
-            // Notify React useModels so it can invalidate; live query over join often doesn't re-run when model_schemas is inserted.
-            // Yield so the insert is visible to the refetch that will run when the broadcast is received.
-            if (typeof BroadcastChannel !== 'undefined') {
-                await new Promise((r) => setTimeout(r, 10));
-                const row = schemaCheck[0];
-                try {
-                    postBroadcast('seed-models-invalidate', {
-                        schemaName: row.name ?? undefined,
-                        schemaFileId: row.schemaFileId ?? undefined,
-                    });
-                }
-                catch (_) { }
-            }
-            logger$3(`Successfully created join record for model ${data.modelName} (id: ${modelId}) to schema (id: ${data.schemaId})`);
-        }
-        catch (error) {
-            if (error?.code === 'SQLITE_CONSTRAINT_FOREIGNKEY') {
-                logger$3(`FOREIGN KEY constraint failed when creating join record for model "${data.modelName}"`);
-                logger$3(`modelId: ${modelId}, schemaId: ${data.schemaId}`);
-                logger$3(`Error details:`, error);
-                // Re-throw with more context
-                throw new Error(`FOREIGN KEY constraint failed when creating join record for model "${data.modelName}" (modelId: ${modelId}, schemaId: ${data.schemaId}). ${error.message}`);
-            }
-            throw error;
-        }
-    }
-    // Write properties if provided
-    if (data.properties) {
-        for (const [propName, propData] of Object.entries(data.properties)) {
-            // Check if property already exists in database
-            const existingProps = await db
-                .select()
-                .from(properties)
-                .where(and(eq(properties.name, propName), eq(properties.modelId, modelId)))
-                .limit(1);
-            let propertyFileId;
-            if (existingProps.length > 0 && existingProps[0].schemaFileId) {
-                // Use existing property's schemaFileId
-                propertyFileId = existingProps[0].schemaFileId;
-                logger$3(`Using existing propertyFileId "${propertyFileId}" for property "${data.modelName}:${propName}"`);
-            }
-            else if (propData.id) {
-                // Use provided ID
-                propertyFileId = propData.id;
-            }
-            else {
-                // Generate random propertyFileId
-                // IDs should be generated in the import process before calling writeModelToDb
-                const { generateId } = await Promise.resolve().then(function () { return generateId$1; });
-                propertyFileId = generateId();
-                logger$3(`Generated propertyFileId "${propertyFileId}" for property "${data.modelName}:${propName}"`);
-            }
-            await writePropertyToDb(propertyFileId, {
-                modelId,
-                name: propName,
-                ...propData,
-            });
-        }
-    }
-    logger$3(`Wrote model ${data.modelName} (${modelFileId}) to database`);
-}
-/**
- * Write property to database
- * @param propertyFileId - The property file ID (schema_file_id)
- * @param data - Property data including modelId, name, dataType, and other property fields
- * @param isEdited - Optional flag indicating if property has been edited locally. Left unset, an update
- *   keeps the row's flag (a load or creation write must not clear an unsaved edit) and an insert stores false.
- */
-async function writePropertyToDb(propertyFileId, data, isEdited) {
-    const db = BaseDb.getAppDb();
-    if (!db)
-        throw new Error('Database not available');
-    // Find existing property by schemaFileId first (preferred for uniqueness)
-    let existingProperties = await db
-        .select()
-        .from(properties)
-        .where(eq(properties.schemaFileId, propertyFileId))
-        .limit(1);
-    // Fallback: find by modelId and name if not found by schemaFileId
-    if (existingProperties.length === 0) {
-        existingProperties = await db
-            .select()
-            .from(properties)
-            .where(and(eq(properties.name, data.name), eq(properties.modelId, data.modelId)))
-            .limit(1);
-    }
-    // Prepare property data
-    const propertyData = {
-        name: data.name,
-        modelId: data.modelId,
-        dataType: normalizeDataType(data.dataType),
-        schemaFileId: propertyFileId,
-        ...(isEdited !== undefined && { isEdited }),
-    };
-    // Handle ref property - create ref model if needed
-    // Check refModelName first, then ref (for backwards compatibility with schema files)
-    const refModelName = data.refModelName || data.ref;
-    if (refModelName) {
-        const refModel = await findOrCreateRefModelRecord(db, refModelName, data.modelId);
-        propertyData.refModelId = refModel.id;
-    }
-    else if (data.refModelId) {
-        propertyData.refModelId = data.refModelId;
-    }
-    else {
-        // If it's not a Relation type, ensure refModelId is null
-        propertyData.refModelId = null;
-    }
-    if (data.refValueType) {
-        propertyData.refValueType = normalizeDataType(data.refValueType);
-    }
-    else {
-        // If refValueType is not set, ensure it's null
-        propertyData.refValueType = null;
-    }
-    // Only overwrite `required` when the caller knows it. The creation write's payload can lack it, and
-    // defaulting to false here cleared the flag the schema import set (required relations became optional).
-    if (data.required !== undefined) {
-        propertyData.required = data.required;
-    }
-    // Storage settings, like `required`, only when the caller has them: the creation write's payload
-    // can lack them, and writing nulls would clear what the schema import stored.
-    const storage = propertyStorageColumns(data);
-    if (hasStorageSettings(storage)) {
-        Object.assign(propertyData, storage);
-    }
-    if (existingProperties.length > 0) {
-        // Property exists, update it with new values.
-        // Use existing row id for WHERE (not name+modelId) so renames work: the row
-        // may have the old name but we're updating to the new one.
-        const existing = existingProperties[0];
-        await db
-            .update(properties)
-            .set(propertyData)
-            .where(eq(properties.id, existing.id));
-        logger$3(`Updated property ${data.name} (${propertyFileId}) in database`);
-    }
-    else {
-        // Property doesn't exist, create it
-        // Double-check before insert to avoid race conditions
-        const doubleCheck = await db
-            .select()
-            .from(properties)
-            .where(eq(properties.schemaFileId, propertyFileId))
-            .limit(1);
-        if (doubleCheck.length > 0) {
-            // Another process created it, update it instead
-            await db
-                .update(properties)
-                .set(propertyData)
-                .where(eq(properties.id, doubleCheck[0].id));
-            logger$3(`Property with schemaFileId "${propertyFileId}" was created by another process, updated existing record`);
-        }
-        else {
-            // DO NOTHING on conflict: addModelsToDb writes the same row during schema import, and a failed
-            // insert is logged by sqlite-wasm even when caught.
-            const inserted = await db
-                .insert(properties)
-                .values({ required: false, isEdited: false, ...propertyData })
-                .onConflictDoNothing()
-                .returning({ id: properties.id });
-            if (inserted.length > 0) {
-                logger$3(`Created property ${data.name} (${propertyFileId}) in database`);
-            }
-            else {
-                const existing = await db
-                    .select()
-                    .from(properties)
-                    .where(eq(properties.schemaFileId, propertyFileId))
-                    .limit(1);
-                if (existing.length === 0) {
-                    throw new Error(`Failed to create or find property "${data.name}" with schemaFileId "${propertyFileId}"`);
-                }
-                await db
-                    .update(properties)
-                    .set(propertyData)
-                    .where(eq(properties.id, existing[0].id));
-                logger$3(`Found existing property with schemaFileId "${propertyFileId}" (id: ${existing[0].id}) after insert conflict, updated it`);
-            }
-        }
-    }
-}
-/**
- * Get model database ID from model name or modelFileId
- * @param modelNameOrFileId - Model name (string) or modelFileId (string)
- * @param schemaNameOrId - Optional schema name or ID to narrow search
- * @returns Model database ID
- * @throws Error if model not found
- */
-async function getModelId(modelNameOrFileId, schemaNameOrId) {
-    const db = BaseDb.getAppDb();
-    if (!db) {
-        throw new Error('Database not available');
-    }
-    const modelSchemaMod = await Promise.resolve().then(function () { return ModelSchema; });
-    const { models: modelsTable } = modelSchemaMod;
-    const drizzleMod = await import('drizzle-orm');
-    const { eq, and } = drizzleMod;
-    // Try to find by modelFileId first (more reliable)
-    let records = await db
-        .select()
-        .from(modelsTable)
-        .where(eq(modelsTable.schemaFileId, modelNameOrFileId))
-        .limit(1);
-    // If not found by modelFileId, try by name
-    if (records.length === 0) {
-        // If schema is provided, narrow the search
-        if (schemaNameOrId !== undefined) {
-            const modelSchemaSchemaMod = await Promise.resolve().then(function () { return ModelSchemaSchema; });
-            const { modelSchemas } = modelSchemaSchemaMod;
-            const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
-            const { schemas: schemasTable } = schemaSchemaMod;
-            if (typeof schemaNameOrId === 'number') {
-                // schemaNameOrId is schemaId
-                records = await db
-                    .select({ id: modelsTable.id })
-                    .from(modelsTable)
-                    .innerJoin(modelSchemas, eq(modelsTable.id, modelSchemas.modelId))
-                    .where(and(eq(modelsTable.name, modelNameOrFileId), eq(modelSchemas.schemaId, schemaNameOrId)))
-                    .limit(1);
-            }
-            else {
-                // schemaNameOrId is schemaName
-                records = await db
-                    .select({ id: modelsTable.id })
-                    .from(modelsTable)
-                    .innerJoin(modelSchemas, eq(modelsTable.id, modelSchemas.modelId))
-                    .innerJoin(schemasTable, eq(modelSchemas.schemaId, schemasTable.id))
-                    .where(and(eq(modelsTable.name, modelNameOrFileId), eq(schemasTable.name, schemaNameOrId)))
-                    .limit(1);
-            }
-        }
-        else {
-            // No schema filter: name-only (newest row, warns when the name is ambiguous)
-            const byName = await resolveModelRecord(modelNameOrFileId, {}, db);
-            records = byName ? [byName] : [];
-        }
-    }
-    if (records.length === 0) {
-        const schemaInfo = schemaNameOrId ? ` in schema "${schemaNameOrId}"` : '';
-        throw new Error(`Model "${modelNameOrFileId}"${schemaInfo} not found in database`);
-    }
-    return records[0].id;
-}
-/**
- * Get model database ID from modelFileId
- * @param modelFileId - The model file ID (schema_file_id)
- * @returns Model database ID
- * @throws Error if model not found
- */
-async function getModelIdByFileId(modelFileId) {
-    const db = BaseDb.getAppDb();
-    if (!db) {
-        throw new Error('Database not available');
-    }
-    const modelSchemaMod = await Promise.resolve().then(function () { return ModelSchema; });
-    const { models: modelsTable } = modelSchemaMod;
-    const drizzleMod = await import('drizzle-orm');
-    const { eq } = drizzleMod;
-    const records = await db
-        .select()
-        .from(modelsTable)
-        .where(eq(modelsTable.schemaFileId, modelFileId))
-        .limit(1);
-    if (records.length === 0) {
-        throw new Error(`Model with file ID "${modelFileId}" not found in database`);
-    }
-    return records[0].id;
-}
-
-var db = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    addModelsToDb: addModelsToDb,
-    addSchemaToDb: addSchemaToDb,
-    getAddressesForItemsFilter: getAddressesForItemsFilter,
-    getAllAddressesFromDb: getAllAddressesFromDb,
-    getItemStoragePropertiesForModel: getItemStoragePropertiesForModel,
-    getModelId: getModelId,
-    getModelIdByFileId: getModelIdByFileId,
-    getModelNameByModelId: getModelNameByModelId,
-    getOwnedAddressesFromDb: getOwnedAddressesFromDb,
-    getPropertyIdForModelAndName: getPropertyIdForModelAndName,
-    getPropertyIdForSchemaFileId: getPropertyIdForSchemaFileId,
-    getPropertyModelNameAndDataType: getPropertyModelNameAndDataType,
-    getWatchedAddressesFromDb: getWatchedAddressesFromDb,
-    loadModelsFromDbForSchema: loadModelsFromDbForSchema,
-    mergeDbModelsIntoSchemaModels: mergeDbModelsIntoSchemaModels,
-    migrateMetadataForPropertyRename: migrateMetadataForPropertyRename,
-    moveMetadataToRenamedProperty: moveMetadataToRenamedProperty,
-    propertyStorageColumns: propertyStorageColumns,
-    renameModelInDb: renameModelInDb,
-    savePropertyToDb: savePropertyToDb,
-    writeModelToDb: writeModelToDb,
-    writePropertyToDb: writePropertyToDb
-});
-
-const isNode = () => {
-    return (typeof process !== 'undefined' &&
-        process.versions != null &&
-        process.versions.node != null);
-};
-const isBrowser = () => {
-    return !isElectron() && typeof document !== 'undefined' && typeof window !== 'undefined';
-};
-const isElectron = () => {
-    return typeof process !== 'undefined' && process.versions != null && process.versions.electron != null;
-};
-/**
- * Detects if code is running in an Electron renderer process.
- *
- * Uses multiple detection methods for robustness:
- * 1. Checks process.type === 'renderer' (most reliable)
- * 2. Falls back to checking if Electron is present and window/document exist
- *
- * @returns true if running in Electron renderer process, false otherwise
- */
-const isElectronRenderer = () => {
-    // Method 1: Check process.type (most reliable - official Electron API)
-    if (typeof process !== 'undefined' &&
-        process.type === 'renderer') {
-        return true;
-    }
-    // Method 2: Fallback - Electron + browser-like environment
-    // Renderer processes have window/document, main process doesn't (in modern Electron)
-    if (isElectron() &&
-        typeof window !== 'undefined' &&
-        typeof document !== 'undefined') {
-        return true;
-    }
-    return false;
-};
-/**
- * True where OPFS-backed Arweave file downloads should run: normal browsers and
- * Electron renderer. {@link isBrowser} is false for every Electron build (including renderer).
- */
-const supportsOpfsFileDownloads = () => {
-    return isBrowser() || isElectronRenderer();
-};
-/**
- * NODE_ENV is 'test' or IS_SEED_DEV is set. Bundlers compile `process.env.NODE_ENV` in, but
- * not IS_SEED_DEV, so that is only read where a `process` global exists: browsers have none.
- */
-const isTestOrSeedDev = () => process.env.NODE_ENV === 'test' || (typeof process !== 'undefined' && !!process.env?.IS_SEED_DEV);
-
-/**
- * Tag every Seed upload carries with the hex digest of its data. Producers: the SDK's
- * `getPublishUploadData` / `getPublishUploads` (and through them both the L1 transaction path and
- * the bundler / DataItem path in `@seedprotocol/publish`). Consumer: the files download
- * (`events/files/download.ts` and the download worker), which verifies downloaded bytes against it.
- */
-const CONTENT_SHA256_TAG = 'Content-SHA-256';
-const CONTENT_TYPE_TAG = 'Content-Type';
-/**
- * Lowercase hex SHA-256 of `data`: the value of the {@link CONTENT_SHA256_TAG} tag.
- *
- * Uses @noble/hashes rather than WebCrypto so it also works outside secure contexts (WebCrypto's
- * `crypto.subtle` is missing on plain-http origins); the digest is the same.
- *
- * In SDK 0.7.2 and earlier the L1 transaction path (`getPublishUploads`) wrote SHA3-256 under this tag name
- * while the bundler path wrote SHA-256. Uploads from that path still carry SHA3-256 digests; use
- * {@link contentSha256TagMatches} to check a tag value against bytes.
- */
-const getContentSha256 = (data) => bytesToHex(sha256(data));
-/**
- * True when `tagValue` (a {@link CONTENT_SHA256_TAG} value read from Arweave) is the digest of
- * `data`. Accepts SHA-256 and, for uploads made by SDK 0.7.2 and earlier through the L1 transaction path,
- * SHA3-256.
- */
-const contentSha256TagMatches = (data, tagValue) => {
-    const expected = tagValue.trim().toLowerCase();
-    if (!expected)
-        return false;
-    return getContentSha256(data) === expected || bytesToHex(sha3_256(data)) === expected;
-};
-/**
- * Tags for one upload, in the order every upload uses: content hash, content type, then any
- * configured extra tags (e.g. App-Name from `arweaveUploadTags`).
- */
-const buildArweaveContentTags = (contentHash, contentType, extra) => {
-    const tags = [];
-    if (contentHash)
-        tags.push({ name: CONTENT_SHA256_TAG, value: contentHash });
-    if (contentType)
-        tags.push({ name: CONTENT_TYPE_TAG, value: contentType });
-    if (extra?.length)
-        tags.push(...extra);
-    return tags;
-};
-
-/** Subdirectory of the files root that holds a storage seed's file, by its data type. */
-const getStorageSubdirForDataType = (dataType) => {
-    switch (normalizeDataType(dataType ?? undefined)) {
-        case 'Image':
-            return 'images';
-        case 'Html':
-            return 'html';
-        case 'Json':
-            return 'json';
-        case 'File':
-        default:
-            // Unknown types are generic files; `images/` is only for what the SDK knows is an image.
-            return 'files';
-    }
-};
-/** Absolute directory for a storage seed's file (`images/`, `files/`, `html/` or `json/` under the files root). */
-const getStorageDirForDataType = (dataType) => BaseFileManager.getFilesPath(getStorageSubdirForDataType(dataType));
-/**
- * Subdirectory (relative to the files root, no leading slash) for an ItemStorage property's file:
- * its model's `storage.path` (`localStorageDir`), else `files`.
- */
-const getItemStorageSubdir = (localStorageDir) => (localStorageDir ?? '').replace(/^\/+/, '').replace(/\/+$/, '') || 'files';
-/**
- * File name a local save gives an ItemStorage property: `<seedUid or seedLocalId><extension>`
- * (see saveItemStorage). Downloaded content is named after its transaction instead
- * (`<txId><extension>`, see syncDbWithEas), which is what the metadata row's refResolvedValue says.
- */
-const getItemStorageLocalFileName = (seedId, filenameSuffix) => `${seedId}${filenameSuffix ?? ''}`;
-
-/** Rows per query: well under SQLite's bound-parameter limit. */
-const CHUNK_SIZE = 400;
-/**
- * Where the download worker saves each child of a composite upload, by transaction id then child
- * (property) name: a path relative to the files root.
- *
- * The paths come from the ItemStorage rows sync derives from a `storage_transaction_id`
- * attestation (see `createMetadataRecordsForStorageTransactionId`): property value = the
- * transaction id, `refResolvedValue` = `<txId><extension>`, `localStorageDir` = the model's storage
- * directory. Those rows are what hydration reads, so a child saved here is found as that property's
- * file. Transactions with no such rows are left out; the worker then falls back to the legacy
- * html / json layout.
- */
-const getCompositeChildPaths = async (transactionIds) => {
-    const out = {};
-    const appDb = BaseDb.getAppDb();
-    if (!appDb || transactionIds.length === 0)
-        return out;
-    for (let i = 0; i < transactionIds.length; i += CHUNK_SIZE) {
-        const chunk = transactionIds.slice(i, i + CHUNK_SIZE);
-        const rows = await appDb
-            .select({
-            transactionId: metadata.propertyValue,
-            propertyName: metadata.propertyName,
-            refResolvedValue: metadata.refResolvedValue,
-            localStorageDir: metadata.localStorageDir,
-        })
-            .from(metadata)
-            .where(and(isNotNull(metadata.derivedFromUid), isNotNull(metadata.refResolvedValue), inArray(metadata.propertyValue, chunk)));
-        for (const row of rows) {
-            const { transactionId, propertyName, refResolvedValue } = row;
-            if (!transactionId || !propertyName || !refResolvedValue)
-                continue;
-            // A file name, never a path: anything else is not where the SDK would look.
-            if (refResolvedValue.includes('/') || refResolvedValue.includes('\\'))
-                continue;
-            const byName = (out[transactionId] ?? (out[transactionId] = {}));
-            byName[propertyName] ?? (byName[propertyName] = `${getItemStorageSubdir(row.localStorageDir)}/${refResolvedValue}`);
-        }
-    }
-    return out;
-};
-
-const logger$2 = debug('seedSdk:files:download');
-const AUTO_BULK_DOWNLOAD_THROTTLE_MS = 10000;
-/** Avoid refetch-on-every-call: transient empty indexer responses were overwriting good cache (see trailing throttle ~10s after success). */
-const GET_FILES_METADATA_STALE_MS = 120000;
-let bulkDownloadInFlight = null;
-const lazyDownloadInFlightByTransactionId = new Map();
-const getAppDbReady = async () => {
-    if (!BaseDb.isAppDbReady()) {
-        // Wait for ClientManager to be ready (DB_INIT state or later)
-        const _mod_0 = await import('./ClientManager-DqL0q_eu.js');
-        const _ns_0 = _mod_0.W;
-        const clientManagerMod = _ns_0;
-        const { getClient } = clientManagerMod;
-        const clientManager = getClient();
-        const clientService = clientManager.getService();
-        await waitFor(clientService, (snapshot) => {
-            const state = snapshot.value;
-            return state === 'dbInit' ||
-                state === 'saveConfig' ||
-                state === 'processSchemaFiles' ||
-                state === 'addModelsToStore' ||
-                state === 'addModelsToDb' ||
-                state === 'idle';
-        }, { timeout: 30000 });
-    }
-    return BaseDb.getAppDb();
-};
-const getExcludedTransactions = async () => {
-    const appDb = await getAppDbReady();
-    if (!appDb) {
-        return new Set();
-    }
-    const excludedTransactionsQuery = await appDb
-        .select()
-        .from(appState)
-        .where(eq(appState.key, 'excludedTransactions'));
-    const excludedTransactions = new Set();
-    if (excludedTransactionsQuery && excludedTransactionsQuery.length === 1) {
-        const valueString = excludedTransactionsQuery[0].value;
-        if (valueString) {
-            const excludedTransactionsArray = JSON.parse(valueString);
-            for (const txId of excludedTransactionsArray) {
-                excludedTransactions.add(txId);
-            }
-        }
-    }
-    return excludedTransactions;
-};
-/** Arweave transaction ids are 43 chars in the URL-safe base64 alphabet. */
-const ARWEAVE_TX_ID_RE$1 = /^[a-z0-9_-]{43}$/i;
-const normalizeArweaveTxId = (raw) => {
-    if (raw == null || raw === '')
-        return undefined;
-    const t = String(raw).trim();
-    if (ARWEAVE_TX_ID_RE$1.test(t))
-        return t;
-    const m = t.match(/^([a-z0-9_-]{43})(?:\.[^/]+)?$/i);
-    if (m)
-        return m[1];
-    // Values may be full gateway URLs or paths; scan for an embedded tx id. It must be 43 characters
-    // on its own, not the start of a longer run: the first 43 of a bytes32 value (`0x0000…0020`,
-    // an EAS UID) are in the alphabet too.
-    const embedded = t.match(/(?<![a-z0-9_-])[a-z0-9_-]{43}(?![a-z0-9_-])/gi);
-    return embedded?.[0];
-};
-const mergeAddressLists = (a, b) => {
-    const seen = new Set();
-    const out = [];
-    for (const addr of [...(a ?? []), ...(b ?? [])]) {
-        if (!addr || !addr.trim())
-            continue;
-        const k = addr.toLowerCase();
-        if (seen.has(k))
-            continue;
-        seen.add(k);
-        out.push(addr);
-    }
-    return out;
-};
-const collectTransactionIdsFromLocalMetadata = async () => {
-    const appDb = await getAppDbReady();
-    if (!appDb) {
-        return [];
-    }
-    const nameOr = or(eq(metadata.propertyName, 'storageTransactionId'), eq(metadata.propertyName, 'storage_transaction_id'), eq(metadata.propertyName, 'transactionId'));
-    const propRows = await appDb
-        .select({ propertyValue: metadata.propertyValue })
-        .from(metadata)
-        .where(and(nameOr, isNotNull(metadata.propertyValue)));
-    const refRows = await appDb
-        .select({ refResolvedValue: metadata.refResolvedValue })
-        .from(metadata)
-        .where(isNotNull(metadata.refResolvedValue));
-    const ids = new Set();
-    for (const row of propRows) {
-        const id = normalizeArweaveTxId(row.propertyValue ?? undefined);
-        if (id)
-            ids.add(id);
-    }
-    for (const row of refRows) {
-        const id = normalizeArweaveTxId(row.refResolvedValue ?? undefined);
-        if (id)
-            ids.add(id);
-    }
-    return Array.from(ids);
-};
-const parseTransactionIdsFromMetadata = (filesMetadata, excludedTransactions) => {
-    const transactionIds = [];
-    for (const fileMetadata of filesMetadata) {
-        // Validate and parse decodedDataJson
-        if (!fileMetadata.decodedDataJson || fileMetadata.decodedDataJson.trim() === '') {
-            console.warn('[events/files] [download] empty decodedDataJson for fileMetadata: ', fileMetadata.id);
-            continue;
-        }
-        let json;
-        try {
-            json = JSON.parse(fileMetadata.decodedDataJson);
-        }
-        catch (error) {
-            console.warn('[events/files] [download] failed to parse decodedDataJson for fileMetadata: ', fileMetadata.id, error);
-            continue;
-        }
-        if (!Array.isArray(json) || json.length === 0 || !json[0]?.value?.value) {
-            console.warn('[events/files] [download] invalid decodedDataJson structure for fileMetadata: ', fileMetadata.id);
-            continue;
-        }
-        const rawTx = json[0].value.value;
-        if (typeof rawTx !== 'string' || rawTx.trim().length === 0) {
-            continue;
-        }
-        const transactionId = normalizeArweaveTxId(rawTx.trim());
-        if (!transactionId) {
-            continue;
-        }
-        if (excludedTransactions.has(transactionId) || excludedTransactions.has(rawTx.trim())) {
-            continue;
-        }
-        transactionIds.push(transactionId);
-    }
-    return transactionIds;
-};
-/** Content-SHA-256 tag values for the transactions that have one, from one batched tag lookup (cached). */
-const getExpectedContentHashes = async (transactionIds) => {
-    const queryClient = BaseQueryClient.getQueryClient();
-    const tagsById = new Map();
-    const toFetch = [];
-    for (const transactionId of transactionIds) {
-        // Tags never change once a transaction is indexed, so a cached lookup stays good.
-        const cached = queryClient.getQueryData?.(['getTransactionTags', transactionId]);
-        if (cached)
-            tagsById.set(transactionId, cached);
-        else
-            toFetch.push(transactionId);
-    }
-    if (toFetch.length > 0) {
-        try {
-            const fetched = await getTransactionTagsByIds(toFetch, {
-                client: BaseArweaveClient.getArweaveClient(),
-                onError: (error) => logger$2('[download] transaction tags lookup failed', error),
-            });
-            for (const [transactionId, tags] of fetched) {
-                tagsById.set(transactionId, tags);
-                // Seed the per-transaction cache entry (the client interface has no setQueryData).
-                void queryClient
-                    .fetchQuery({ queryKey: ['getTransactionTags', transactionId], queryFn: async () => tags })
-                    .catch(() => { });
-            }
-        }
-        catch (error) {
-            logger$2('[download] transaction tags lookup failed', error);
-        }
-    }
-    const out = {};
-    for (const [transactionId, tags] of tagsById) {
-        const value = tags.find((tag) => tag.name === CONTENT_SHA256_TAG)?.value?.trim();
-        if (value)
-            out[transactionId] = value;
-    }
-    return out;
-};
-const downloadTransactionIds = async (rawTransactionIds, options) => {
-    if (!supportsOpfsFileDownloads()) {
-        return false;
-    }
-    const transactionIds = Array.from(new Set(rawTransactionIds.filter((tx) => !!tx && tx.trim().length > 0)));
-    if (transactionIds.length === 0) {
-        return false;
-    }
-    const excludedTransactions = await getExcludedTransactions();
-    await ensureReadGatewaySelected();
-    // Browser: do not call getTransactionStatus() — many gateways (e.g. g8way.io) redirect or omit
-    // CORS headers, so fetch() fails and we would wrongly exclude txs. The OPFS worker fetch decides success.
-    const transactionIdsToDownload = transactionIds.filter((id) => !excludedTransactions.has(id));
-    if (transactionIdsToDownload.length === 0) {
-        return false;
-    }
-    // One batched lookup for every upload's Content-SHA-256 tag; downloads are verified against it.
-    // Missing tags (old uploads, or a just-published one not indexed yet) just mean no verification.
-    const expectedContentHashes = await getExpectedContentHashes(transactionIdsToDownload);
-    // Preferred gateways first: a just-published item is only on the gateway it was uploaded through.
-    const arweaveBaseUrls = getArweaveReadBaseUrls();
-    // Where each ItemStorage child of a composite goes (the worker cannot read the DB or the schema).
-    const compositeChildPaths = await getCompositeChildPaths(transactionIdsToDownload).catch((error) => {
-        logger$2('[download] composite child paths lookup failed', error);
-        return {};
-    });
-    let result;
-    if (transactionIdsToDownload.length === 1) {
-        const transactionId = transactionIdsToDownload[0];
-        result = await BaseFileManager.downloadFileByTransactionId({
-            transactionId,
-            arweaveHost: BaseArweaveClient.getBaseUrl(),
-            arweaveBaseUrls,
-            excludedTransactions,
-            expectedContentHash: expectedContentHashes[transactionId],
-            compositeChildPaths: compositeChildPaths[transactionId],
-            skipExisting: options?.skipExisting,
-        });
-    }
-    else {
-        result = await BaseFileManager.downloadAllFiles({
-            transactionIds: transactionIdsToDownload,
-            arweaveHost: BaseArweaveClient.getBaseUrl(),
-            arweaveBaseUrls,
-            excludedTransactions,
-            expectedContentHashes,
-            compositeChildPaths,
-            skipExisting: options?.skipExisting,
-        });
-    }
-    if (result) {
-        for (const transactionId of result.hashMismatchTransactionIds) {
-            // Not saved by the worker; left for a later run (a gateway may serve the right bytes then).
-            logger$2(`[download] ${transactionId}: downloaded bytes do not match Content-SHA-256; skipped`);
-        }
-    }
-    return true;
-};
-const runBulkDownloadWithDedupe = async (transactionIds) => {
-    if (bulkDownloadInFlight) {
-        return bulkDownloadInFlight;
-    }
-    bulkDownloadInFlight = (async () => {
-        try {
-            await downloadTransactionIds(transactionIds, { skipExisting: true });
-        }
-        finally {
-            bulkDownloadInFlight = null;
-        }
-    })();
-    return bulkDownloadInFlight;
-};
-const downloadAllFilesBinaryRequestHandler = async (addressesHint) => {
-    if (!supportsOpfsFileDownloads()) {
-        return;
-    }
-    let fromDb = [];
-    if (BaseDb.isAppDbReady()) {
-        fromDb = await getAllAddressesFromDb();
-    }
-    if (!BaseDb.isAppDbReady()) {
-        await getAppDbReady();
-        fromDb = await getAllAddressesFromDb();
-    }
-    const addresses = mergeAddressLists(addressesHint, fromDb);
-    if (!addresses || addresses.length === 0) {
-        return;
-    }
-    const queryClient = BaseQueryClient.getQueryClient();
-    const easClient = BaseEasClient.getEasClient();
-    const filesMetadataQueryKey = ['getFilesMetadata', ...addresses];
-    const fetchFilesMetadata = () => easClient.request(GET_FILES_METADATA, {
-        where: {
-            attester: {
-                in: addresses,
-            },
-            schema: {
-                is: {
-                    id: {
-                        equals: '0x55fdefb36fcbbaebeb7d6b41dc3a1a9666e4e42154267c889de064faa7ede517',
-                    },
-                },
-            },
-        },
-    });
-    let { filesMetadata } = await queryClient.fetchQuery({
-        queryKey: filesMetadataQueryKey,
-        queryFn: fetchFilesMetadata,
-        staleTime: GET_FILES_METADATA_STALE_MS,
-    });
-    if ((!Array.isArray(filesMetadata) || filesMetadata.length === 0) && addresses.length > 0) {
-        await queryClient.removeQueries({ queryKey: filesMetadataQueryKey });
-        ({ filesMetadata } = await queryClient.fetchQuery({
-            queryKey: filesMetadataQueryKey,
-            queryFn: fetchFilesMetadata,
-            staleTime: GET_FILES_METADATA_STALE_MS,
-        }));
-    }
-    const filesRoot = BaseFileManager.getWorkingDir();
-    await BaseFileManager.createDirIfNotExists(filesRoot);
-    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('html'));
-    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('json'));
-    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('images'));
-    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('files'));
-    const excludedTransactions = await getExcludedTransactions();
-    const fromEas = parseTransactionIdsFromMetadata(filesMetadata ?? [], excludedTransactions);
-    const fromLocal = await collectTransactionIdsFromLocalMetadata();
-    const transactionIds = Array.from(new Set([...fromEas, ...fromLocal]));
-    await runBulkDownloadWithDedupe(transactionIds);
-};
-const downloadTransactionIdWithDedupe = async (transactionId) => {
-    if (!supportsOpfsFileDownloads() || !transactionId || transactionId.trim().length === 0) {
-        return false;
-    }
-    const normalizedTxId = normalizeArweaveTxId(transactionId);
-    if (!normalizedTxId) {
-        logger$2(`[download] not an Arweave transaction id: ${transactionId}`);
-        return false;
-    }
-    const existing = lazyDownloadInFlightByTransactionId.get(normalizedTxId);
-    if (existing) {
-        return existing;
-    }
-    const inFlight = (async () => {
-        try {
-            // No skipExisting: the caller found no local file, so a file on disk it could not see is
-            // written again and announced.
-            const ok = await downloadTransactionIds([normalizedTxId]);
-            return ok;
-        }
-        finally {
-            lazyDownloadInFlightByTransactionId.delete(normalizedTxId);
-        }
-    })();
-    lazyDownloadInFlightByTransactionId.set(normalizedTxId, inFlight);
-    return inFlight;
-};
-const scheduleBulkFilesDownloadFromEasSyncThrottled = throttle((addressesHint) => {
-    void downloadAllFilesBinaryRequestHandler(addressesHint).catch((error) => {
-        logger$2('[scheduleBulkFilesDownloadFromEasSync] failed', error);
-    });
-}, AUTO_BULK_DOWNLOAD_THROTTLE_MS, { leading: true, trailing: false });
-const scheduleBulkFilesDownloadFromEasSync = (addressesHint) => {
-    if (!supportsOpfsFileDownloads()) {
-        return;
-    }
-    scheduleBulkFilesDownloadFromEasSyncThrottled(addressesHint);
-};
-
-var download = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    downloadAllFilesBinaryRequestHandler: downloadAllFilesBinaryRequestHandler,
-    downloadTransactionIdWithDedupe: downloadTransactionIdWithDedupe,
-    scheduleBulkFilesDownloadFromEasSync: scheduleBulkFilesDownloadFromEasSync
-});
-
-const logger$1 = debug('seedSdk:helpers:ensureImageLocal');
-/** Arweave transaction ids are 43 chars in the URL-safe base64 alphabet. */
-const ARWEAVE_TX_ID_RE = /^[a-z0-9_-]{43}$/i;
-const IMAGE_SIZES = [
-    ImageSize.EXTRA_SMALL,
-    ImageSize.SMALL,
-    ImageSize.MEDIUM,
-    ImageSize.LARGE,
-    ImageSize.EXTRA_LARGE,
-];
-const inFlightByKey = new Map();
-const normalizeArweaveTxIdForEnsure = (raw) => {
-    if (raw == null || raw === '')
-        return undefined;
-    const t = String(raw).trim();
-    if (ARWEAVE_TX_ID_RE.test(t))
-        return t;
-    const m = t.match(/^([a-z0-9_-]{43})(?:\.[^/]+)?$/i);
-    if (m)
-        return m[1];
-    const embedded = t.match(/[a-z0-9_-]{43}/gi);
-    if (embedded) {
-        for (const candidate of embedded) {
-            if (ARWEAVE_TX_ID_RE.test(candidate))
-                return candidate;
-        }
-    }
-    return undefined;
-};
-const closestImageSize = (width) => {
-    let best = ImageSize.EXTRA_SMALL;
-    let bestDist = Math.abs(best - width);
-    for (const size of IMAGE_SIZES) {
-        const dist = Math.abs(size - width);
-        if (dist < bestDist) {
-            best = size;
-            bestDist = dist;
-        }
-    }
-    return best;
-};
-const mapRequestedWidthsToImageSizes = (widths) => {
-    const requested = widths && widths.length > 0 ? widths : [ImageSize.EXTRA_SMALL];
-    const unique = new Set();
-    for (const w of requested) {
-        if (typeof w !== 'number' || !Number.isFinite(w) || w <= 0)
-            continue;
-        unique.add(closestImageSize(w));
-    }
-    if (unique.size === 0) {
-        unique.add(ImageSize.EXTRA_SMALL);
-    }
-    return Array.from(unique).sort((a, b) => a - b);
-};
-const getBasename = (filePath) => {
-    const path = BaseFileManager.getPathModule();
-    return path.basename(filePath);
-};
-const getBasenameWithoutExtension = (fileName) => {
-    const match = fileName.match(/^(.*[\/\\])?([^\/\\]+?)(\.[^.\/\\]*)?$/);
-    return match?.[2] ?? fileName;
-};
-const resolveMatchingImagePath = async (needle) => {
-    const dirPath = BaseFileManager.getFilesPath('images');
-    const dirExists = await BaseFileManager.pathExists(dirPath);
-    if (!dirExists)
-        return undefined;
-    const fs = await BaseFileManager.getFs();
-    const path = BaseFileManager.getPathModule();
-    const files = await fs.promises.readdir(dirPath);
-    // Prefer exact basename match (files only); skip size dirs.
-    const exact = files.find((file) => path.basename(file) === needle);
-    if (exact) {
-        const candidate = BaseFileManager.getFilesPath('images', exact);
-        try {
-            const zenfs = await BaseFileManager.getFs();
-            const stat = await zenfs.promises.stat(candidate);
-            if (stat.isFile())
-                return candidate;
-        }
-        catch {
-            // fall through
-        }
-    }
-    const matchingFiles = files.filter((file) => {
-        const base = path.basename(file);
-        return base.includes(needle);
-    });
-    for (const file of matchingFiles) {
-        const candidate = BaseFileManager.getFilesPath('images', file);
-        try {
-            const zenfs = await BaseFileManager.getFs();
-            const stat = await zenfs.promises.stat(candidate);
-            if (stat.isFile())
-                return candidate;
-        }
-        catch {
-            continue;
-        }
-    }
-    return undefined;
-};
-const sizedVariantPath = (originalFilePath, size) => {
-    const path = BaseFileManager.getPathModule();
-    const dir = path.dirname(originalFilePath);
-    const base = getBasenameWithoutExtension(getBasename(originalFilePath));
-    return path.join(dir, String(size), `${base}.webp`);
-};
-const ensureKey = (txId, fileName, sizes) => {
-    const idPart = txId ?? fileName ?? '';
-    return `${idPart}|${sizes.join(',')}`;
-};
-const runEnsureImageLocal = async (params) => {
-    if (!supportsOpfsFileDownloads()) {
-        return { status: 'unsupported' };
-    }
-    const fileName = params.fileName?.trim() || undefined;
-    const txId = normalizeArweaveTxIdForEnsure(params.transactionId) ??
-        normalizeArweaveTxIdForEnsure(fileName);
-    if (!txId && !fileName) {
-        return { status: 'missing-id' };
-    }
-    const targetSizes = mapRequestedWidthsToImageSizes(params.widths);
-    const needles = [fileName, txId].filter((n) => typeof n === 'string' && n.length > 0);
-    try {
-        let filePath;
-        for (const needle of needles) {
-            filePath = await resolveMatchingImagePath(needle);
-            if (filePath)
-                break;
-        }
-        if (!filePath && txId) {
-            await downloadTransactionIdWithDedupe(txId);
-            for (const needle of needles) {
-                filePath = await resolveMatchingImagePath(needle);
-                if (filePath)
-                    break;
-            }
-            // Downloads store as bare tx id
-            if (!filePath) {
-                const direct = BaseFileManager.getFilesPath('images', txId);
-                if (await BaseFileManager.pathExists(direct)) {
-                    filePath = direct;
-                }
-            }
-        }
-        if (!filePath) {
-            return { status: 'failed' };
-        }
-        const createdWidths = [];
-        for (const size of targetSizes) {
-            const variantPath = sizedVariantPath(filePath, size);
-            const exists = await BaseFileManager.pathExists(variantPath);
-            if (exists)
-                continue;
-            await BaseFileManager.resizeImage({
-                filePath,
-                width: size,
-                height: size,
-            });
-            createdWidths.push(size);
-        }
-        return {
-            status: 'ready',
-            filePath,
-            createdWidths,
-        };
-    }
-    catch (error) {
-        logger$1('ensureImageLocal failed', error);
-        return { status: 'failed' };
-    }
-};
-/**
- * Ensure an image original exists in OPFS (downloading from Arweave if needed)
- * and create only the requested ImageSize variant(s) for that one file.
- */
-const ensureImageLocal = async (params) => {
-    if (!supportsOpfsFileDownloads()) {
-        return { status: 'unsupported' };
-    }
-    const fileName = params.fileName?.trim() || undefined;
-    const txId = normalizeArweaveTxIdForEnsure(params.transactionId) ??
-        normalizeArweaveTxIdForEnsure(fileName);
-    if (!txId && !fileName) {
-        return { status: 'missing-id' };
-    }
-    const targetSizes = mapRequestedWidthsToImageSizes(params.widths);
-    const key = ensureKey(txId, fileName, targetSizes);
-    const existing = inFlightByKey.get(key);
-    if (existing) {
-        return existing;
-    }
-    const inFlight = (async () => {
-        try {
-            return await runEnsureImageLocal({
-                transactionId: txId,
-                fileName,
-                widths: targetSizes,
-            });
-        }
-        finally {
-            inFlightByKey.delete(key);
-        }
-    })();
-    inFlightByKey.set(key, inFlight);
-    return inFlight;
-};
-
-const randomId = customAlphabet(alphanumeric, 10);
-/**
- * A 10-character local id. Never starts with "0x" (about 1 in 3,844 random ids would), so code that
- * tells local ids from EAS uids by that prefix can't mistake one for the other.
- */
-const generateId = () => {
-    let id = randomId();
-    while (id.startsWith('0x'))
-        id = randomId();
-    return id;
-};
-
-var generateId$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    generateId: generateId
-});
-
-const logger = debug('seedSdk:shared:helpers');
-const getMimeType = (base64) => {
-    if (!base64) {
-        return null;
-    }
-    const result = base64.match(/^data:([a-zA-Z0-9]+\/[a-zA-Z0-9-.+]+).*,/);
-    if (result && result.length > 1) {
-        return result[1];
-    }
-    else {
-        return null; // MIME type could not be determined
-    }
-};
-const getCorrectId = (localIdOrUid) => {
-    const id = {
-        localId: undefined,
-        uid: undefined,
-    };
-    if (!localIdOrUid) {
-        return id;
-    }
-    if (localIdOrUid.length === 10) {
-        id.localId = localIdOrUid;
-    }
-    if (localIdOrUid.startsWith('0x') && localIdOrUid.length === 66) {
-        id.uid = localIdOrUid;
-    }
-    return id;
-};
-const getDataTypeFromString = (data) => {
-    const nonImageBase64Regex = /^(?!data:image\/(?:jpeg|png|gif|bmp|webp);base64,)[A-Za-z0-9+/=]+$/;
-    if (nonImageBase64Regex.test(data)) {
-        return 'base64';
-    }
-    // Regular expression for base64 (simple version, checking for base64 format)
-    const imageBase64Regex = /^data:image\/[a-zA-Z]+;base64,[A-Za-z0-9+/]+={0,2}$/;
-    if (imageBase64Regex.test(data)) {
-        return 'imageBase64';
-    }
-    // Blob URLs are fetchable but session-scoped; recognize them as url type
-    if (data.startsWith('blob:')) {
-        return 'url';
-    }
-    // Regular expression for URL (simple version, checking for common URL format)
-    const urlRegex = /^(http:\/\/www\.|https:\/\/www\.|http:\/\/|https:\/\/)?[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/;
-    if (urlRegex.test(data)) {
-        return 'url';
-    }
-    return null;
-};
-const convertTxIdToImage = async (txId) => {
-    const imageFilePath = BaseFileManager.getFilesPath('images', txId);
-    const fileExists = await BaseFileManager.pathExists(imageFilePath);
-    if (!fileExists) {
-        logger(`[ItemView] [updateImage] ${imageFilePath} does not exist`);
-        return;
-    }
-    const buffer = await BaseFileManager.readFileAsBuffer(imageFilePath);
-    // Convert Blob to ArrayBuffer if needed, or use Buffer directly
-    let arrayBuffer;
-    if (buffer instanceof Blob) {
-        arrayBuffer = await buffer.arrayBuffer();
-    }
-    else if (buffer instanceof ArrayBuffer) {
-        arrayBuffer = buffer;
-    }
-    else {
-        // Node.js Buffer
-        const sliced = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
-        // Handle SharedArrayBuffer case by creating a new ArrayBuffer
-        if (sliced instanceof SharedArrayBuffer) {
-            const uint8Array = new Uint8Array(sliced);
-            arrayBuffer = uint8Array.buffer.slice(0);
-        }
-        else {
-            arrayBuffer = sliced;
-        }
-    }
-    const uint = new Uint8Array(arrayBuffer);
-    const imageBlob = new Blob([uint]);
-    return URL.createObjectURL(imageBlob);
-};
-/**
- * Constructs an Arweave URL for a storage transaction ID
- * @param storageTransactionId - The Arweave transaction ID
- * @returns The full URL to access the transaction data on Arweave (e.g., https://arweave.net/raw/{transactionId})
- * @deprecated Use BaseArweaveClient.getRawUrl() instead for better consistency and testability
- */
-const getArweaveUrlForTransaction = (storageTransactionId) => {
-    return BaseArweaveClient.getRawUrl(storageTransactionId);
-};
-
-export { INTERNAL_DATA_TYPES as $, AmbiguousModelError as A, modelsRelations as B, pendingWrites as C, DEFAULT_TEXT_MAX_LENGTH as D, properties as E, propertiesRelations as F, propertyUidRelations as G, propertyUids as H, publishProcesses as I, schemas as J, uploadProcesses as K, BaseDb as L, ModelPropertyDataTypes as M, resolveStorageNameToSchemaName as N, nameMatchLevels as O, Property as P, BaseFileManager as Q, resolveModelRecord as R, getPropertyIdForModelAndName as S, THtmlEmbeddedDataUriPolicy as T, resolveItemModelFileId as U, INTERNAL_STORAGE_MODEL_FILE_IDS as V, getStorageDirForDataType as W, getContentSha256 as X, buildArweaveContentTags as Y, getItemStorageSubdir as Z, getItemStorageLocalFileName as _, TProperty as a, convertTxIdToImage as a$, normalizePublisher as a0, getAllAddressesFromDb as a1, loadNameMatchLevels as a2, scheduleBulkFilesDownloadFromEasSync as a3, EAS_SEED_DATA_SYNCED_TO_DB_EVENT as a4, generateId as a5, normalizeHexAddress as a6, listRelationEasPropertyName as a7, easPropertyNameForPublish as a8, toMetadataPropertyName as a9, getFeedItemStringField as aA, normalizeAddressConfig as aB, normalizeAddressList as aC, normalizeArweaveTxIdForEnsure as aD, normalizeFeedItemFields as aE, resolveMediaRef as aF, isInternalSchema as aG, writeModelToDb as aH, writePropertyToDb as aI, renameModelInDb as aJ, currentNameMatchLevels as aK, withSqliteBusyRetry as aL, loadModelsFromDbForSchema as aM, mergeDbModelsIntoSchemaModels as aN, addSchemaToDb as aO, addModelsToDb as aP, clearNameMatchLevels as aQ, isTestOrSeedDev as aR, warnOnInvalidNameMatch as aS, INTERNAL_SCHEMA_IDS as aT, linkModelToSchema as aU, getWatchedAddressesFromDb as aV, getOwnedAddressesFromDb as aW, CLIENT_NOT_INITIALIZED as aX, toSchemaPropertyName as aY, easSchemaDefinitionForProperty as aZ, getStorageTransactionIdForSeedUid as a_, getItemStoragePropertiesForModel as aa, getMetadataPropertyNamesForQuery as ab, isNode as ac, ZERO_BYTES32 as ad, getItemModelScope as ae, INTERNAL_PROPERTY_NAMES as af, isStorageSeedRef as ag, defaultAttestationData as ah, getModelIdByFileId as ai, getModelId as aj, setCachedPropertyRefresher as ak, isSqliteBusyError as al, SQLITE_BUSY_RETRY_DELAYS_MS as am, isBrowser as an, CONTENT_SHA256_TAG as ao, CONTENT_TYPE_TAG as ap, ImageSize as aq, SEED_PROTOCOL_SCHEMA_NAME as ar, SeedModels as as, VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA as at, classifyMediaRef as au, closestImageSize as av, contentSha256TagMatches as aw, ensureImageLocal as ax, getAddressesForItemsFilter as ay, getArweaveUrlForTransaction as az, TPropertyConstructor as b, getPropertyIdForSchemaFileId as b0, downloadTransactionIdWithDedupe as b1, resolveMetadataRecord as b2, getDataTypeFromString as b3, getMimeType as b4, listRelationStoragePropertyName as b5, PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP as b6, toItemPropertyKey as b7, getAlternatePropertyNameForInstanceLookup as b8, BaseDb$1 as b9, ModelSchema as ba, BaseFileManager$1 as bb, SchemaSchema as bc, ModelSchemaSchema as bd, resolveModelRecord$1 as be, db as bf, download as bg, generateId$1 as bh, TPropertyDataType as c, TPropertyDefs as d, TStorageType as e, TValidationRules as f, normalizePropertyRecordSchema as g, appState as h, isDataType as i, config as j, getCorrectId as k, isPublishedSeedRef as l, metadata as m, normalizeDataType as n, modelUids as o, models as p, normalizeRelationPropertyValue as q, resolveSeedIdsFromRefString as r, seeds as s, arweaveL1FinalizeJobs as t, easSyncProcesses as u, versions as v, entityChanges as w, htmlEmbeddedImageCoPublish as x, modelRelations as y, modelSchemas as z };
-//# sourceMappingURL=index-rOTW-2QZ.js.map