@seedprotocol/sdk 0.7.3-next.613.g79a8dfd → 0.7.3

package/dist/{db-CQt-gcAl.js → BasePathResolver-Cm4apKRb.js}

@@ -1,10 +1,272 @@
-import { j as models, g as modelSchemas, s as schemas, a as BaseDb, r as seeds, p as properties, b as appState, m as metadata } from './BasePathResolver-BdxCSIzn.js';
-import { toSnakeCase } from 'drizzle-orm/casing';
-import { eq, and, inArray, desc, isNull } from 'drizzle-orm';
 import debug from 'debug';
-import { upperFirst, camelCase } from 'lodash-es';
+import { isEasAttestationExplorerUrl, BaseArweaveClient, ensureReadGatewaySelected, getArweaveReadBaseUrls, getTransactionTagsByIds } from '@seedprotocol/arweave';
+import { BaseQueryClient, BaseEasClient, GET_FILES_METADATA } from '@seedprotocol/eas';
+import { waitFor } from 'xstate';
 import 'pluralize';
 import { Type } from '@sinclair/typebox';
+import { sqliteTable, integer, text, unique, int, blob, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { relations, and, eq, inArray, desc, isNull, isNotNull, or } from 'drizzle-orm';
+import { toSnakeCase as toSnakeCase$1 } from 'drizzle-orm/casing';
+import { upperFirst, camelCase, throttle } from 'lodash-es';
+import { customAlphabet } from 'nanoid';
+import { alphanumeric } from 'nanoid-dictionary';
+import '@seedprotocol/query';
+import { sha256 } from '@noble/hashes/sha256';
+import { sha3_256 } from '@noble/hashes/sha3';
+import { bytesToHex } from '@noble/hashes/utils';
+
+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: liveQuery((sql) => sql`SELECT * FROM models`)
+     * 2. Drizzle query builder (browser only): liveQuery(db.select().from(models))
+     */
+    static liveQuery(query) {
+        return BaseDb.requireImpl().liveQuery(query);
+    }
+}
+BaseDb._impl = null;
+
+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, }) {
+        return BaseFileManager.requireImpl().downloadAllFiles({
+            transactionIds: [transactionId],
+            arweaveHost,
+            arweaveBaseUrls,
+            excludedTransactions,
+            expectedContentHashes: expectedContentHash ? { [transactionId]: expectedContentHash } : undefined,
+            compositeChildPaths: compositeChildPaths ? { [transactionId]: compositeChildPaths } : undefined,
+        });
+    }
+    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;
@@ -105,17 +367,19 @@ function normalizePropertyRecordSchema(def) {
     }
     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(ModelPropertyDataTypes.Text),
-    Type.Literal(ModelPropertyDataTypes.Number),
-    Type.Literal(ModelPropertyDataTypes.List),
-    Type.Literal(ModelPropertyDataTypes.Relation),
-    Type.Literal(ModelPropertyDataTypes.Image),
-    Type.Literal(ModelPropertyDataTypes.Json),
-    Type.Literal(ModelPropertyDataTypes.File),
-    Type.Literal(ModelPropertyDataTypes.Boolean),
-    Type.Literal(ModelPropertyDataTypes.Date),
-    Type.Literal(ModelPropertyDataTypes.Html),
+    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
@@ -195,24 +459,547 @@ const Property = {
     Html: htmlPropertyFactory,
     /** `Html` opts are not representable in `TPropertyConstructor`; keep runtime shape via double assert. */
 };
-const PropertyMetadataKey = Symbol('property');
-const PropertyConstructor = (propertyType) => {
-    return function (parentClassPrototype, propertyKey) {
-        const existingProperties = Reflect.getMetadata(PropertyMetadataKey, parentClassPrototype) || [];
-        existingProperties.push({ propertyKey, propertyType });
-        Reflect.defineMetadata(PropertyMetadataKey, existingProperties, parentClassPrototype);
+
+/** 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'),
+    createdAt: int('created_at'),
+    updatedAt: int('updated_at'),
+    _markedForDeletion: int('_marked_for_deletion'),
+    revokedAt: int('revoked_at'),
+});
+
+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'),
+    createdAt: int('created_at'),
+    updatedAt: int('updated_at'),
+    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'),
+});
+
+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'),
+    createdAt: int('created_at'),
+    updatedAt: int('updated_at'),
+    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'),
+});
+
+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),
+]);
+
+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 Text = (storageType, srcDir, filenameSuffix) => PropertyConstructor(Property.Text(storageType, srcDir, filenameSuffix));
-const Number$1 = () => PropertyConstructor(Property.Number());
-const Json = () => PropertyConstructor(Property.Json());
-const File = () => PropertyConstructor(Property.File());
-const Image = () => PropertyConstructor(Property.Image());
-const Relation = (ref, refValueType, required) => PropertyConstructor(Property.Relation(ref, refValueType, required)); // Adjust for actual relation type
-const List = (refValueType, ref) => PropertyConstructor(Property.List(refValueType, ref));
-const Boolean = () => PropertyConstructor(Property.Boolean());
-const Date$1 = () => PropertyConstructor(Property.Date());
-const Html = (opts) => PropertyConstructor(htmlPropertyFactory(opts));
+
+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;
+}
 
 class SeedEventEmitter {
     constructor() {
@@ -254,18 +1041,39 @@ class SeedEventEmitter {
         this.listeners.delete(event);
         return this;
     }
+    /**
+     * Calls every listener. A listener that throws is logged and skipped: the others still
+     * run, and the error never reaches the SDK code that emitted the event (which may be
+     * midway through a save).
+     */
     emit(event, ...args) {
         const set = this.listeners.get(event);
         if (!set || set.size === 0)
             return false;
         for (const listener of [...set]) {
-            listener(...args);
+            try {
+                listener(...args);
+            }
+            catch (error) {
+                console.error(`[seed] listener for "${String(event)}" threw:`, error);
+            }
         }
         return true;
     }
 }
 const eventEmitter = new SeedEventEmitter();
 
+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,
@@ -406,7 +1214,7 @@ const modelNamesForNameOrType = async (nameOrType, db) => {
     const rows = (await db.selectDistinct({ name: models.name }).from(models));
     return rows
         .map((r) => r.name)
-        .filter((name) => name === nameOrType || name === pascal || toSnakeCase(name) === nameOrType);
+        .filter((name) => name === nameOrType || name === pascal || toSnakeCase$1(name) === nameOrType);
 };
 /**
  * resolveModelRecord for a model name **or** an EAS model type (snake_case model name, what sync
@@ -619,7 +1427,7 @@ function linkModelToSchema(db, modelId, schemaId) {
     return current;
 }
 
-const logger = debug('seedSdk:helpers:db');
+const logger$3 = debug('seedSdk:helpers:db');
 /**
  * The `properties` storage columns for a property definition, in either the internal shape
  * (`storageType`, `localStorageDir`, `filenameSuffix`) or the schema-file shape
@@ -725,7 +1533,7 @@ async function getItemStoragePropertiesForModel(modelNameOrType, scope = {}) {
 async function migrateMetadataForPropertyRename(modelName, oldPropertyName, newPropertyName, propertySchemaFileId, scope = {}) {
     const db = BaseDb.getAppDb();
     if (!db) {
-        logger('[migrateMetadataForPropertyRename] Database not available, skipping');
+        logger$3('[migrateMetadataForPropertyRename] Database not available, skipping');
         return 0;
     }
     // Find the property row by schemaFileId (preferred) or by name
@@ -737,7 +1545,7 @@ async function migrateMetadataForPropertyRename(modelName, oldPropertyName, newP
         propertyId = await getPropertyIdForModelAndName(modelName, oldPropertyName, scope);
     }
     if (propertyId == null) {
-        logger(`[migrateMetadataForPropertyRename] Property not found: ${modelName}.${oldPropertyName}, skipping`);
+        logger$3(`[migrateMetadataForPropertyRename] Property not found: ${modelName}.${oldPropertyName}, skipping`);
         return 0;
     }
     // Primary path: update metadata by propertyId
@@ -753,7 +1561,7 @@ async function migrateMetadataForPropertyRename(modelName, oldPropertyName, newP
             .where(eq(metadata.propertyId, propertyId));
     }
     // Fallback: update metadata with null propertyId (legacy rows) by propertyName + modelType
-    const modelType = toSnakeCase(modelName);
+    const modelType = toSnakeCase$1(modelName);
     const toUpdateByFallback = await db
         .select({ localId: metadata.localId })
         .from(metadata)
@@ -766,11 +1574,11 @@ async function migrateMetadataForPropertyRename(modelName, oldPropertyName, newP
             .where(and(eq(metadata.propertyName, oldPropertyName), eq(metadata.modelType, modelType), isNull(metadata.propertyId)));
     }
     if (updatedByFallback > 0) {
-        logger(`[migrateMetadataForPropertyRename] Fallback updated ${updatedByFallback} rows (propertyId was null)`);
+        logger$3(`[migrateMetadataForPropertyRename] Fallback updated ${updatedByFallback} rows (propertyId was null)`);
     }
     const total = updatedByPropertyId + updatedByFallback;
     if (total > 0) {
-        logger(`[migrateMetadataForPropertyRename] Migrated ${total} metadata rows for ${modelName}.${oldPropertyName} -> ${newPropertyName}`);
+        logger$3(`[migrateMetadataForPropertyRename] Migrated ${total} metadata rows for ${modelName}.${oldPropertyName} -> ${newPropertyName}`);
     }
     return total;
 }
@@ -919,7 +1727,7 @@ const findOrCreateModelRecord = async (db, modelName, modelFileId, schemaId) =>
                 .set({ schemaFileId: modelFileId, isEdited: false })
                 .where(eq(models.id, chosen.id));
             chosen = { ...chosen, schemaFileId: modelFileId, isEdited: false };
-            logger(`Adopted existing model "${modelName}" (id: ${chosen.id}) with schemaFileId "${modelFileId}"`);
+            logger$3(`Adopted existing model "${modelName}" (id: ${chosen.id}) with schemaFileId "${modelFileId}"`);
         }
         if (chosen) {
             return chosen;
@@ -1190,7 +1998,7 @@ const addSchemaToDb = async (schema, schemaFileId, schemaData, isDraft, isEdited
             .limit(1);
         if (draftSchemas.length > 0) {
             // Found a draft - we'll update it to non-draft below
-            logger(`Found draft schema "${schema.name}" with schemaFileId "${draftSchemas[0].schemaFileId}", will update to non-draft with schemaFileId "${schemaFileId}"`);
+            logger$3(`Found draft schema "${schema.name}" with schemaFileId "${draftSchemas[0].schemaFileId}", will update to non-draft with schemaFileId "${schemaFileId}"`);
             existingSchemas = draftSchemas;
         }
     }
@@ -1210,11 +2018,11 @@ const addSchemaToDb = async (schema, schemaFileId, schemaData, isDraft, isEdited
                 !existingSchemas[0].schemaFileId ||
                 (isDraft === false && existingSchemas[0].isDraft === true);
             if (shouldUpdate) {
-                logger(`Updating schemaFileId from "${existingSchemas[0].schemaFileId}" to "${schemaFileId}" for schema "${schema.name}"`);
+                logger$3(`Updating schemaFileId from "${existingSchemas[0].schemaFileId}" to "${schemaFileId}" for schema "${schema.name}"`);
                 updates.schemaFileId = schemaFileId;
             }
             else {
-                logger(`Preserving existing schemaFileId "${existingSchemas[0].schemaFileId}" for non-draft schema "${schema.name}" (new schemaFileId "${schemaFileId}" would overwrite it)`);
+                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)
@@ -1241,16 +2049,16 @@ const addSchemaToDb = async (schema, schemaFileId, schemaData, isDraft, isEdited
             updates.updatedAt = schema.updatedAt;
         }
         if (Object.keys(updates).length > 0) {
-            logger(`Applying updates to schema "${schema.name}" (id: ${existingSchemas[0].id}):`, Object.keys(updates));
+            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(`Schema "${schema.name}" updated. New schemaFileId: "${updated.schemaFileId}", isDraft: ${updated.isDraft}`);
+            logger$3(`Schema "${schema.name}" updated. New schemaFileId: "${updated.schemaFileId}", isDraft: ${updated.isDraft}`);
             return updated;
         }
-        logger(`No updates needed for schema "${schema.name}" (id: ${existingSchemas[0].id})`);
+        logger$3(`No updates needed for schema "${schema.name}" (id: ${existingSchemas[0].id})`);
         return existingSchemas[0];
     }
     const newSchema = await db.insert(schemas).values({
@@ -1286,9 +2094,7 @@ const renameModelInDb = async (oldName, newName, schemaNameOrId) => {
     if (!db) {
         throw new Error('Database not found');
     }
-    const _mod_0 = await import('./BasePathResolver-BdxCSIzn.js');
-    const _ns_0 = _mod_0.Q;
-    const { schemas: schemasTable } = _ns_0;
+    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) {
@@ -1435,7 +2241,7 @@ modelId) {
                         // Compare database value with schema file value
                         // If they differ, the property has been edited
                         if (dbProperty.dataType !== schemaFileValue.dataType) {
-                            logger(`Property ${modelName}:${propertyName} has been edited (dataType differs: DB=${dbProperty.dataType}, Schema=${schemaFileValue.dataType})`);
+                            logger$3(`Property ${modelName}:${propertyName} has been edited (dataType differs: DB=${dbProperty.dataType}, Schema=${schemaFileValue.dataType})`);
                             return true;
                         }
                         // Check refModelId if it's a relation
@@ -1444,19 +2250,19 @@ modelId) {
                             if (refModelRecord) {
                                 const expectedRefModelId = refModelRecord.id;
                                 if (dbProperty.refModelId !== expectedRefModelId) {
-                                    logger(`Property ${modelName}:${propertyName} has been edited (refModelId differs)`);
+                                    logger$3(`Property ${modelName}:${propertyName} has been edited (refModelId differs)`);
                                     return true;
                                 }
                             }
                         }
                         else if (dbProperty.refModelId !== null) {
                             // Schema file has no ref, but DB has one
-                            logger(`Property ${modelName}:${propertyName} has been edited (refModelId differs)`);
+                            logger$3(`Property ${modelName}:${propertyName} has been edited (refModelId differs)`);
                             return true;
                         }
                         // Check refValueType
                         if (dbProperty.refValueType !== (schemaFileValue.refValueType || null)) {
-                            logger(`Property ${modelName}:${propertyName} has been edited (refValueType differs)`);
+                            logger$3(`Property ${modelName}:${propertyName} has been edited (refValueType differs)`);
                             return true;
                         }
                         // Check required (for Relation/Image properties)
@@ -1464,7 +2270,7 @@ modelId) {
                             const schemaRequired = !!schemaFileValue.required;
                             const dbRequired = dbProperty.required === true;
                             if (dbRequired !== schemaRequired) {
-                                logger(`Property ${modelName}:${propertyName} has been edited (required differs: DB=${dbRequired}, Schema=${schemaRequired})`);
+                                logger$3(`Property ${modelName}:${propertyName} has been edited (required differs: DB=${dbRequired}, Schema=${schemaRequired})`);
                                 return true;
                             }
                         }
@@ -1480,7 +2286,7 @@ modelId) {
                             if (dbStorage.storageType !== fileStorage.storageType ||
                                 dbStorage.localStorageDir !== fileStorage.localStorageDir ||
                                 dbStorage.filenameSuffix !== fileStorage.filenameSuffix) {
-                                logger(`Property ${modelName}:${propertyName} has been edited (storage settings differ)`);
+                                logger$3(`Property ${modelName}:${propertyName} has been edited (storage settings differ)`);
                                 return true;
                             }
                         }
@@ -1492,7 +2298,7 @@ modelId) {
     }
     catch (error) {
         // If we can't check, assume it's not edited to be safe
-        logger('Error checking if property is edited:', error);
+        logger$3('Error checking if property is edited:', error);
         return false;
     }
 }
@@ -1517,11 +2323,11 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
         // SchemaType includes id, so check if it's set
         if (schema.id !== null && schema.id !== undefined) {
             schemaRecord = schema;
-            logger(`Using existing schema record with id: ${schemaRecord.id}`);
+            logger$3(`Using existing schema record with id: ${schemaRecord.id}`);
         }
         else {
             schemaRecord = await addSchemaToDb(schema, schemaFileData?.schemaFileId);
-            logger(`Created/found schema record with id: ${schemaRecord.id}`);
+            logger$3(`Created/found schema record with id: ${schemaRecord.id}`);
         }
     }
     // Handle model renames first if provided
@@ -1534,6 +2340,8 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
     // 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);
@@ -1547,7 +2355,7 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
                     .where(eq(models.schemaFileId, modelFileId))
                     .limit(1);
                 if (existingWithFileId.length > 0 && existingWithFileId[0].id !== modelRecord.id) {
-                    logger(`WARNING: Model "${modelName}" (id: ${modelRecord.id}) conflicts with existing model "${existingWithFileId[0].name}" (id: ${existingWithFileId[0].id}) both trying to use schemaFileId "${modelFileId}"`);
+                    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) {
@@ -1575,8 +2383,14 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
             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 (Object.keys(contextProperties).length > 0) {
+            if (filePropertyDefinitions) {
+                schema = filePropertyDefinitions;
+            }
+            else if (Object.keys(contextProperties).length > 0) {
                 schema = contextProperties;
             }
             else if (Object.keys(pendingProperties).length > 0) {
@@ -1600,14 +2414,13 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
                 }
                 // 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 _mod_1 = await import('./tabEvents-BZJMY5uK.js');
-                    const _ns_1 = _mod_1.P;
-                    const { generateId } = _ns_1;
+                    const { generateId } = await Promise.resolve().then(function () { return generateId$1; });
                     propertyFileId = generateId();
-                    logger(`Generated propertyFileId "${propertyFileId}" for property "${modelName}:${propertyName}" (not found in propertyFileIds map)`);
+                    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;
@@ -1674,7 +2487,7 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
                     if (potentialMatches.length > 0) {
                         const matchedProperty = potentialMatches[0];
                         existingProperty = matchedProperty;
-                        logger(`Found renamed property: ${modelName}:${matchedProperty.name} -> ${propertyName} (matched by characteristics)`);
+                        logger$3(`Found renamed property: ${modelName}:${matchedProperty.name} -> ${propertyName} (matched by characteristics)`);
                     }
                 }
                 if (existingProperty) {
@@ -1695,7 +2508,7 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
                         }, modelRecord.id);
                     if (isPropertyEdited) {
                         // Property has been locally edited - skip update to preserve local changes
-                        logger(`Skipping update for property ${modelName}:${existingProperty.name} -> ${propertyName} - it has been locally edited and will be preserved`);
+                        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
@@ -1703,6 +2516,10 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
                     // 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;
@@ -1726,6 +2543,9 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
                             .update(properties)
                             .set(updateData)
                             .where(eq(properties.id, existingProperty.id));
+                        const updatedFileId = updateData.schemaFileId ?? existingProperty.schemaFileId;
+                        if (updatedFileId)
+                            updatedPropertyFileIds.push(updatedFileId);
                     }
                 }
                 else {
@@ -1746,18 +2566,18 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
                         if (existingByFileId.length > 0) {
                             const found = existingByFileId[0];
                             matchedDbPropertyIds.add(found.id);
-                            logger(`Property ${modelName}:${propertyName} already exists by schemaFileId "${propertyFileId}" (id: ${found.id}), skipping insert`);
+                            logger$3(`Property ${modelName}:${propertyName} already exists by schemaFileId "${propertyFileId}" (id: ${found.id}), skipping insert`);
                             continue;
                         }
                     }
-                    logger(`Creating new property ${modelName}:${propertyName} with schemaFileId: ${propertyData.schemaFileId}`);
+                    logger$3(`Creating new property ${modelName}:${propertyName} with schemaFileId: ${propertyData.schemaFileId}`);
                     try {
                         await db.insert(properties).values(propertyDataWithIsEdited);
                     }
                     catch (insertError) {
                         // Treat UNIQUE constraint as success - property already exists (e.g. from concurrent addModelsToDb call)
                         if (isSqliteUniqueConstraintError(insertError)) {
-                            logger(`Property ${modelName}:${propertyName} already exists (UNIQUE constraint), treating as success`);
+                            logger$3(`Property ${modelName}:${propertyName} already exists (UNIQUE constraint), treating as success`);
                         }
                         else {
                             throw insertError;
@@ -1768,14 +2588,14 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
         }
         catch (error) {
             const errorMessage = error?.message || String(error);
-            logger(`Error processing model "${modelName}": ${errorMessage}`);
+            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(`Errors processing models: ${modelProcessingErrors.map(e => e.modelName).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) {
@@ -1783,7 +2603,7 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
             .filter(([, r]) => r.id)
             .map(([name, r]) => ({ modelName: name, modelId: r.id }));
         if (modelIds.length === 0) {
-            logger('No model IDs to link, skipping schema linking');
+            logger$3('No model IDs to link, skipping schema linking');
         }
         else {
             // Single batch query: get all existing joins for this schema
@@ -1797,14 +2617,16 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
                 for (const { modelName, modelId } of toInsert) {
                     if (!(await linkModelToSchema(db, modelId, schemaRecord.id)))
                         continue;
-                    logger(`Created join table entry for model ${modelName} (id: ${modelId}) to schema (id: ${schemaRecord.id})`);
+                    logger$3(`Created join table entry for model ${modelName} (id: ${modelId}) to schema (id: ${schemaRecord.id})`);
                 }
             }
         }
     }
     else if (schemaRecord && !schemaRecord.id) {
-        logger(`Warning: schemaRecord provided but has no id, cannot create join table entries`);
+        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.
@@ -1816,7 +2638,7 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
 const loadModelsFromDbForSchema = async (schemaId) => {
     const db = BaseDb.getAppDb();
     if (!db) {
-        logger('Database not found, cannot load models from DB');
+        logger$3('Database not found, cannot load models from DB');
         return {};
     }
     try {
@@ -1885,11 +2707,11 @@ const loadModelsFromDbForSchema = async (schemaId) => {
                 // or reconstructed from schemaData if available
             };
         }
-        logger(`Loaded ${Object.keys(models$1).length} models from database for schema ${schemaId}`);
+        logger$3(`Loaded ${Object.keys(models$1).length} models from database for schema ${schemaId}`);
         return models$1;
     }
     catch (error) {
-        logger(`Error loading models from database for schema ${schemaId}:`, error);
+        logger$3(`Error loading models from database for schema ${schemaId}:`, error);
         return {};
     }
 };
@@ -2006,34 +2828,34 @@ const savePropertyToDb = async (property) => {
     // Find existing property - try multiple strategies to handle name changes
     // 1. First try by schemaFileId (most reliable - doesn't change when name changes)
     let existingProperties = [];
-    logger(`[savePropertyToDb] Looking for property ${property.modelName}:${property.name} (schemaFileId: ${schemaFileId}, originalName: ${property._originalValues?.name})`);
+    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(`[savePropertyToDb] Found ${existingProperties.length} properties by schemaFileId`);
+        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(`[savePropertyToDb] Trying to find by original name: ${property._originalValues.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(`[savePropertyToDb] Found ${existingProperties.length} properties by original name`);
+        logger$3(`[savePropertyToDb] Found ${existingProperties.length} properties by original name`);
     }
     // 3. Fallback: try by current name
     if (existingProperties.length === 0) {
-        logger(`[savePropertyToDb] Trying to find by current name: ${property.name}`);
+        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(`[savePropertyToDb] Found ${existingProperties.length} properties by current name`);
+        logger$3(`[savePropertyToDb] Found ${existingProperties.length} properties by current name`);
     }
     // Prepare property data
     const propertyData = {
@@ -2082,7 +2904,7 @@ const savePropertyToDb = async (property) => {
             isEdited: true, // Mark as edited when saving changes
         })
             .where(eq(properties.id, existingProperty.id));
-        logger(`Updated property ${property.modelName}:${property._originalValues?.name || 'unknown'} -> ${property.name} in database`);
+        logger$3(`Updated property ${property.modelName}:${property._originalValues?.name || 'unknown'} -> ${property.name} in database`);
     }
     else {
         // Property doesn't exist, create it
@@ -2092,12 +2914,12 @@ const savePropertyToDb = async (property) => {
                 ...propertyData,
                 isEdited: true, // Runtime-created properties are edited
             });
-            logger(`Created property ${property.modelName}:${property.name} in database`);
+            logger$3(`Created property ${property.modelName}:${property.name} in database`);
         }
         catch (insertError) {
             // Treat UNIQUE constraint as success - property already exists (e.g. from concurrent addModelsToDb or race)
             if (isSqliteUniqueConstraintError(insertError)) {
-                logger(`Property ${property.modelName}:${property.name} already exists (UNIQUE constraint), treating as success`);
+                logger$3(`Property ${property.modelName}:${property.name} already exists (UNIQUE constraint), treating as success`);
             }
             else {
                 throw insertError;
@@ -2214,7 +3036,7 @@ async function writeModelToDb(modelFileId, data) {
         if (doubleCheck.length > 0) {
             // Another process created it, use existing
             modelId = doubleCheck[0].id;
-            logger(`Model with schemaFileId "${modelFileId}" was created by another process, using existing record (id: ${modelId})`);
+            logger$3(`Model with schemaFileId "${modelFileId}" was created by another process, using existing record (id: ${modelId})`);
         }
         else {
             try {
@@ -2228,7 +3050,7 @@ async function writeModelToDb(modelFileId, data) {
             catch (error) {
                 // Handle unique constraint violation
                 if (isSqliteUniqueConstraintError(error)) {
-                    logger(`Unique constraint violation for schemaFileId "${modelFileId}", attempting to find existing model`);
+                    logger$3(`Unique constraint violation for schemaFileId "${modelFileId}", attempting to find existing model`);
                     const existing = await db
                         .select()
                         .from(models)
@@ -2236,7 +3058,7 @@ async function writeModelToDb(modelFileId, data) {
                         .limit(1);
                     if (existing.length > 0) {
                         modelId = existing[0].id;
-                        logger(`Found existing model with schemaFileId "${modelFileId}" (id: ${modelId}) after constraint violation`);
+                        logger$3(`Found existing model with schemaFileId "${modelFileId}" (id: ${modelId}) after constraint violation`);
                     }
                     else {
                         throw error;
@@ -2292,9 +3114,7 @@ async function writeModelToDb(modelFileId, data) {
                 throw new Error(`Model with id ${modelId} does not exist in database. Cannot create join record.`);
             }
             // Verify schemaId exists and get name/fileId for invalidation broadcast
-            const _mod_2 = await import('./BasePathResolver-BdxCSIzn.js');
-            const _ns_2 = _mod_2.Q;
-            const schemaSchemaMod = _ns_2;
+            const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
             const { schemas: schemasTable } = schemaSchemaMod;
             const schemaCheck = await db
                 .select({
@@ -2308,7 +3128,7 @@ async function writeModelToDb(modelFileId, data) {
             if (schemaCheck.length === 0) {
                 throw new Error(`Schema with id ${data.schemaId} does not exist in database. Cannot create join record.`);
             }
-            logger(`Creating join record: modelId=${modelId}, schemaId=${data.schemaId} (both verified to exist)`);
+            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.
@@ -2323,13 +3143,13 @@ async function writeModelToDb(modelFileId, data) {
                 }
                 catch (_) { }
             }
-            logger(`Successfully created join record for model ${data.modelName} (id: ${modelId}) to schema (id: ${data.schemaId})`);
+            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(`FOREIGN KEY constraint failed when creating join record for model "${data.modelName}"`);
-                logger(`modelId: ${modelId}, schemaId: ${data.schemaId}`);
-                logger(`Error details:`, error);
+                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}`);
             }
@@ -2349,7 +3169,7 @@ async function writeModelToDb(modelFileId, data) {
             if (existingProps.length > 0 && existingProps[0].schemaFileId) {
                 // Use existing property's schemaFileId
                 propertyFileId = existingProps[0].schemaFileId;
-                logger(`Using existing propertyFileId "${propertyFileId}" for property "${data.modelName}:${propName}"`);
+                logger$3(`Using existing propertyFileId "${propertyFileId}" for property "${data.modelName}:${propName}"`);
             }
             else if (propData.id) {
                 // Use provided ID
@@ -2358,11 +3178,9 @@ async function writeModelToDb(modelFileId, data) {
             else {
                 // Generate random propertyFileId
                 // IDs should be generated in the import process before calling writeModelToDb
-                const _mod_3 = await import('./tabEvents-BZJMY5uK.js');
-                const _ns_3 = _mod_3.P;
-                const { generateId } = _ns_3;
+                const { generateId } = await Promise.resolve().then(function () { return generateId$1; });
                 propertyFileId = generateId();
-                logger(`Generated propertyFileId "${propertyFileId}" for property "${data.modelName}:${propName}"`);
+                logger$3(`Generated propertyFileId "${propertyFileId}" for property "${data.modelName}:${propName}"`);
             }
             await writePropertyToDb(propertyFileId, {
                 modelId,
@@ -2371,7 +3189,7 @@ async function writeModelToDb(modelFileId, data) {
             });
         }
     }
-    logger(`Wrote model ${data.modelName} (${modelFileId}) to database`);
+    logger$3(`Wrote model ${data.modelName} (${modelFileId}) to database`);
 }
 /**
  * Write property to database
@@ -2446,7 +3264,7 @@ async function writePropertyToDb(propertyFileId, data, isEdited = false) {
             .update(properties)
             .set(propertyData)
             .where(eq(properties.id, existing.id));
-        logger(`Updated property ${data.name} (${propertyFileId}) in database`);
+        logger$3(`Updated property ${data.name} (${propertyFileId}) in database`);
     }
     else {
         // Property doesn't exist, create it
@@ -2462,17 +3280,17 @@ async function writePropertyToDb(propertyFileId, data, isEdited = false) {
                 .update(properties)
                 .set(propertyData)
                 .where(eq(properties.id, doubleCheck[0].id));
-            logger(`Property with schemaFileId "${propertyFileId}" was created by another process, updated existing record`);
+            logger$3(`Property with schemaFileId "${propertyFileId}" was created by another process, updated existing record`);
         }
         else {
             try {
                 await db.insert(properties).values({ required: false, ...propertyData });
-                logger(`Created property ${data.name} (${propertyFileId}) in database`);
+                logger$3(`Created property ${data.name} (${propertyFileId}) in database`);
             }
             catch (error) {
                 // Handle unique constraint violation
                 if (isSqliteUniqueConstraintError(error)) {
-                    logger(`Unique constraint violation for property schemaFileId "${propertyFileId}", attempting to find existing property`);
+                    logger$3(`Unique constraint violation for property schemaFileId "${propertyFileId}", attempting to find existing property`);
                     const existing = await db
                         .select()
                         .from(properties)
@@ -2483,7 +3301,7 @@ async function writePropertyToDb(propertyFileId, data, isEdited = false) {
                             .update(properties)
                             .set(propertyData)
                             .where(eq(properties.id, existing[0].id));
-                        logger(`Found existing property with schemaFileId "${propertyFileId}" (id: ${existing[0].id}) after constraint violation, updated it`);
+                        logger$3(`Found existing property with schemaFileId "${propertyFileId}" (id: ${existing[0].id}) after constraint violation, updated it`);
                     }
                     else {
                         throw new Error(`Failed to create or find property "${data.name}" with schemaFileId "${propertyFileId}": ${error.message}`);
@@ -2507,9 +3325,7 @@ async function getSchemaId(schemaNameOrFileId) {
     if (!db) {
         throw new Error('Database not available');
     }
-    const _mod_4 = await import('./BasePathResolver-BdxCSIzn.js');
-    const _ns_4 = _mod_4.Q;
-    const schemaSchemaMod = _ns_4;
+    const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
     const { schemas: schemasTable } = schemaSchemaMod;
     const drizzleMod = await import('drizzle-orm');
     const { eq, desc } = drizzleMod;
@@ -2545,9 +3361,7 @@ async function getSchemaIdByFileId(schemaFileId) {
     if (!db) {
         throw new Error('Database not available');
     }
-    const _mod_5 = await import('./BasePathResolver-BdxCSIzn.js');
-    const _ns_5 = _mod_5.Q;
-    const schemaSchemaMod = _ns_5;
+    const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
     const { schemas: schemasTable } = schemaSchemaMod;
     const drizzleMod = await import('drizzle-orm');
     const { eq, desc } = drizzleMod;
@@ -2574,9 +3388,7 @@ async function getModelId(modelNameOrFileId, schemaNameOrId) {
     if (!db) {
         throw new Error('Database not available');
     }
-    const _mod_6 = await import('./BasePathResolver-BdxCSIzn.js');
-    const _ns_6 = _mod_6.N;
-    const modelSchemaMod = _ns_6;
+    const modelSchemaMod = await Promise.resolve().then(function () { return ModelSchema; });
     const { models: modelsTable } = modelSchemaMod;
     const drizzleMod = await import('drizzle-orm');
     const { eq, and, or } = drizzleMod;
@@ -2591,13 +3403,9 @@ async function getModelId(modelNameOrFileId, schemaNameOrId) {
         [eq(modelsTable.name, modelNameOrFileId)];
         // If schema is provided, narrow the search
         if (schemaNameOrId !== undefined) {
-            const _mod_7 = await import('./BasePathResolver-BdxCSIzn.js');
-            const _ns_7 = _mod_7.R;
-            const modelSchemaSchemaMod = _ns_7;
+            const modelSchemaSchemaMod = await Promise.resolve().then(function () { return ModelSchemaSchema; });
             const { modelSchemas } = modelSchemaSchemaMod;
-            const _mod_8 = await import('./BasePathResolver-BdxCSIzn.js');
-            const _ns_8 = _mod_8.Q;
-            const schemaSchemaMod = _ns_8;
+            const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
             const { schemas: schemasTable } = schemaSchemaMod;
             if (typeof schemaNameOrId === 'number') {
                 // schemaNameOrId is schemaId
@@ -2642,9 +3450,7 @@ async function getModelIdByFileId(modelFileId) {
     if (!db) {
         throw new Error('Database not available');
     }
-    const _mod_9 = await import('./BasePathResolver-BdxCSIzn.js');
-    const _ns_9 = _mod_9.N;
-    const modelSchemaMod = _ns_9;
+    const modelSchemaMod = await Promise.resolve().then(function () { return ModelSchema; });
     const { models: modelsTable } = modelSchemaMod;
     const drizzleMod = await import('drizzle-orm');
     const { eq } = drizzleMod;
@@ -2690,5 +3496,1113 @@ var db = /*#__PURE__*/Object.freeze({
     writePropertyToDb: writePropertyToDb
 });
 
-export { AmbiguousModelError as A, Boolean as B, normalizeAddressConfig as C, DEFAULT_TEXT_MAX_LENGTH as D, normalizeAddressList as E, File as F, writeModelToDb as G, Html as H, Image as I, Json as J, writePropertyToDb as K, List as L, ModelPropertyDataTypes as M, Number$1 as N, addSchemaToDb as O, Property as P, renameModelInDb as Q, Relation as R, loadModelsFromDbForSchema as S, THtmlEmbeddedDataUriPolicy as T, linkModelToSchema as U, getWatchedAddressesFromDb as V, getOwnedAddressesFromDb as W, getPropertyIdForSchemaFileId as X, resolveModelRecord$1 as Y, db as Z, Date$1 as a, PropertyConstructor as b, PropertyMetadataKey as c, TProperty as d, TPropertyConstructor as e, TPropertyDataType as f, TPropertyDefs as g, TStorageType as h, TValidationRules as i, Text as j, isDataType as k, normalizePropertyRecordSchema as l, eventEmitter as m, normalizeDataType as n, getPropertyIdForModelAndName as o, resolveModelRecord as p, getItemModelScope as q, resolveItemModelFileId as r, normalizePublisher as s, getAllAddressesFromDb as t, normalizeHexAddress as u, getItemStoragePropertiesForModel as v, addModelsToDb as w, getModelIdByFileId as x, getModelId as y, getAddressesForItemsFilter as z };
-//# sourceMappingURL=db-CQt-gcAl.js.map
+const getMetadata = async (props) => {
+    const appDb = BaseDb.getAppDb();
+    let storageTransactionId;
+    if (props) {
+        storageTransactionId = props.storageTransactionId;
+    }
+    const whereClauses = [];
+    if (storageTransactionId) {
+        whereClauses.push(eq(metadata.propertyName, 'storageTransactionId'));
+        whereClauses.push(eq(metadata.propertyValue, storageTransactionId));
+    }
+    const metadataRows = await appDb
+        .select()
+        .from(metadata)
+        .where(and(...whereClauses));
+    if (!metadataRows || metadataRows.length === 0) {
+        return;
+    }
+    return metadataRows[0];
+};
+
+const saveMetadata = async (metadataRecord, metadataValues) => {
+    if (!metadataRecord.localId) {
+        return;
+    }
+    const appDb = BaseDb.getAppDb();
+    await appDb
+        .update(metadata)
+        .set({
+        ...metadataValues,
+        updatedAt: Date.now(),
+    })
+        .where(eq(metadata.localId, metadataRecord.localId));
+};
+
+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();
+};
+
+/**
+ * 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
+ * and copies a verified value into `metadata.content_hash`.
+ */
+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();
+// syncDbFiles helper - internal service removed, functionality moved here
+const syncDbFiles = async (endpoints) => {
+    // TODO: Implement syncDbFiles functionality if needed
+    // This was previously in @/services/internal/helpers
+    logger$2('[download] syncDbFiles called but not yet implemented');
+    return Promise.resolve();
+};
+const getAppDbReady = async () => {
+    if (!BaseDb.isAppDbReady()) {
+        // Wait for ClientManager to be ready (DB_INIT state or later)
+        const _mod_0 = await import('./ClientManager-i3nJASkg.js');
+        const _ns_0 = _mod_0.L;
+        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 the embedded tx id.
+    const embedded = t.match(/[a-z0-9_-]{43}/gi);
+    if (embedded) {
+        for (const candidate of embedded) {
+            if (ARWEAVE_TX_ID_RE$1.test(candidate))
+                return candidate;
+        }
+    }
+    return undefined;
+};
+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;
+};
+/** Store the (now verified) Content-SHA-256 of each downloaded transaction on its metadata row. */
+const recordVerifiedContentHashes = async (transactionIds, expectedContentHashes) => {
+    for (const transactionId of transactionIds) {
+        const contentHash = expectedContentHashes[transactionId];
+        if (!contentHash)
+            continue;
+        try {
+            const metadataRecord = await getMetadata({ storageTransactionId: transactionId });
+            if (metadataRecord) {
+                await saveMetadata(metadataRecord, { contentHash });
+            }
+        }
+        catch (error) {
+            logger$2(error);
+        }
+    }
+};
+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],
+        });
+    }
+    else {
+        result = await BaseFileManager.downloadAllFiles({
+            transactionIds: transactionIdsToDownload,
+            arweaveHost: BaseArweaveClient.getBaseUrl(),
+            arweaveBaseUrls,
+            excludedTransactions,
+            expectedContentHashes,
+            compositeChildPaths,
+        });
+    }
+    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`);
+        }
+        await recordVerifiedContentHashes(result.verifiedTransactionIds, expectedContentHashes);
+    }
+    if (options?.resizeAllImages !== false) {
+        await BaseFileManager.resizeAllImages({
+            width: 480,
+            height: 480,
+        });
+    }
+    return true;
+};
+const runBulkDownloadWithDedupe = async (transactionIds) => {
+    if (bulkDownloadInFlight) {
+        return bulkDownloadInFlight;
+    }
+    bulkDownloadInFlight = (async () => {
+        try {
+            await downloadTransactionIds(transactionIds, { resizeAllImages: true });
+        }
+        finally {
+            bulkDownloadInFlight = null;
+        }
+    })();
+    return bulkDownloadInFlight;
+};
+const downloadAllFilesRequestHandler = async ({ endpoints, eventId, }) => {
+    if (!supportsOpfsFileDownloads()) {
+        return;
+    }
+    await syncDbFiles();
+    eventEmitter.emit('fs.downloadAll.success', { eventId });
+    eventEmitter.emit('fs.downloadAllBinary.request', { endpoints });
+};
+const downloadAllFilesBinaryRequestHandler = async (addressesHintOrPayload) => {
+    if (!supportsOpfsFileDownloads()) {
+        return;
+    }
+    const addressesHint = Array.isArray(addressesHintOrPayload)
+        ? addressesHintOrPayload
+        : undefined;
+    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) ?? transactionId.trim();
+    const existing = lazyDownloadInFlightByTransactionId.get(normalizedTxId);
+    if (existing) {
+        return existing;
+    }
+    const inFlight = (async () => {
+        try {
+            const ok = await downloadTransactionIds([normalizedTxId], { resizeAllImages: false });
+            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,
+    downloadAllFilesRequestHandler: downloadAllFilesRequestHandler,
+    downloadTransactionIdWithDedupe: downloadTransactionIdWithDedupe,
+    scheduleBulkFilesDownloadFromEasSync: scheduleBulkFilesDownloadFromEasSync
+});
+
+// Top-level re-export (not mid-file import + export): Rollup with
+// external `@seedprotocol/arweave` otherwise emits a side-effect-only import
+// and an unbound Object.freeze namespace when this module is dynamically imported.
+// 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';
+// Primary config file name for Seed Protocol SDK
+const SEED_CONFIG_FILE = 'seed.config.ts';
+// Fallback config file names (in order of preference)
+const SEED_CONFIG_FALLBACKS = ['seed.schema.ts', 'schema.ts'];
+// Legacy constant for backward compatibility
+const SCHEMA_TS = SEED_CONFIG_FILE;
+const INTERNAL_DATA_TYPES = {
+    Text: {
+        eas: 'string',
+    },
+    Number: {
+        eas: 'uint8',
+    },
+    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',
+];
+/** Schema definition of the Version attestation (zero resolver, revocable). */
+const VERSION_SCHEMA_DEF = 'bytes32 version';
+/**
+ * UID of {@link VERSION_SCHEMA_DEF}. Schema UIDs hash the definition, resolver and revocable flag,
+ * so this is the same on every chain; the schema must still be registered on each one.
+ */
+const VERSION_SCHEMA_UID = '0x13c0fd59d69dbce40501a41f8b37768d26dd2e2bb0cad64615334d84f7b9bdf6';
+/** @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.';
+const INIT_SCRIPT_SUCCESS_MESSAGE = '[Seed Protocol] Finished running init script';
+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',
+};
+
+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 toSnakeCase = (str) => {
+    return str.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
+};
+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);
+};
+
+/**
+ * Save/restore helper for swapping a single facade implementation in tests.
+ */
+function createFacadeTestHandle(getImpl, setImpl, next) {
+    const previous = getImpl();
+    setImpl(next);
+    return {
+        restore() {
+            setImpl(previous);
+        },
+    };
+}
+
+class BasePathResolver {
+    static configure(impl) {
+        if (!impl) {
+            throw new Error('Cannot configure PathResolver with undefined or null. Ensure the platform-specific PathResolver is properly created.');
+        }
+        BasePathResolver._impl = impl;
+    }
+    static createForTesting(impl) {
+        return createFacadeTestHandle(() => BasePathResolver._impl, (next) => {
+            BasePathResolver._impl = next;
+        }, impl);
+    }
+    static requireImpl() {
+        if (!BasePathResolver._impl) {
+            throw new Error('PathResolver not configured. Please ensure the platform-specific PathResolver is registered. For Node.js, import from @seedprotocol/sdk/node. For browser, the SDK should auto-initialize.');
+        }
+        return BasePathResolver._impl;
+    }
+    /**
+     * @deprecated Prefer static facade methods (e.g. BasePathResolver.getDotSeedDir()).
+     */
+    static getInstance() {
+        return BasePathResolver.requireImpl();
+    }
+    static getRootWithNodeModules() {
+        return BasePathResolver.requireImpl().getRootWithNodeModules();
+    }
+    static getSdkRootDir() {
+        return BasePathResolver.requireImpl().getSdkRootDir();
+    }
+    static getNodeModulesDir() {
+        return BasePathResolver.requireImpl().getNodeModulesDir();
+    }
+    static getDotSeedDir(schemaFileDir) {
+        return BasePathResolver.requireImpl().getDotSeedDir(schemaFileDir);
+    }
+    static findConfigFile(searchDir) {
+        return BasePathResolver.requireImpl().findConfigFile(searchDir);
+    }
+    static getAppPaths(schemaFileDir) {
+        return BasePathResolver.requireImpl().getAppPaths(schemaFileDir);
+    }
+}
+BasePathResolver._impl = null;
+
+export { generateId as $, seeds as A, uploadProcesses as B, versions as C, DEFAULT_TEXT_MAX_LENGTH as D, BaseDb as E, AmbiguousModelError as F, eventEmitter as G, toSnakeCase as H, BasePathResolver as I, BaseFileManager as J, getPropertyIdForModelAndName as K, resolveItemModelFileId as L, ModelPropertyDataTypes as M, resolveSeedIdsFromRefString as N, normalizeRelationPropertyValue as O, Property as P, isPublishedSeedRef as Q, getStorageDirForDataType as R, getContentSha256 as S, THtmlEmbeddedDataUriPolicy as T, buildArweaveContentTags as U, getItemStorageSubdir as V, getItemStorageLocalFileName as W, normalizePublisher as X, getAllAddressesFromDb as Y, scheduleBulkFilesDownloadFromEasSync as Z, EAS_SEED_DATA_SYNCED_TO_DB_EVENT as _, TProperty as a, SchemaSchema as a$, normalizeHexAddress as a0, getItemStoragePropertiesForModel as a1, addModelsToDb as a2, INIT_SCRIPT_SUCCESS_MESSAGE as a3, SCHEMA_TS as a4, getCorrectId as a5, SEED_CONFIG_FILE as a6, SEED_CONFIG_FALLBACKS as a7, isNode as a8, ZERO_BYTES32 as a9, normalizeAddressConfig as aA, normalizeAddressList as aB, normalizeArweaveTxIdForEnsure as aC, normalizeFeedItemFields as aD, resolveMediaRef as aE, isInternalSchema as aF, writeModelToDb as aG, writePropertyToDb as aH, addSchemaToDb as aI, renameModelInDb as aJ, loadModelsFromDbForSchema as aK, downloadAllFilesRequestHandler as aL, downloadAllFilesBinaryRequestHandler as aM, INTERNAL_SCHEMA_IDS as aN, linkModelToSchema as aO, getWatchedAddressesFromDb as aP, getOwnedAddressesFromDb as aQ, CLIENT_NOT_INITIALIZED as aR, getStorageTransactionIdForSeedUid as aS, convertTxIdToImage as aT, downloadTransactionIdWithDedupe as aU, getPropertyIdForSchemaFileId as aV, getDataTypeFromString as aW, getMimeType as aX, PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP as aY, ModelSchema as aZ, BaseFileManager$1 as a_, resolveModelRecord as aa, getItemModelScope as ab, VERSION_SCHEMA_UID as ac, INTERNAL_PROPERTY_NAMES as ad, isStorageSeedRef as ae, defaultAttestationData as af, INTERNAL_DATA_TYPES as ag, isBrowser as ah, getModelIdByFileId as ai, getModelId as aj, setCachedPropertyRefresher as ak, getArweaveUrlForTransaction as al, INTERNAL_STORAGE_MODEL_FILE_IDS as am, CONTENT_SHA256_TAG as an, CONTENT_TYPE_TAG as ao, ImageSize as ap, SEED_PROTOCOL_SCHEMA_NAME as aq, SeedModels as ar, VERSION_SCHEMA_DEF as as, VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA as at, classifyMediaRef as au, closestImageSize as av, contentSha256TagMatches as aw, ensureImageLocal as ax, getAddressesForItemsFilter as ay, getFeedItemStringField as az, TPropertyConstructor as b, ModelSchemaSchema as b0, resolveModelRecord$1 as b1, db as b2, download as b3, generateId$1 as b4, TPropertyDataType as c, TPropertyDefs as d, TStorageType as e, TValidationRules as f, normalizePropertyRecordSchema as g, appState as h, isDataType as i, arweaveL1FinalizeJobs as j, config as k, easSyncProcesses as l, metadata as m, normalizeDataType as n, htmlEmbeddedImageCoPublish as o, modelRelations as p, modelSchemas as q, modelUids as r, models as s, modelsRelations as t, properties as u, propertiesRelations as v, propertyUidRelations as w, propertyUids as x, publishProcesses as y, schemas as z };
+//# sourceMappingURL=BasePathResolver-Cm4apKRb.js.map