@seedprotocol/sdk 0.5.1 → 0.5.3

package/dist/{index--F3Wolt5.js → index-B4In0GEO.js}

@@ -1,11 +1,11 @@
 import { waitFor, fromCallback, fromPromise, setup, assign, stateIn, createActor, isMachineSnapshot } from 'xstate';
-import { B as BaseDb, m as models$1, p as properties, s as seeds, j as modelUids, v as versions, f as metadata$1, r as schemas, i as modelSchemas, a as BaseFileManager, b as appState, e as easSyncProcesses, t as BasePathResolver } from './BasePathResolver-BDgc7c4T.js';
+import { a as BaseDb, m as models$1, p as properties, r as seeds, j as modelUids, v as versions, b as metadata$1, s as schemas, i as modelSchemas, B as BaseFileManager, c as appState, f as easSyncProcesses, t as BasePathResolver, h as htmlEmbeddedImageCoPublish, d as arweaveL1FinalizeJobs, q as publishProcesses } from './BasePathResolver-DWY_hb8w.js';
 import { eq, and, isNotNull, not, or, max, count, getTableColumns, sql, isNull, desc, inArray, gt } from 'drizzle-orm';
-import { n as normalizeDataType, t as toSnakeCase, o as MachineIds, w as getStorageTransactionIdForSeedUid, x as convertTxIdToImage, M as ModelPropertyDataTypes, y as getDataTypeFromString, z as getMimeType, l as getCorrectId, A as ClientManagerEvents, C as ClientManagerState, c as TProperty } from './constants-B5S5JPDK.js';
+import { n as normalizeDataType, t as toSnakeCase, o as MachineIds, v as getStorageTransactionIdForSeedUid, w as convertTxIdToImage, M as ModelPropertyDataTypes, x as getDataTypeFromString, y as getMimeType, l as getCorrectId, z as ClientManagerEvents, C as ClientManagerState, d as TProperty } from './constants-B7aNfB_1.js';
 import debug from 'debug';
 import { customAlphabet } from 'nanoid';
 import { alphanumeric } from 'nanoid-dictionary';
-import { writeModelToDb, writePropertyToDb, addSchemaToDb, getAddressesForItemsFilter, getAllAddressesFromDb, escapeSqliteString, getPropertyIdForModelAndName, loadModelsFromDbForSchema, getWatchedAddressesFromDb, getOwnedAddressesFromDb, renameModelInDb } from './db-Cvh84NY7.js';
+import { writeModelToDb, writePropertyToDb, addSchemaToDb, getAddressesForItemsFilter, getAllAddressesFromDb, escapeSqliteString, getPropertyIdForModelAndName, loadModelsFromDbForSchema, getOwnedAddressesFromDb, getWatchedAddressesFromDb, renameModelInDb } from './db-Bad8QKfZ.js';
 import pluralize from 'pluralize';
 import { BaseQueryClient, BaseEasClient, GET_SCHEMAS, getSchemaUidForModelFromCache, setSchemaUidForModel, GET_PROPERTIES, pickLatestPropertyAttestationsByRefAndSchema, isValidEasAttestationUid, getEasSchemaUidForSchemaDefinition, GET_FILES_METADATA, GET_SCHEMA_BY_NAME } from '@seedprotocol/eas';
 import { ZERO_BYTES32, INTERNAL_PROPERTY_NAMES, INTERNAL_DATA_TYPES, ImageSize, PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, isInternalSchema, INTERNAL_SCHEMA_IDS, SEED_PROTOCOL_SCHEMA_NAME, CLIENT_NOT_INITIALIZED } from './constants-DMHTYMgJ.js';
@@ -14,6 +14,7 @@ import { startCase, throttle, upperFirst, camelCase, orderBy } from 'lodash-es';
 import { toSnakeCase as toSnakeCase$1 } from 'drizzle-orm/casing';
 import { ensureReadGatewaySelected, BaseArweaveClient, getResolvedSeedGatewayEndpoints, getReadGatewayHostsForConfig, getDefaultArweaveReadGatewayHostsOrdered, getArweaveReadGatewayHostsForPrimary, seedGatewayConfigFromSeedConfig, resolveSeedGatewayEndpoints, setResolvedSeedGatewayEndpoints, DEFAULT_ARWEAVE_HOST } from '@seedprotocol/arweave';
 import * as sha3 from 'js-sha3';
+import { clearLocalQuerySource, registerLocalQuerySource, getSeed } from '@seedprotocol/query';
 import { Type } from '@sinclair/typebox';
 
 /**
@@ -282,7 +283,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await import('./ModelProperty-D-ysg8zA.js');
+        const mod = await import('./ModelProperty-DGJf78CS.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$s('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -466,7 +467,7 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         // Step 2: Fallback to Schema context (only if database doesn't have the model)
         // This handles the case where model exists in schema file but not yet in database
         try {
-            const _mod_0 = await import('./Schema-CyCftnKI.js');
+            const _mod_0 = await import('./Schema-Drmce3q-.js');
             const _ns_0 = _mod_0.b;
             const schemaMod = _ns_0;
             const { Schema } = schemaMod;
@@ -616,11 +617,11 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
                     }
                     // Also check database for models (in case they're persisted but not in Schema context)
                     if (db) {
-                        const _mod_1 = await import('./BasePathResolver-BDgc7c4T.js');
+                        const _mod_1 = await import('./BasePathResolver-DWY_hb8w.js');
                         const _ns_1 = _mod_1.x;
                         const modelSchemaSchemaMod = _ns_1;
                         const { modelSchemas } = modelSchemaSchemaMod;
-                        const _mod_2 = await import('./BasePathResolver-BDgc7c4T.js');
+                        const _mod_2 = await import('./BasePathResolver-DWY_hb8w.js');
                         const _ns_2 = _mod_2.S;
                         const schemaSchemaMod = _ns_2;
                         const { schemas: schemasTable } = schemaSchemaMod;
@@ -716,7 +717,7 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const _mod_3 = await import('./Schema-CyCftnKI.js');
+            const _mod_3 = await import('./Schema-Drmce3q-.js');
             const _ns_3 = _mod_3.b;
             const schemaMod = _ns_3;
             const { Schema } = schemaMod;
@@ -762,10 +763,10 @@ const validateModel = fromCallback(({ sendBack, input: { context } }) => {
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await import('./SchemaValidationService-POM6jHbJ.js');
+            const validationServiceMod = await import('./SchemaValidationService-a_sfnpDV.js');
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const _mod_4 = await import('./Schema-CyCftnKI.js');
+            const _mod_4 = await import('./Schema-Drmce3q-.js');
             const _ns_4 = _mod_4.b;
             const schemaMod = _ns_4;
             const { Schema } = schemaMod;
@@ -877,7 +878,7 @@ const createModelProperties = fromCallback(({ sendBack, input }) => {
             return;
         }
         logger$q(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await import('./ModelProperty-D-ysg8zA.js');
+        const mod = await import('./ModelProperty-DGJf78CS.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$q('ModelProperty not available from dynamic import');
@@ -980,7 +981,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                 const structureMsg = `[validateEntity] Validating model structure`;
                 logger$p(structureMsg);
                 // Use existing Model validation
-                const validationServiceMod = await import('./SchemaValidationService-POM6jHbJ.js');
+                const validationServiceMod = await import('./SchemaValidationService-a_sfnpDV.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
@@ -998,7 +999,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                     if (entityInput.entityData.schemaName) {
                         try {
                             logger$p(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
-                            const _mod_5 = await import('./Schema-CyCftnKI.js');
+                            const _mod_5 = await import('./Schema-Drmce3q-.js');
                             const _ns_5 = _mod_5.b;
                             const schemaMod = _ns_5;
                             const { Schema } = schemaMod;
@@ -1036,7 +1037,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const validationServiceMod = await import('./SchemaValidationService-POM6jHbJ.js');
+                const validationServiceMod = await import('./SchemaValidationService-a_sfnpDV.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -1051,7 +1052,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                     // If schema name and model name provided, validate against schema
                     if (entityInput.entityData._schemaName && entityInput.entityData.modelName) {
                         try {
-                            const _mod_6 = await import('./Schema-CyCftnKI.js');
+                            const _mod_6 = await import('./Schema-Drmce3q-.js');
                             const _ns_6 = _mod_6.b;
                             const schemaMod = _ns_6;
                             const { Schema } = schemaMod;
@@ -1082,7 +1083,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const validationServiceMod = await import('./SchemaValidationService-POM6jHbJ.js');
+                const validationServiceMod = await import('./SchemaValidationService-a_sfnpDV.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -1155,7 +1156,7 @@ const writeToDatabase = fromCallback(({ sendBack, input }) => {
                 // initial write completes is not overwritten by the stale requestWrite payload.
                 let dataToWrite = input.entityData;
                 try {
-                    const mod = await import('./ModelProperty-D-ysg8zA.js');
+                    const mod = await import('./ModelProperty-DGJf78CS.js');
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -1535,7 +1536,7 @@ const modelMachine = setup({
                                 // Create ModelProperty instances for any new property IDs
                                 if (Array.isArray(newPropertyIds) && newPropertyIds.length > 0) {
                                     // Import and create instances asynchronously (fire-and-forget)
-                                    import('./ModelProperty-D-ysg8zA.js').then(({ ModelProperty }) => {
+                                    import('./ModelProperty-DGJf78CS.js').then(({ ModelProperty }) => {
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
                                                 const property = await ModelProperty.createById(propertyFileId);
@@ -2433,7 +2434,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             const schemaNameToTry = model$1?.schemaName;
             if (schemaNameToTry) {
                 try {
-                    const _mod_7 = await import('./Schema-CyCftnKI.js');
+                    const _mod_7 = await import('./Schema-Drmce3q-.js');
                     const _ns_7 = _mod_7.b;
                     const { Schema } = _ns_7;
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false });
@@ -2467,7 +2468,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             if (Object.keys(propertySchemas).length === 0) {
                 try {
                     const { listCompleteSchemaFiles } = await Promise.resolve().then(function () { return schema; });
-                    const _mod_8 = await import('./BasePathResolver-BDgc7c4T.js');
+                    const _mod_8 = await import('./BasePathResolver-DWY_hb8w.js');
                     const _ns_8 = _mod_8.w;
                     const { BaseFileManager } = _ns_8;
                     const schemaFiles = await listCompleteSchemaFiles();
@@ -2486,7 +2487,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await import('./index-oi4roUVf.js');
+                const schemaMod = await import('./index-DNOCl06b.js');
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
@@ -2533,7 +2534,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 // Infer propertyRecordSchema from metadata when schema is missing (enables persistence)
                 let propSchema = propertySchemas[propertyName];
                 if (!propSchema && isRefTypeFromMeta) {
-                    const schemaMod = await import('./index-oi4roUVf.js');
+                    const schemaMod = await import('./index-DNOCl06b.js');
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -2790,9 +2791,9 @@ const runPublish = fromCallback(({ sendBack, input: { context } }) => {
                 sendBack({ type: 'publishError', error: new Error(`Item not found for seedLocalId: ${seedLocalId}`) });
                 return;
             }
-            const getPublishUploadsMod = await import('./getPublishUploads-D9rPHkB7.js');
+            const getPublishUploadsMod = await import('./getPublishUploads-CJjfqJi9.js');
             const { getPublishUploads } = getPublishUploadsMod;
-            const getPublishPayloadMod = await import('./getPublishPayload-CNYsn8-6.js');
+            const getPublishPayloadMod = await import('./getPublishPayload-BEO52UOv.js');
             const { getPublishPayload } = getPublishPayloadMod;
             const uploads = await getPublishUploads(item);
             let uploadedTransactions = [];
@@ -3173,6 +3174,14 @@ async function getLatestPublishedVersionRow(seedLocalId) {
 }
 
 const logger$j = debug('seedSdk:db:read:getItemData');
+/**
+ * Assemble flat ItemData for Item / liveQuery / draft-head authoring.
+ *
+ * For **published chain JSON** (Seed → latest attested Version → properties),
+ * prefer `getPublishedSeedRecord` from `@seedprotocol/sdk` or
+ * `getSeed` / `queryBySchema` from `@seedprotocol/query`. This function remains
+ * the correct path for local-head / draft-wins property selection used by Item.
+ */
 const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     if (!seedLocalId && !seedUid) {
         throw new Error('[db/queries] [getItem] no seedLocalId or seedUid');
@@ -3632,7 +3641,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
     const { isRelation, propertyValue, propertyName, seedUid, propertyRecordSchema, populatedFromDb, schemaUid, } = context;
     const _resolveRelatedValue = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-oi4roUVf.js');
+        const schemaMod = await import('./index-DNOCl06b.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -4494,7 +4503,7 @@ async function fetchHtmlViaRawAcrossGateways(txId) {
         return undefined;
     try {
         const resolved = getResolvedSeedGatewayEndpoints();
-        if (!resolved || resolved.activePath !== 'hyper-sidecar') {
+        if (!resolved || (resolved.activePath !== 'hyper-sidecar' && resolved.activePath !== 'http-proxy')) {
             const { ensureReadGatewaySelected } = await import('@seedprotocol/arweave');
             await ensureReadGatewaySelected().catch(() => { });
         }
@@ -4635,7 +4644,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
     // to use dynamically imported ModelPropertyDataTypes
     const _hydrateFromDb = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-oi4roUVf.js');
+        const schemaMod = await import('./index-DNOCl06b.js');
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -4998,14 +5007,14 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                         };
                         // Merge with schema from file/DB to get validation rules (enum, pattern, etc.) - properties table doesn't store these
                         try {
-                            const { getPropertySchema } = await import('./property-BdyDfcSc.js');
+                            const { getPropertySchema } = await import('./property-DIN1zQ_c.js');
                             let schemaFromFile = await getPropertySchema(normalizedModelName, propertyName);
                             if (!schemaFromFile?.validation) {
                                 // Fallback: get validation from schemaData in database (Schema context may not be loaded yet)
-                                const _mod_9 = await import('./BasePathResolver-BDgc7c4T.js');
+                                const _mod_9 = await import('./BasePathResolver-DWY_hb8w.js');
                                 const _ns_9 = _mod_9.S;
                                 const { schemas: schemasTable } = _ns_9;
-                                const _mod_10 = await import('./BasePathResolver-BDgc7c4T.js');
+                                const _mod_10 = await import('./BasePathResolver-DWY_hb8w.js');
                                 const _ns_10 = _mod_10.x;
                                 const { modelSchemas } = _ns_10;
                                 const modelSchemaRows = await db
@@ -5467,9 +5476,9 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _analyzeInput = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-oi4roUVf.js');
+        const schemaMod = await import('./index-DNOCl06b.js');
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await import('./SchemaValidationService-POM6jHbJ.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-a_sfnpDV.js');
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -5667,7 +5676,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await import('./SchemaValidationService-POM6jHbJ.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-a_sfnpDV.js');
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
             ? normalizeDataType(String(propertyRecordSchema.refValueType))
@@ -6260,7 +6269,7 @@ const saveRelation = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-oi4roUVf.js');
+        const schemaMod = await import('./index-DNOCl06b.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -7304,7 +7313,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await import('./index-oi4roUVf.js');
+            const schemaMod = await import('./index-DNOCl06b.js');
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -7475,7 +7484,7 @@ class ItemProperty {
                 const normalizedRefValueType = normalizeDataType(propertyRecordSchema?.refValueType);
                 const propertyNames = getMetadataPropertyNamesForQuery(propertyName, normalizedDataType, normalizedRefValueType);
                 const propertyNameVariant = propertyNames.length > 1 ? propertyNames[1] : undefined;
-                const _mod_11 = await import('./index-QMrBK-L3.js');
+                const _mod_11 = await import('./index-DrEkRiuK.js');
                 const _ns_11 = _mod_11.s;
                 const seedSchemaMod = _ns_11;
                 const { metadata } = seedSchemaMod;
@@ -8215,7 +8224,7 @@ class ItemProperty {
     }
     async save() {
         const ctx = this._getSnapshotContext();
-        const { assertItemOwned } = await import('./ownership-BF_ZUKIp.js');
+        const { assertItemOwned } = await Promise.resolve().then(function () { return ownership; });
         await assertItemOwned({
             seedLocalId: ctx?.seedLocalId ?? undefined,
             seedUid: ctx?.seedUid ?? undefined,
@@ -8308,7 +8317,7 @@ class ItemProperty {
                 if (!propertyName || (!seedLocalId && !seedUid))
                     return;
                 if (db) {
-                    const _mod_12 = await import('./index-QMrBK-L3.js');
+                    const _mod_12 = await import('./index-DrEkRiuK.js');
                     const _ns_12 = _mod_12.s;
                     const seedSchemaMod = _ns_12;
                     const { metadata } = seedSchemaMod;
@@ -8556,7 +8565,7 @@ class Item {
             });
         };
         this.unpublish = async () => {
-            const { assertItemOwned } = await import('./ownership-BF_ZUKIp.js');
+            const { assertItemOwned } = await Promise.resolve().then(function () { return ownership; });
             const { getRevokeExecutor } = await Promise.resolve().then(function () { return publishConfig; });
             await assertItemOwned(this);
             const seedUid = this.seedUid;
@@ -8580,7 +8589,7 @@ class Item {
             this._service.send({ type: 'updateContext', revokedAt });
         };
         this.publish = async () => {
-            const { assertItemOwned } = await import('./ownership-BF_ZUKIp.js');
+            const { assertItemOwned } = await Promise.resolve().then(function () { return ownership; });
             await assertItemOwned(this);
             this._service.send({ type: 'startPublish' });
             return new Promise((resolve, reject) => {
@@ -8616,12 +8625,12 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const getPublishUploadsMod = await import('./getPublishUploads-D9rPHkB7.js');
+            const getPublishUploadsMod = await import('./getPublishUploads-CJjfqJi9.js');
             const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this, [], undefined, options);
         };
         this.getPublishPayload = async (uploadedTransactions, options) => {
-            const getPublishPayloadMod = await import('./getPublishPayload-CNYsn8-6.js');
+            const getPublishPayloadMod = await import('./getPublishPayload-BEO52UOv.js');
             const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions, options);
         };
@@ -9093,11 +9102,11 @@ class Item {
             let modelRecords;
             // If we have a schema name, join with modelSchemas to filter by schema
             if (schemaName) {
-                const _mod_13 = await import('./BasePathResolver-BDgc7c4T.js');
+                const _mod_13 = await import('./BasePathResolver-DWY_hb8w.js');
                 const _ns_13 = _mod_13.x;
                 const modelSchemaSchemaMod = _ns_13;
                 const { modelSchemas } = modelSchemaSchemaMod;
-                const _mod_14 = await import('./BasePathResolver-BDgc7c4T.js');
+                const _mod_14 = await import('./BasePathResolver-DWY_hb8w.js');
                 const _ns_14 = _mod_14.S;
                 const schemaSchemaMod = _ns_14;
                 const { schemas: schemasTable } = schemaSchemaMod;
@@ -9278,6 +9287,39 @@ class Item {
         }
         return null;
     }
+    /**
+     * Drop cached Item instances for the given seed local ids / uids without soft-deleting DB rows.
+     * Used by local purge (`removeLocalCopiesForAddresses`) before hard-deleting rows.
+     */
+    static dropCachedInstancesForSeedIds(ids) {
+        const uniqueIds = [
+            ...new Set(ids.filter((id) => typeof id === 'string' && id.length > 0)),
+        ];
+        const seenInstances = new Set();
+        for (const id of uniqueIds) {
+            const entry = this.findItemInstanceCacheEntryById(id);
+            if (entry && !seenInstances.has(entry.instance)) {
+                seenInstances.add(entry.instance);
+                const instance = entry.instance;
+                const cacheKeys = this.collectInstanceCacheKeysForInstance(instance);
+                clearDestroySubscriptions(instance, {
+                    instanceState: itemInstanceState,
+                    onUnload: (inst) => inst._subscription?.unsubscribe(),
+                });
+                forceRemoveFromCaches(instance, {
+                    getCacheKeys: () => cacheKeys,
+                    caches: [Item.instanceCache],
+                });
+                try {
+                    instance._service.stop();
+                }
+                catch {
+                    // Service may already be stopped
+                }
+            }
+            ItemProperty.clearInstanceCacheForItem(id);
+        }
+    }
     /**
      * Create Item instance by ID (queries database if not in cache)
      * The ID can be either seedUid or seedLocalId
@@ -9366,7 +9408,7 @@ class Item {
         if (!appDb || Item.instanceCache.size === 0) {
             return;
         }
-        const _mod_15 = await import('./index-QMrBK-L3.js');
+        const _mod_15 = await import('./index-DrEkRiuK.js');
         const _ns_15 = _mod_15.s;
         const { metadata } = _ns_15;
         const { eq, and } = await import('drizzle-orm');
@@ -9817,7 +9859,7 @@ class Item {
                 itemActor.send(event);
             };
             try {
-                const _mod_16 = await import('./index-QMrBK-L3.js');
+                const _mod_16 = await import('./index-DrEkRiuK.js');
                 const _ns_16 = _mod_16.s;
                 const seedSchemaMod = _ns_16;
                 const { seeds, versions, metadata } = seedSchemaMod;
@@ -10123,7 +10165,7 @@ class Item {
      * Destroy the item: soft delete in DB, remove from caches, clean up subscriptions, stop service.
      */
     async destroy() {
-        const { assertItemOwned } = await import('./ownership-BF_ZUKIp.js');
+        const { assertItemOwned } = await Promise.resolve().then(function () { return ownership; });
         await assertItemOwned(this);
         const context = this._getSnapshotContext();
         const cacheKeys = Item.collectInstanceCacheKeysForInstance(this);
@@ -10279,7 +10321,7 @@ const runEasSync = fromPromise(async ({ input, }) => {
         requestPayload: input.requestPayload,
         persistedSnapshot: input.runningSnapshot,
     });
-    const { runSyncFromEas } = await import('./syncDbWithEas-DMOJHtkP.js');
+    const { runSyncFromEas } = await import('./syncDbWithEas-ceVUuWSZ.js');
     try {
         await runSyncFromEas(toRunSyncArg(input.options));
         await finalizeEasSyncProcessRow(rowId, {
@@ -10558,7 +10600,7 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
         }
         // Prefer the condition-resolved factory when available; fall back to explicit
         // platform imports so source/vitest resolution stays reliable.
-        const { configurePlatform } = await import('./configurePlatform-R5neRbQ9.js');
+        const { configurePlatform } = await import('./configurePlatform-CXQCT7N8.js');
         if (isBrowser()) {
             const { createPlatformServices } = await import('./platform.browser.js');
             configurePlatform(createPlatformServices());
@@ -10636,6 +10678,7 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
                 gatewayHyperKey: resolvedGateway.gatewayHyperKey,
                 gatewaySidecarHost: gatewayConfig.hyper?.localSidecarHost,
                 gatewaySidecarPort: gatewayConfig.hyper?.localSidecarPort,
+                gatewayProxyBaseUrl: resolvedGateway.proxyBaseUrl ?? gatewayConfig.proxyBaseUrl,
                 addresses: normalizedAddresses.owned,
                 ownedAddresses: normalizedAddresses.owned,
                 watchedAddresses: normalizedAddresses.watched,
@@ -10645,7 +10688,7 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
                 schema,
                 syncFromEasOnAddressChange: options.syncFromEasOnAddressChange ?? true,
             } });
-        if (resolvedGateway.activePath !== 'hyper-sidecar') {
+        if (resolvedGateway.activePath !== 'hyper-sidecar' && resolvedGateway.activePath !== 'http-proxy') {
             void ensureReadGatewaySelected().catch(() => {
                 /* non-blocking warm-up for read gateway probe */
             });
@@ -10984,7 +11027,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
 const logger$5 = debug('seedSdk:client:actors:saveConfig');
 const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
     logger$5('saveConfig starting');
-    const { endpoints, addresses, ownedAddresses, watchedAddresses, arweaveDomain, uploadApiBaseUrl, gatewayTransport, gatewayHyperKey, gatewaySidecarHost, gatewaySidecarPort, } = context;
+    const { endpoints, addresses, ownedAddresses, watchedAddresses, arweaveDomain, uploadApiBaseUrl, gatewayTransport, gatewayHyperKey, gatewaySidecarHost, gatewaySidecarPort, gatewayProxyBaseUrl, } = context;
     // Validate endpoints - required for proper initialization
     // If endpoints are missing or invalid, initialization should fail
     if (!endpoints || !endpoints.filePaths || !endpoints.files) {
@@ -11064,6 +11107,7 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
             if (gatewaySidecarPort != null) {
                 await persistKey('gatewaySidecarPort', String(gatewaySidecarPort));
             }
+            await persistKey('gatewayProxyBaseUrl', gatewayProxyBaseUrl);
         }
         catch (error) {
             logger$5('[internal/actors] [saveConfig] Error saving config:', error);
@@ -11185,6 +11229,50 @@ const readSchema = async (name, version, schemaFileId) => {
         throw new Error(`Failed to read schema ${name} v${version}: ${error instanceof Error ? error.message : String(error)}`);
     }
 };
+/**
+ * Update an existing schema file
+ * @param schema - The updated schema object (must have same name and version as existing)
+ * @param schemaFileId - Schema file ID (required)
+ * @throws Error if schema doesn't exist
+ */
+async function updateSchema(schema, schemaFileId) {
+    if (!schema.name || !schema.version) {
+        throw new Error('Schema must have a name and version');
+    }
+    const filePath = getSchemaFilePath$1(schema.name, schema.version, schemaFileId);
+    // Check if schema exists
+    const exists = await BaseFileManager.pathExists(filePath);
+    if (!exists) {
+        throw new Error(`Schema ${schema.name} v${schema.version} does not exist`);
+    }
+    // Write updated schema to file
+    const content = JSON.stringify(schema, null, 2);
+    await BaseFileManager.saveFile(filePath, content);
+}
+/**
+ * Delete a schema file
+ * @param name - The name of the schema
+ * @param version - The version of the schema
+ * @param schemaFileId - Schema file ID (required)
+ * @throws Error if schema doesn't exist
+ */
+async function deleteSchema(name, version, schemaFileId) {
+    const filePath = getSchemaFilePath$1(name, version, schemaFileId);
+    // Check if schema exists
+    const exists = await BaseFileManager.pathExists(filePath);
+    if (!exists) {
+        throw new Error(`Schema ${name} v${version} does not exist`);
+    }
+    // Delete the file
+    const fs = await BaseFileManager.getFs();
+    BaseFileManager.getPathModule();
+    try {
+        await fs.promises.unlink(filePath);
+    }
+    catch (error) {
+        throw new Error(`Failed to delete schema ${name} v${version}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
 /**
  * List all schema files in the working directory
  * Only returns files that are NOT already complete schema files (i.e., files without $schema field)
@@ -11295,6 +11383,24 @@ async function listCompleteSchemaFiles() {
         throw new Error(`Failed to list complete schemas: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
+/**
+ * Find a schema by name (returns the latest version if multiple versions exist)
+ * @param name - The name of the schema
+ * @returns The schema with the highest version, or null if not found
+ */
+async function findSchemaByName(name) {
+    const schemas = await listCompleteSchemaFiles();
+    const matchingSchemas = schemas.filter((s) => s.name === name);
+    if (matchingSchemas.length === 0) {
+        return null;
+    }
+    // Find the schema with the highest version
+    const latest = matchingSchemas.reduce((prev, current) => current.version > prev.version ? current : prev);
+    if (!latest.schemaFileId) {
+        throw new Error(`Schema ${latest.name} v${latest.version} is missing schemaFileId`);
+    }
+    return readSchema(latest.name, latest.version, latest.schemaFileId);
+}
 /**
  * Get the latest version number for a schema by name
  * Only considers complete schema files (with $schema field)
@@ -11327,6 +11433,27 @@ async function listLatestSchemaFiles() {
     }
     return Array.from(schemaMap.values());
 }
+/**
+ * Filter an array of schemas to only include the latest version for each schema name
+ * Works with any object that has a name (via metadata.name or name property) and a version property
+ * @param schemas - Array of schema objects
+ * @returns Array containing only the latest version of each schema
+ */
+function filterLatestSchemas(schemas) {
+    // Group by schema name and keep only the latest version of each
+    const schemaMap = new Map();
+    for (const schema of schemas) {
+        const schemaName = schema.metadata?.name || schema.name;
+        if (!schemaName) {
+            continue; // Skip schemas without a name
+        }
+        const existing = schemaMap.get(schemaName);
+        if (!existing || schema.version > existing.version) {
+            schemaMap.set(schemaName, schema);
+        }
+    }
+    return Array.from(schemaMap.values());
+}
 /**
  * Unified schema loading function that queries database first, then merges with files
  * Returns all schemas with their draft status and source information
@@ -11520,6 +11647,62 @@ async function loadAllSchemasFromDb() {
     }
     return result;
 }
+/**
+ * Migration helper: Migrate existing file-based schemas to the database
+ * This function should be called once to migrate existing schema files to the new database-first approach
+ * All existing schemas will be marked as published (isDraft = false) since they already exist in files
+ * @returns Number of schemas migrated
+ */
+async function migrateFileSchemasToDb() {
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        throw new Error('Database not found');
+    }
+    logger$4('Starting migration of file-based schemas to database');
+    // Get all complete schema files
+    const completeSchemas = await listCompleteSchemaFiles();
+    let migratedCount = 0;
+    for (const schemaFileInfo of completeSchemas) {
+        try {
+            // Read the schema file
+            const content = await BaseFileManager.readFileAsString(schemaFileInfo.filePath);
+            const schemaFile = JSON.parse(content);
+            if (!schemaFile.$schema || !schemaFile.metadata?.name) {
+                logger$4(`Skipping invalid schema file: ${schemaFileInfo.filePath}`);
+                continue;
+            }
+            const schemaName = schemaFile.metadata.name;
+            // Check if schema already exists in database
+            const existingSchemas = await db
+                .select()
+                .from(schemas)
+                .where(eq(schemas.name, schemaName))
+                .limit(1);
+            // Only migrate if it doesn't exist or if existing record doesn't have schemaFileId
+            if (existingSchemas.length === 0 || !existingSchemas[0].schemaFileId) {
+                // Add schema to database as published (isDraft = false)
+                await addSchemaToDb({
+                    name: schemaName,
+                    version: schemaFile.version,
+                    createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
+                    updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
+                }, schemaFile.id, // schemaFileId
+                JSON.stringify(schemaFile, null, 2), // schemaData
+                false);
+                migratedCount++;
+                logger$4(`Migrated schema: ${schemaName} v${schemaFile.version}`);
+            }
+            else {
+                logger$4(`Schema ${schemaName} already exists in database, skipping`);
+            }
+        }
+        catch (error) {
+            logger$4(`Error migrating schema file ${schemaFileInfo.filePath}:`, error);
+        }
+    }
+    logger$4(`Migration complete: ${migratedCount} schemas migrated`);
+    return migratedCount;
+}
 /**
  * Extract the schema name from a schemaId string
  * @param schemaId - Schema ID in the format `${schemaName}-${schemaVersion}`
@@ -11539,13 +11722,18 @@ function getSchemaNameFromId(schemaId) {
 var schema = /*#__PURE__*/Object.freeze({
     __proto__: null,
     createSchema: createSchema,
+    deleteSchema: deleteSchema,
+    filterLatestSchemas: filterLatestSchemas,
+    findSchemaByName: findSchemaByName,
     getLatestSchemaVersion: getLatestSchemaVersion,
     getSchemaNameFromId: getSchemaNameFromId,
     listCompleteSchemaFiles: listCompleteSchemaFiles,
     listLatestSchemaFiles: listLatestSchemaFiles,
     listSchemaFiles: listSchemaFiles,
     loadAllSchemasFromDb: loadAllSchemasFromDb,
-    readSchema: readSchema
+    migrateFileSchemasToDb: migrateFileSchemasToDb,
+    readSchema: readSchema,
+    updateSchema: updateSchema
 });
 
 const { sha3_256 } = sha3;
@@ -11639,7 +11827,7 @@ function getRefValueType(prop) {
  * @returns Promise that resolves when properties are found, or rejects if not found after max retries
  */
 const verifyPropertiesPersisted = async (db, modelId, modelName, maxRetries = 10, retryDelay = 100) => {
-    const _mod_17 = await import('./BasePathResolver-BDgc7c4T.js');
+    const _mod_17 = await import('./BasePathResolver-DWY_hb8w.js');
     const _ns_17 = _mod_17.M;
     const modelSchemaMod = _ns_17;
     const { properties: propertiesTable } = modelSchemaMod;
@@ -11987,7 +12175,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         // Check DB for existing schema by name+version (same as minimal path)
         const db = BaseDb.getAppDb();
         if (db) {
-            const _mod_18 = await import('./BasePathResolver-BDgc7c4T.js');
+            const _mod_18 = await import('./BasePathResolver-DWY_hb8w.js');
             const _ns_18 = _mod_18.S;
             const schemaSchemaMod = _ns_18;
             const { schemas: schemasTable } = schemaSchemaMod;
@@ -12071,7 +12259,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         // For minimal imports: check DB for existing schema before creating new file
         const db = BaseDb.getAppDb();
         if (db) {
-            const _mod_19 = await import('./BasePathResolver-BDgc7c4T.js');
+            const _mod_19 = await import('./BasePathResolver-DWY_hb8w.js');
             const _ns_19 = _mod_19.S;
             const schemaSchemaMod = _ns_19;
             const { schemas: schemasTable } = schemaSchemaMod;
@@ -12252,7 +12440,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
             updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
         };
         // Use dynamic import to break circular dependency
-        const dbMod = await import('./db-Cvh84NY7.js');
+        const dbMod = await import('./db-Bad8QKfZ.js');
         const { addSchemaToDb, addModelsToDb } = dbMod;
         // Try to add schema and models to database if database is available
         try {
@@ -12272,11 +12460,11 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                     });
                     // Verify expected models are linked (single attempt - addModelsToDb already confirmed)
                     const expectedModelNames = Object.keys(schemaFile.models || {});
-                    const _mod_20 = await import('./BasePathResolver-BDgc7c4T.js');
+                    const _mod_20 = await import('./BasePathResolver-DWY_hb8w.js');
                     const _ns_20 = _mod_20.x;
                     const modelSchemaSchemaMod = _ns_20;
                     const { modelSchemas } = modelSchemaSchemaMod;
-                    const _mod_21 = await import('./BasePathResolver-BDgc7c4T.js');
+                    const _mod_21 = await import('./BasePathResolver-DWY_hb8w.js');
                     const _ns_21 = _mod_21.M;
                     const modelSchemaMod = _ns_21;
                     const { models: modelsTable } = modelSchemaMod;
@@ -12479,7 +12667,7 @@ async function applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, prope
         createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
         updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
     };
-    const dbMod = await import('./db-Cvh84NY7.js');
+    const dbMod = await import('./db-Bad8QKfZ.js');
     const { addSchemaToDb, addModelsToDb } = dbMod;
     const db = BaseDb.getAppDb();
     if (!db) {
@@ -12637,11 +12825,11 @@ const loadSchemaFromFile = async (schemaFilePath) => {
             if (db) {
                 const { schemaRecord } = await applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, propertyFileIds);
                 // Query the database to get model IDs that were just created
-                const _mod_22 = await import('./BasePathResolver-BDgc7c4T.js');
+                const _mod_22 = await import('./BasePathResolver-DWY_hb8w.js');
                 const _ns_22 = _mod_22.x;
                 const modelSchemaSchemaMod = _ns_22;
                 const { modelSchemas } = modelSchemaSchemaMod;
-                const _mod_23 = await import('./BasePathResolver-BDgc7c4T.js');
+                const _mod_23 = await import('./BasePathResolver-DWY_hb8w.js');
                 const _ns_23 = _mod_23.M;
                 const modelSchemaMod = _ns_23;
                 const { models: modelsTable } = modelSchemaMod;
@@ -12707,7 +12895,7 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                 // After properties are created (file path), ensure schemaFile has the correct IDs from database
                 // Query the database to get the actual schemaFileId values that were used
                 // This ensures schemaData matches what's actually in the database
-                const _mod_24 = await import('./BasePathResolver-BDgc7c4T.js');
+                const _mod_24 = await import('./BasePathResolver-DWY_hb8w.js');
                 const _ns_24 = _mod_24.M;
                 const modelSchemaMod2 = _ns_24;
                 const { properties: propertiesTable } = modelSchemaMod2;
@@ -12743,7 +12931,7 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                 // This is important even if nothing changed, to ensure consistency
                 const updatedSchemaData = JSON.stringify(schemaFile, null, 2);
                 // Update the schema record in the database with current schemaData
-                const _mod_25 = await import('./BasePathResolver-BDgc7c4T.js');
+                const _mod_25 = await import('./BasePathResolver-DWY_hb8w.js');
                 const _ns_25 = _mod_25.S;
                 const schemaSchemaMod = _ns_25;
                 const { schemas: schemasTable } = schemaSchemaMod;
@@ -13424,6 +13612,8 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
 
 /** Emitted by the client manager after `app_state.addresses` is written (post-`setAddresses`). */
 const ADDRESSES_PERSISTED_EVENT = 'addresses.persisted';
+/** Emitted after hard-deleting local on-chain seed copies for publisher addresses. */
+const LOCAL_COPIES_REMOVED_EVENT = 'localCopies.removed';
 function parseAddressesPersistedPayload(value) {
     if (!value || typeof value !== 'object') {
         return { owned: [], watched: [] };
@@ -13685,6 +13875,585 @@ const clientManagerMachine = setup({
     },
 });
 
+function msToUnixSeconds(ms) {
+    if (ms == null || !Number.isFinite(ms))
+        return 0;
+    // Heuristic: values already in seconds are small; ms are large
+    if (ms > 1e12)
+        return Math.floor(ms / 1000);
+    if (ms > 1e10)
+        return Math.floor(ms / 1000);
+    return Math.floor(ms);
+}
+function toSnakeCaseName(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
+        .toLowerCase();
+}
+function parsePropertyValue(raw) {
+    if (raw == null)
+        return '';
+    const t = raw.trim();
+    if ((t.startsWith('[') && t.endsWith(']')) ||
+        (t.startsWith('{') && t.endsWith('}'))) {
+        try {
+            return JSON.parse(t);
+        }
+        catch {
+            return raw;
+        }
+    }
+    return raw;
+}
+function attestationFromRaw(raw) {
+    if (!raw || !raw.trim())
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed.id === 'string')
+            return parsed;
+    }
+    catch {
+        // fall through
+    }
+    return null;
+}
+function seedRowToAttestation(row) {
+    if (!row.uid || !isValidEasAttestationUid(row.uid))
+        return null;
+    const fromRaw = attestationFromRaw(row.attestationRaw);
+    if (fromRaw) {
+        const schemaName = row.schemaName ??
+            fromRaw.schema?.schemaNames?.[0]?.name ??
+            row.type ??
+            'unknown';
+        return {
+            ...fromRaw,
+            id: row.uid,
+            schema: {
+                schemaNames: [{ name: schemaName }],
+            },
+            timeCreated: fromRaw.timeCreated ||
+                msToUnixSeconds(row.attestationCreatedAt),
+            attester: fromRaw.attester ?? row.publisher ?? undefined,
+            schemaId: fromRaw.schemaId || row.schemaUid || '',
+        };
+    }
+    const schemaName = row.schemaName ?? row.type ?? 'unknown';
+    return {
+        id: row.uid,
+        decodedDataJson: '',
+        refUID: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        schemaId: row.schemaUid || '',
+        timeCreated: msToUnixSeconds(row.attestationCreatedAt),
+        attester: row.publisher ?? undefined,
+        schema: { schemaNames: [{ name: schemaName }] },
+    };
+}
+function versionRowToAttestation(row) {
+    if (!row.uid || !isValidEasAttestationUid(row.uid))
+        return null;
+    if (!row.seedUid)
+        return null;
+    const fromRaw = attestationFromRaw(row.attestationRaw);
+    if (fromRaw) {
+        return {
+            ...fromRaw,
+            id: row.uid,
+            refUID: row.seedUid,
+            timeCreated: fromRaw.timeCreated ||
+                msToUnixSeconds(row.attestationCreatedAt),
+            attester: fromRaw.attester ?? row.publisher ?? undefined,
+        };
+    }
+    return {
+        id: row.uid,
+        decodedDataJson: '',
+        refUID: row.seedUid,
+        schemaId: '',
+        timeCreated: msToUnixSeconds(row.attestationCreatedAt),
+        attester: row.publisher ?? undefined,
+    };
+}
+function metadataRowToAttestation(row) {
+    if (!row.uid || !isValidEasAttestationUid(row.uid))
+        return null;
+    if (!row.versionUid)
+        return null;
+    const fromRaw = attestationFromRaw(row.attestationRaw);
+    if (fromRaw) {
+        return {
+            ...fromRaw,
+            id: row.uid,
+            refUID: row.versionUid,
+            schemaId: fromRaw.schemaId || row.schemaUid || '',
+            timeCreated: fromRaw.timeCreated ||
+                msToUnixSeconds(row.attestationCreatedAt),
+            attester: fromRaw.attester ?? row.publisher ?? undefined,
+        };
+    }
+    const name = row.propertyName
+        ? toSnakeCaseName(row.propertyName)
+        : 'unknown';
+    const value = parsePropertyValue(row.propertyValue);
+    const type = row.easDataType || 'string';
+    return {
+        id: row.uid,
+        decodedDataJson: JSON.stringify([{ value: { name, value, type } }]),
+        refUID: row.versionUid,
+        schemaId: row.schemaUid || '',
+        timeCreated: msToUnixSeconds(row.attestationCreatedAt),
+        attester: row.publisher ?? undefined,
+    };
+}
+async function resolveSchemaNameForSeedType(appDb, seedType) {
+    if (!seedType)
+        return null;
+    const normalized = startCase(seedType);
+    try {
+        const schemaRows = await appDb
+            .select({ schemaName: schemas.name })
+            .from(models$1)
+            .innerJoin(modelSchemas, eq(models$1.id, modelSchemas.modelId))
+            .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
+            .where(eq(models$1.name, normalized))
+            .limit(1);
+        if (schemaRows[0]?.schemaName)
+            return schemaRows[0].schemaName;
+    }
+    catch {
+        // ignore
+    }
+    return seedType;
+}
+function monthBoundsUnix(year, month) {
+    const startDate = new Date(year, month - 1, 1);
+    const endDate = new Date(year, month, 0, 23, 59, 59);
+    const startTs = Math.floor(startDate.getTime() / 1000);
+    const endTs = Math.floor(endDate.getTime() / 1000) + 1;
+    return { startTs, endTs };
+}
+async function listPublishedSeedRows(schemaName, opts) {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb)
+        return [];
+    const snakeType = schemaName.includes('_')
+        ? schemaName
+        : schemaName.replace(/([A-Z])/g, (m, i) => i === 0 ? m.toLowerCase() : `_${m.toLowerCase()}`);
+    // Prefer exact type match (EAS schema names are usually lowercase singular)
+    const typeCandidates = Array.from(new Set([schemaName, schemaName.toLowerCase(), snakeType.toLowerCase()]));
+    const rows = await appDb
+        .select({
+        uid: seeds.uid,
+        schemaUid: seeds.schemaUid,
+        type: seeds.type,
+        publisher: seeds.publisher,
+        attestationRaw: seeds.attestationRaw,
+        attestationCreatedAt: seeds.attestationCreatedAt,
+        revokedAt: seeds.revokedAt,
+        markedForDeletion: seeds._markedForDeletion,
+    })
+        .from(seeds)
+        .where(and(inArray(seeds.type, typeCandidates), isNotNull(seeds.uid), or(isNull(seeds.revokedAt), eq(seeds.revokedAt, 0)), or(isNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 0))))
+        .orderBy(desc(seeds.attestationCreatedAt));
+    const out = [];
+    for (const row of rows) {
+        if (!row.uid || !isValidEasAttestationUid(row.uid))
+            continue;
+        // Must have at least one published version
+        const versionRows = await appDb
+            .select({
+            uid: versions.uid,
+        })
+            .from(versions)
+            .where(eq(versions.seedUid, row.uid))
+            .orderBy(desc(versions.createdAt));
+        const hasPublished = versionRows.some((v) => v.uid && isValidEasAttestationUid(v.uid));
+        if (!hasPublished)
+            continue;
+        const schemaResolved = await resolveSchemaNameForSeedType(appDb, row.type);
+        const att = seedRowToAttestation({
+            ...row,
+            schemaName: schemaResolved === schemaName ? schemaName : (schemaResolved ?? schemaName),
+        });
+        if (!att)
+            continue;
+        // Force requested schema name so assembleSeeds filters correctly
+        att.schema = { schemaNames: [{ name: schemaName }] };
+        if (opts?.startTs != null || opts?.endTs != null) {
+            const t = att.timeCreated;
+            if (opts.startTs != null && t < opts.startTs)
+                continue;
+            if (opts.endTs != null && t >= opts.endTs)
+                continue;
+        }
+        out.push(att);
+    }
+    return out;
+}
+/**
+ * SDK local QueryDataSource: published Seeds/Versions/metadata from SQLite.
+ */
+function createLocalQueryDataSource() {
+    return {
+        kind: 'local',
+        async getSeedByUid(seedUid) {
+            const appDb = BaseDb.getAppDb();
+            if (!appDb || !seedUid)
+                return null;
+            const rows = await appDb
+                .select({
+                uid: seeds.uid,
+                schemaUid: seeds.schemaUid,
+                type: seeds.type,
+                publisher: seeds.publisher,
+                attestationRaw: seeds.attestationRaw,
+                attestationCreatedAt: seeds.attestationCreatedAt,
+                revokedAt: seeds.revokedAt,
+            })
+                .from(seeds)
+                .where(eq(seeds.uid, seedUid))
+                .limit(1);
+            const row = rows[0];
+            if (!row?.uid || !isValidEasAttestationUid(row.uid))
+                return null;
+            if (row.revokedAt != null && row.revokedAt !== 0)
+                return null;
+            const schemaName = await resolveSchemaNameForSeedType(appDb, row.type);
+            return seedRowToAttestation({ ...row, schemaName });
+        },
+        async listSeedsBySchemaName(schemaName, opts) {
+            const all = await listPublishedSeedRows(schemaName);
+            return all.slice(opts.skip, opts.skip + opts.limit);
+        },
+        async listSeedsBySchemaNameForMonth(schemaName, year, month) {
+            const { startTs, endTs } = monthBoundsUnix(year, month);
+            return listPublishedSeedRows(schemaName, { startTs, endTs });
+        },
+        async getVersionsForSeed(seedUid) {
+            return this.getVersionsForSeeds([seedUid]);
+        },
+        async getVersionsForSeeds(seedUids) {
+            const appDb = BaseDb.getAppDb();
+            if (!appDb || seedUids.length === 0)
+                return [];
+            const rows = await appDb
+                .select({
+                uid: versions.uid,
+                seedUid: versions.seedUid,
+                publisher: versions.publisher,
+                attestationRaw: versions.attestationRaw,
+                attestationCreatedAt: versions.attestationCreatedAt,
+            })
+                .from(versions)
+                .where(inArray(versions.seedUid, seedUids));
+            const out = [];
+            for (const row of rows) {
+                const att = versionRowToAttestation(row);
+                if (att)
+                    out.push(att);
+            }
+            return out;
+        },
+        async getPropertiesForVersionUids(versionUids) {
+            const appDb = BaseDb.getAppDb();
+            if (!appDb || versionUids.length === 0)
+                return [];
+            const rows = await appDb
+                .select({
+                uid: metadata$1.uid,
+                schemaUid: metadata$1.schemaUid,
+                propertyName: metadata$1.propertyName,
+                propertyValue: metadata$1.propertyValue,
+                easDataType: metadata$1.easDataType,
+                versionUid: metadata$1.versionUid,
+                publisher: metadata$1.publisher,
+                attestationRaw: metadata$1.attestationRaw,
+                attestationCreatedAt: metadata$1.attestationCreatedAt,
+            })
+                .from(metadata$1)
+                .where(inArray(metadata$1.versionUid, versionUids));
+            const out = [];
+            for (const row of rows) {
+                const att = metadataRowToAttestation(row);
+                if (att)
+                    out.push(att);
+            }
+            return out;
+        },
+        async getSeedsByUids(uids) {
+            const appDb = BaseDb.getAppDb();
+            if (!appDb || uids.length === 0)
+                return [];
+            const rows = await appDb
+                .select({
+                uid: seeds.uid,
+                schemaUid: seeds.schemaUid,
+                type: seeds.type,
+                publisher: seeds.publisher,
+                attestationRaw: seeds.attestationRaw,
+                attestationCreatedAt: seeds.attestationCreatedAt,
+                revokedAt: seeds.revokedAt,
+            })
+                .from(seeds)
+                .where(inArray(seeds.uid, uids));
+            const out = [];
+            for (const row of rows) {
+                if (row.revokedAt != null && row.revokedAt !== 0)
+                    continue;
+                const schemaName = await resolveSchemaNameForSeedType(appDb, row.type);
+                const att = seedRowToAttestation({ ...row, schemaName });
+                if (att)
+                    out.push(att);
+            }
+            return out;
+        },
+        async readStorageBody(ref) {
+            try {
+                if (ref.localPathHint) {
+                    const text = await BaseFileManager.readFileAsString(ref.localPathHint);
+                    if (text)
+                        return text;
+                }
+                // Common layout: html/{name}.html under filesDir
+                if (typeof ref.value === 'string') {
+                    const v = ref.value.trim();
+                    // Absolute or relative file path already on disk
+                    if (v.includes('/') && !v.startsWith('http')) {
+                        try {
+                            const text = await BaseFileManager.readFileAsString(v);
+                            if (text)
+                                return text;
+                        }
+                        catch {
+                            // try under html/
+                        }
+                    }
+                    const htmlPath = BaseFileManager.getFilesPath('html', v.endsWith('.html') ? v : `${v}.html`);
+                    try {
+                        const text = await BaseFileManager.readFileAsString(htmlPath);
+                        if (text)
+                            return text;
+                    }
+                    catch {
+                        // fall through
+                    }
+                }
+            }
+            catch {
+                return null;
+            }
+            return null;
+        },
+    };
+}
+
+let registered = false;
+/**
+ * Register the SDK SQLite/files adapter with `@seedprotocol/query`.
+ * Safe to call multiple times; re-registers with a fresh adapter instance.
+ * No-op when the app DB is not ready yet (unless `force`).
+ */
+function registerSeedQueryLocalSource(options) {
+    if (!options?.force && !BaseDb.isAppDbReady()) {
+        return false;
+    }
+    try {
+        registerLocalQuerySource(createLocalQueryDataSource());
+        registered = true;
+        return true;
+    }
+    catch (err) {
+        console.warn('[sdk/query] registerSeedQueryLocalSource failed:', err);
+        return false;
+    }
+}
+/** Unregister local query source (tests / client unload). */
+function unregisterSeedQueryLocalSource() {
+    clearLocalQuerySource();
+    registered = false;
+}
+function isSeedQueryLocalSourceRegistered() {
+    return registered;
+}
+/**
+ * Thin published-JSON helper: `getSeed` via the local (or auto) query source.
+ * Does not touch Item / drafts / liveQuery.
+ *
+ * Prefer this (or `@seedprotocol/query` `getSeed` / `queryBySchema`) for
+ * canonical published Seed JSON. Use `getItemData` / Item for draft-head authoring.
+ */
+async function getPublishedSeedRecord(seedUid, options) {
+    if (!registered) {
+        registerSeedQueryLocalSource();
+    }
+    const source = options?.source ?? 'local';
+    return getSeed(seedUid, { ...options, source });
+}
+
+const READ_ONLY_ERROR = 'Item is read-only: you do not own this item';
+async function getSeedRowForItem(item) {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb)
+        return null;
+    const conditions = [];
+    if (item.seedLocalId)
+        conditions.push(eq(seeds.localId, item.seedLocalId));
+    if (item.seedUid)
+        conditions.push(eq(seeds.uid, item.seedUid));
+    if (conditions.length === 0)
+        return null;
+    const seedRows = await appDb
+        .select({
+        publisher: seeds.publisher,
+        attestationRaw: seeds.attestationRaw,
+        uid: seeds.uid,
+    })
+        .from(seeds)
+        .where(conditions.length === 1 ? conditions[0] : or(...conditions))
+        .limit(1);
+    if (!seedRows || seedRows.length === 0)
+        return null;
+    return seedRows[0];
+}
+/** Resolve publisher from seed row: `publisher` column, else `attestationRaw.attester`. */
+function resolvePublisherFromSeedRow(row) {
+    if (row.publisher)
+        return row.publisher;
+    if (row.attestationRaw) {
+        try {
+            const parsed = JSON.parse(row.attestationRaw);
+            return parsed.attester ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Checks if the current user owns the item (publisher is in owned addresses).
+ * Locally created items (no publisher, no attestationRaw) are considered owned.
+ * Includes getAdditionalSyncAddresses (e.g. `modularAccountModuleContract` when configured)
+ * so ownership aligns with EAS sync when the publisher/attester matches those addresses.
+ */
+async function isItemOwned(item) {
+    const row = await getSeedRowForItem(item);
+    if (!row)
+        return false;
+    const publisher = resolvePublisherFromSeedRow(row);
+    if (!publisher) {
+        if (!row.uid && !row.attestationRaw) {
+            return true;
+        }
+        return false;
+    }
+    let addressesToCheck = await getOwnedAddressesFromDb();
+    const additionalGetter = getGetAdditionalSyncAddresses();
+    if (additionalGetter) {
+        const additional = await additionalGetter();
+        if (additional?.length) {
+            const seen = new Set(addressesToCheck.map((a) => a.toLowerCase()));
+            for (const addr of additional) {
+                if (addr && !seen.has(addr.toLowerCase())) {
+                    seen.add(addr.toLowerCase());
+                    addressesToCheck = [...addressesToCheck, addr];
+                }
+            }
+        }
+    }
+    const ownedSet = new Set(addressesToCheck.map((a) => a.toLowerCase()));
+    return ownedSet.has(publisher.toLowerCase());
+}
+/**
+ * Throws if the item is not owned. Use before write operations (publish, save, destroy).
+ */
+async function assertItemOwned(item) {
+    const owned = await isItemOwned(item);
+    if (!owned) {
+        throw new Error(READ_ONLY_ERROR);
+    }
+}
+
+var ownership = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    assertItemOwned: assertItemOwned,
+    isItemOwned: isItemOwned,
+    resolvePublisherFromSeedRow: resolvePublisherFromSeedRow
+});
+
+const emptyResult = () => ({
+    removedSeedLocalIds: [],
+    removedSeedUids: [],
+});
+function normalizeAddresses(addresses) {
+    return [
+        ...new Set(addresses
+            .filter((a) => typeof a === 'string' && a.length > 0)
+            .map((a) => a.toLowerCase())),
+    ];
+}
+/**
+ * Find local on-chain seed copies for the given publisher addresses (no delete).
+ * Drafts (no uid and no attestationRaw) are excluded.
+ */
+async function findLocalOnchainCopiesForAddresses(addresses) {
+    const normalized = normalizeAddresses(addresses);
+    if (normalized.length === 0) {
+        return emptyResult();
+    }
+    const appDb = BaseDb.getAppDb();
+    if (!appDb) {
+        return emptyResult();
+    }
+    const addressSet = new Set(normalized);
+    const candidateRows = (await appDb
+        .select({
+        localId: seeds.localId,
+        uid: seeds.uid,
+        publisher: seeds.publisher,
+        attestationRaw: seeds.attestationRaw,
+    })
+        .from(seeds)
+        .where(or(isNotNull(seeds.uid), isNotNull(seeds.attestationRaw))));
+    const matched = candidateRows.filter((row) => {
+        if (!row.localId)
+            return false;
+        const publisher = resolvePublisherFromSeedRow(row);
+        return publisher != null && addressSet.has(publisher.toLowerCase());
+    });
+    return {
+        removedSeedLocalIds: matched.map((r) => r.localId).filter(Boolean),
+        removedSeedUids: matched
+            .map((r) => r.uid)
+            .filter((u) => typeof u === 'string' && u.length > 0),
+    };
+}
+/**
+ * Hard-delete the given seed local ids and related local rows (cascade).
+ * Does not touch schemas, app_state, or chain.
+ */
+async function hardDeleteLocalSeedsByLocalIds(seedLocalIds) {
+    if (seedLocalIds.length === 0)
+        return;
+    const appDb = BaseDb.getAppDb();
+    if (!appDb)
+        return;
+    await appDb
+        .delete(htmlEmbeddedImageCoPublish)
+        .where(or(inArray(htmlEmbeddedImageCoPublish.parentSeedLocalId, seedLocalIds), inArray(htmlEmbeddedImageCoPublish.htmlSeedLocalId, seedLocalIds), inArray(htmlEmbeddedImageCoPublish.imageSeedLocalId, seedLocalIds)));
+    await appDb
+        .delete(arweaveL1FinalizeJobs)
+        .where(inArray(arweaveL1FinalizeJobs.seedLocalId, seedLocalIds));
+    await appDb
+        .delete(publishProcesses)
+        .where(inArray(publishProcesses.seedLocalId, seedLocalIds));
+    await appDb.delete(metadata$1).where(inArray(metadata$1.seedLocalId, seedLocalIds));
+    await appDb.delete(versions).where(inArray(versions.seedLocalId, seedLocalIds));
+    await appDb.delete(seeds).where(inArray(seeds.localId, seedLocalIds));
+}
+
 const logger$1 = debug('seedSdk:client');
 const clientManager = createActor(clientManagerMachine, {
     input: {
@@ -13789,6 +14558,8 @@ const clientInstance = {
             }
             throw error;
         }
+        // Wire `@seedprotocol/query` local source once DB is ready
+        registerSeedQueryLocalSource({ force: true });
     },
     setAddresses: async (addresses) => {
         ensureInitialized();
@@ -13811,6 +14582,29 @@ const clientInstance = {
         ensureInitialized();
         return getWatchedAddressesFromDb();
     },
+    /**
+     * Hard-delete local on-chain seed copies for the given publisher addresses.
+     * Drafts (no uid / attestationRaw) are kept. Chain is untouched; reconnect can rehydrate via syncFromEas.
+     */
+    removeLocalCopiesForAddresses: async (addresses) => {
+        ensureInitialized();
+        const list = Array.isArray(addresses) ? addresses : [];
+        const matched = await findLocalOnchainCopiesForAddresses(list);
+        const cacheIds = [
+            ...matched.removedSeedLocalIds,
+            ...matched.removedSeedUids,
+        ];
+        if (cacheIds.length > 0) {
+            Item.dropCachedInstancesForSeedIds(cacheIds);
+        }
+        await hardDeleteLocalSeedsByLocalIds(matched.removedSeedLocalIds);
+        eventEmitter.emit(LOCAL_COPIES_REMOVED_EVENT, {
+            addresses: list,
+            removedSeedLocalIds: matched.removedSeedLocalIds,
+            removedSeedUids: matched.removedSeedUids,
+        });
+        return matched;
+    },
     /**
      * Syncs item attestations from EAS for the configured models and given addresses.
      * Uses owned + watched addresses from DB when addresses are not provided.
@@ -13850,10 +14644,12 @@ const clientInstance = {
     },
     stop: () => {
         ensureInitialized();
+        unregisterSeedQueryLocalSource();
         clientManager.stop();
     },
     unload: () => {
         ensureInitialized();
+        unregisterSeedQueryLocalSource();
         clientManager.stop();
         subscription.unsubscribe();
     },
@@ -14036,7 +14832,7 @@ const saveDraftLogger = debug('seedSdk:model:saveDraftToDb');
 // Lazy import cache for ModelProperty to avoid circular dependency
 // Eagerly start loading to minimize delay on first access
 let ModelPropertyClass = null;
-const modelPropertyImportPromise = import('./ModelProperty-D-ysg8zA.js')
+const modelPropertyImportPromise = import('./ModelProperty-DGJf78CS.js')
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -14053,7 +14849,7 @@ function getModelProperty() {
 }
 // Lazy import cache for Schema to avoid circular dependency
 let SchemaClass = null;
-const schemaImportPromise = (async () => { const _mod_26 = await import('./Schema-CyCftnKI.js'); return _mod_26.b; })()
+const schemaImportPromise = (async () => { const _mod_26 = await import('./Schema-Drmce3q-.js'); return _mod_26.b; })()
     .then(module => {
     SchemaClass = module.Schema;
     return SchemaClass;
@@ -15793,5 +16589,5 @@ var Model$1 = /*#__PURE__*/Object.freeze({
 const TModelValues = Type.Record(Type.String(), Type.Any());
 const TModelSchema = Type.Record(Type.String(), TProperty);
 
-export { requestEasSyncFromAddressChange as $, compareMetadataRowsLatestFirst as A, ADDRESSES_PERSISTED_EVENT as B, ClientManager as C, parseAddressesPersistedPayload as D, getClient as E, createNewItem as F, getVersionData$1 as G, getMetadataLatest as H, Item as I, loadAllSchemasFromDb as J, propertyMachine as K, setUploadExecutor as L, Model as M, getUploadExecutor as N, setGetPublisherForNewSeeds as O, getGetPublisherForNewSeeds as P, setRevokeExecutor as Q, getRevokeExecutor as R, setAdditionalSyncAddresses as S, TModelValues as T, createSchema as U, readSchema as V, listCompleteSchemaFiles as W, getSchemaNameFromId as X, easSyncActor as Y, startEasSyncActor as Z, sendEasSyncClientRequest as _, TModelSchema as a, requestEasSyncFromEventBus as a0, requestEasSyncFromModelsInit as a1, mergeEasSyncRequestIntents as a2, createModelsFromJson as a3, getLatestSchemaVersion as a4, createModelFromJson as a5, ConflictError as a6, unloadEntity as a7, clearDestroySubscriptions as a8, setupEntityLiveQuery as a9, publishConfig as aa, generateId$1 as ab, model as ac, getPropertyData$1 as ad, Item$1 as ae, schema as af, SEEDPROTOCOL_Seed_Protocol_v1 as ag, Model$1 as ah, getContentHash as b, getItemData as c, getEasSchemaUidForModel as d, getLatestPublishedVersionRow as e, getEasSchemaForItemProperty as f, getGetAdditionalSyncAddresses as g, ItemProperty as h, eventEmitter as i, getRefValueType as j, importJsonSchema as k, loadSchemaFromFile as l, modelPropertiesToObject as m, readJsonImportFile as n, scheduleBulkFilesDownloadFromEasSync as o, parseListPropertyValueFromStorage as p, generateId as q, resolveStorageNameToSchemaName as r, syncSchemaFromSource as s, transformImportToSchemaFile as t, waitForEntityIdle as u, createReactiveProxy as v, writeProcessMachine as w, findEntity as x, forceRemoveFromCaches as y, runDestroyLifecycle as z };
-//# sourceMappingURL=index--F3Wolt5.js.map
+export { registerSeedQueryLocalSource as $, compareMetadataRowsLatestFirst as A, ADDRESSES_PERSISTED_EVENT as B, ClientManager as C, createLocalQueryDataSource as D, createNewItem as E, createSchema as F, easSyncActor as G, getClient as H, Item as I, getGetPublisherForNewSeeds as J, getMetadataLatest as K, LOCAL_COPIES_REMOVED_EVENT as L, Model as M, getPublishedSeedRecord as N, getRevokeExecutor as O, getSchemaNameFromId as P, getUploadExecutor as Q, getVersionData$1 as R, isItemOwned as S, TModelSchema as T, isSeedQueryLocalSourceRegistered as U, listCompleteSchemaFiles as V, loadAllSchemasFromDb as W, mergeEasSyncRequestIntents as X, parseAddressesPersistedPayload as Y, propertyMachine as Z, readSchema as _, TModelValues as a, requestEasSyncFromAddressChange as a0, requestEasSyncFromEventBus as a1, requestEasSyncFromModelsInit as a2, sendEasSyncClientRequest as a3, setAdditionalSyncAddresses as a4, setGetPublisherForNewSeeds as a5, setRevokeExecutor as a6, setUploadExecutor as a7, startEasSyncActor as a8, unregisterSeedQueryLocalSource as a9, createModelsFromJson as aa, getLatestSchemaVersion as ab, createModelFromJson as ac, ConflictError as ad, unloadEntity as ae, clearDestroySubscriptions as af, setupEntityLiveQuery as ag, publishConfig as ah, generateId$1 as ai, model as aj, getPropertyData$1 as ak, Item$1 as al, schema as am, SEEDPROTOCOL_Seed_Protocol_v1 as an, Model$1 as ao, getItemData as b, getEasSchemaUidForModel as c, getLatestPublishedVersionRow as d, getEasSchemaForItemProperty as e, eventEmitter as f, getContentHash as g, generateId as h, getGetAdditionalSyncAddresses as i, ItemProperty as j, getRefValueType as k, importJsonSchema as l, modelPropertiesToObject as m, loadSchemaFromFile as n, readJsonImportFile as o, parseListPropertyValueFromStorage as p, syncSchemaFromSource as q, resolveStorageNameToSchemaName as r, scheduleBulkFilesDownloadFromEasSync as s, transformImportToSchemaFile as t, waitForEntityIdle as u, createReactiveProxy as v, writeProcessMachine as w, findEntity as x, forceRemoveFromCaches as y, runDestroyLifecycle as z };
+//# sourceMappingURL=index-B4In0GEO.js.map