@seedprotocol/sdk 0.5.2 → 0.5.3

package/dist/cjs/{index-CRBI6dSD.js → index-BD1b6zAi.js}

@@ -1000,7 +1000,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-Dgd4tGrB.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-BA26rMV8.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$v('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -1184,7 +1184,7 @@ const loadOrCreateModel = xstate.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 schemaMod = await Promise.resolve().then(function () { return require('./Schema-dkd-eo3B.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-Hgwq3L34.js'); });
             const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             const schemaSnapshot = schema.getService().getSnapshot();
@@ -1428,7 +1428,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-dkd-eo3B.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-Hgwq3L34.js'); });
             const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             schema.getService().send({ type: 'markAsDraft', propertyKey: 'schema:models' });
@@ -1472,10 +1472,10 @@ const validateModel = xstate.fromCallback(({ sendBack, input: { context } }) =>
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-BMnjcVWV.js'); });
+            const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DVmOGZao.js'); });
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-dkd-eo3B.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-Hgwq3L34.js'); });
             const { Schema } = schemaMod;
             // Validate model structure
             const structureResult = validationService.validateModelStructure(context);
@@ -1585,7 +1585,7 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input }) => {
             return;
         }
         logger$t(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-Dgd4tGrB.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-BA26rMV8.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$t('ModelProperty not available from dynamic import');
@@ -1688,7 +1688,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                 const structureMsg = `[validateEntity] Validating model structure`;
                 logger$s(structureMsg);
                 // Use existing Model validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-BMnjcVWV.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DVmOGZao.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
@@ -1706,7 +1706,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                     if (entityInput.entityData.schemaName) {
                         try {
                             logger$s(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
-                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-dkd-eo3B.js'); });
+                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-Hgwq3L34.js'); });
                             const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData.schemaName, {
                                 waitForReady: false,
@@ -1742,7 +1742,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-BMnjcVWV.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DVmOGZao.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -1757,7 +1757,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                     // If schema name and model name provided, validate against schema
                     if (entityInput.entityData._schemaName && entityInput.entityData.modelName) {
                         try {
-                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-dkd-eo3B.js'); });
+                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-Hgwq3L34.js'); });
                             const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData._schemaName, {
                                 waitForReady: false,
@@ -1786,7 +1786,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-BMnjcVWV.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DVmOGZao.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -3827,7 +3827,7 @@ const writeToDatabase = xstate.fromCallback(({ sendBack, input }) => {
                 // initial write completes is not overwritten by the stale requestWrite payload.
                 let dataToWrite = input.entityData;
                 try {
-                    const mod = await Promise.resolve().then(function () { return require('./ModelProperty-Dgd4tGrB.js'); });
+                    const mod = await Promise.resolve().then(function () { return require('./ModelProperty-BA26rMV8.js'); });
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -4207,7 +4207,7 @@ const modelMachine = xstate.setup({
                                 // Create ModelProperty instances for any new property IDs
                                 if (Array.isArray(newPropertyIds) && newPropertyIds.length > 0) {
                                     // Import and create instances asynchronously (fire-and-forget)
-                                    Promise.resolve().then(function () { return require('./ModelProperty-Dgd4tGrB.js'); }).then(({ ModelProperty }) => {
+                                    Promise.resolve().then(function () { return require('./ModelProperty-BA26rMV8.js'); }).then(({ ModelProperty }) => {
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
                                                 const property = await ModelProperty.createById(propertyFileId);
@@ -5188,7 +5188,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             const schemaNameToTry = model$1?.schemaName;
             if (schemaNameToTry) {
                 try {
-                    const { Schema } = await Promise.resolve().then(function () { return require('./Schema-dkd-eo3B.js'); });
+                    const { Schema } = await Promise.resolve().then(function () { return require('./Schema-Hgwq3L34.js'); });
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false });
                     const schemaContext = schemaInstance.getService().getSnapshot().context;
                     if (schemaContext.models?.[modelName]?.properties) {
@@ -5237,7 +5237,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await Promise.resolve().then(function () { return require('./index-Dx19j60c.js'); });
+                const schemaMod = await Promise.resolve().then(function () { return require('./index-DQggpLqI.js'); });
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
@@ -5284,7 +5284,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 Promise.resolve().then(function () { return require('./index-Dx19j60c.js'); });
+                    const schemaMod = await Promise.resolve().then(function () { return require('./index-DQggpLqI.js'); });
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -5541,9 +5541,9 @@ const runPublish = xstate.fromCallback(({ sendBack, input: { context } }) => {
                 sendBack({ type: 'publishError', error: new Error(`Item not found for seedLocalId: ${seedLocalId}`) });
                 return;
             }
-            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-Dt-DS-lo.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-DMKnK2_R.js'); });
             const { getPublishUploads } = getPublishUploadsMod;
-            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-B_G_6qkE.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-DSBLjMKl.js'); });
             const { getPublishPayload } = getPublishPayloadMod;
             const uploads = await getPublishUploads(item);
             let uploadedTransactions = [];
@@ -6524,7 +6524,7 @@ const resolveRelatedValue = xstate.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 Promise.resolve().then(function () { return require('./index-Dx19j60c.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DQggpLqI.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -7527,7 +7527,7 @@ const hydrateFromDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
     // to use dynamically imported ModelPropertyDataTypes
     const _hydrateFromDb = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-Dx19j60c.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DQggpLqI.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -7890,7 +7890,7 @@ const loadOrCreateProperty = xstate.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 Promise.resolve().then(function () { return require('./property-628qAHpN.js'); });
+                            const { getPropertySchema } = await Promise.resolve().then(function () { return require('./property-D4IB0zBz.js'); });
                             let schemaFromFile = await getPropertySchema(normalizedModelName, propertyName);
                             if (!schemaFromFile?.validation) {
                                 // Fallback: get validation from schemaData in database (Schema context may not be loaded yet)
@@ -8355,9 +8355,9 @@ const analyzeInput = xstate.fromCallback(({ sendBack, input: { context, event }
     }
     const _analyzeInput = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-Dx19j60c.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DQggpLqI.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-BMnjcVWV.js'); });
+        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-DVmOGZao.js'); });
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -8555,7 +8555,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-BMnjcVWV.js'); });
+        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-DVmOGZao.js'); });
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
             ? normalizeDataType(String(propertyRecordSchema.refValueType))
@@ -9148,7 +9148,7 @@ const saveRelation = xstate.fromCallback(({ sendBack, input: { context, event }
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-Dx19j60c.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DQggpLqI.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -10192,7 +10192,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await Promise.resolve().then(function () { return require('./index-Dx19j60c.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./index-DQggpLqI.js'); });
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -11101,7 +11101,7 @@ class ItemProperty {
     }
     async save() {
         const ctx = this._getSnapshotContext();
-        const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-3Tc1-Yrc.js'); });
+        const { assertItemOwned } = await Promise.resolve().then(function () { return ownership; });
         await assertItemOwned({
             seedLocalId: ctx?.seedLocalId ?? undefined,
             seedUid: ctx?.seedUid ?? undefined,
@@ -11440,7 +11440,7 @@ class Item {
             });
         };
         this.unpublish = async () => {
-            const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-3Tc1-Yrc.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;
@@ -11464,7 +11464,7 @@ class Item {
             this._service.send({ type: 'updateContext', revokedAt });
         };
         this.publish = async () => {
-            const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-3Tc1-Yrc.js'); });
+            const { assertItemOwned } = await Promise.resolve().then(function () { return ownership; });
             await assertItemOwned(this);
             this._service.send({ type: 'startPublish' });
             return new Promise((resolve, reject) => {
@@ -11500,12 +11500,12 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-Dt-DS-lo.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-DMKnK2_R.js'); });
             const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this, [], undefined, options);
         };
         this.getPublishPayload = async (uploadedTransactions, options) => {
-            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-B_G_6qkE.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-DSBLjMKl.js'); });
             const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions, options);
         };
@@ -12158,6 +12158,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
@@ -12999,7 +13032,7 @@ class Item {
      * Destroy the item: soft delete in DB, remove from caches, clean up subscriptions, stop service.
      */
     async destroy() {
-        const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-3Tc1-Yrc.js'); });
+        const { assertItemOwned } = await Promise.resolve().then(function () { return ownership; });
         await assertItemOwned(this);
         const context = this._getSnapshotContext();
         const cacheKeys = Item.collectInstanceCacheKeysForInstance(this);
@@ -13155,7 +13188,7 @@ const runEasSync = xstate.fromPromise(async ({ input, }) => {
         requestPayload: input.requestPayload,
         persistedSnapshot: input.runningSnapshot,
     });
-    const { runSyncFromEas } = await Promise.resolve().then(function () { return require('./syncDbWithEas-DOBtMPw-.js'); });
+    const { runSyncFromEas } = await Promise.resolve().then(function () { return require('./syncDbWithEas-BYvFJc7N.js'); });
     try {
         await runSyncFromEas(toRunSyncArg(input.options));
         await finalizeEasSyncProcessRow(rowId, {
@@ -14031,6 +14064,140 @@ const saveConfig = xstate.fromCallback(({ sendBack, input: { context } }) => {
 });
 
 const logger$6 = debug('seedSdk:helpers:schema');
+/**
+ * Sanitize a schema name to be filesystem-safe
+ * Replaces all special characters (except alphanumeric, hyphens, underscores) with underscores
+ * Converts spaces to underscores
+ * Removes leading/trailing underscores
+ *
+ * @param name - Schema name to sanitize
+ * @returns Sanitized name safe for use in filenames
+ */
+const sanitizeSchemaName$1 = (name) => {
+    return name
+        .replace(/[^a-zA-Z0-9\s_-]/g, '_') // Replace special chars (except spaces, hyphens, underscores) with underscore
+        .replace(/\s+/g, '_') // Convert spaces to underscores
+        .replace(/^_+|_+$/g, '') // Remove leading/trailing underscores
+        .replace(/_+/g, '_'); // Collapse multiple underscores to single
+};
+/**
+ * Generate filename for a schema
+ * Format: {schemaFileId}_{schemaName}_v{version}.json
+ *
+ * The ID-first format ensures all files for a schema group together when sorted alphabetically.
+ *
+ * @param name - Schema name
+ * @param version - Schema version
+ * @param schemaFileId - Schema file ID (required)
+ */
+const getSchemaFilename = (name, version, schemaFileId) => {
+    const sanitizedName = sanitizeSchemaName$1(name);
+    return `${schemaFileId}_${sanitizedName}_v${version}.json`;
+};
+/**
+ * Get the full file path for a schema
+ * Format: {schemaFileId}_{schemaName}_v{version}.json
+ *
+ * The ID-first format ensures all files for a schema group together when sorted alphabetically.
+ *
+ * @param name - Schema name
+ * @param version - Schema version
+ * @param schemaFileId - Schema file ID (required)
+ */
+const getSchemaFilePath$1 = (name, version, schemaFileId) => {
+    const path = BaseFileManager.getPathModule();
+    const filename = getSchemaFilename(name, version, schemaFileId);
+    const workingDir = BaseFileManager.getWorkingDir();
+    return path.join(workingDir, filename);
+};
+/**
+ * Create a new schema file
+ * @param schema - The schema object to save
+ * @param schemaFileId - Schema file ID (required)
+ * @throws Error if schema already exists or if workingDir is invalid
+ */
+const createSchema = async (schema, schemaFileId) => {
+    if (!schema.name || !schema.version) {
+        throw new Error('Schema must have a name and version');
+    }
+    const filePath = getSchemaFilePath$1(schema.name, schema.version, schemaFileId);
+    // Check if schema already exists
+    const exists = await BaseFileManager.pathExists(filePath);
+    if (exists) {
+        throw new Error(`Schema ${schema.name} v${schema.version} already exists`);
+    }
+    // Ensure working directory exists
+    const workingDir = BaseFileManager.getWorkingDir();
+    await BaseFileManager.createDirIfNotExists(workingDir);
+    // Write schema to file
+    const content = JSON.stringify(schema, null, 2);
+    await BaseFileManager.saveFile(filePath, content);
+};
+/**
+ * Read a schema file by name and version
+ * @param name - The name of the schema
+ * @param version - The version of the schema
+ * @param schemaFileId - Schema file ID (required)
+ * @returns The schema object, or null if not found
+ */
+const readSchema = async (name, version, schemaFileId) => {
+    const filePath = getSchemaFilePath$1(name, version, schemaFileId);
+    const exists = await BaseFileManager.pathExists(filePath);
+    if (!exists) {
+        return null;
+    }
+    try {
+        const content = await BaseFileManager.readFileAsString(filePath);
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to read schema ${name} v${version}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+/**
+ * Update an existing schema file
+ * @param schema - The updated schema object (must have same name and version as existing)
+ * @param schemaFileId - Schema file ID (required)
+ * @throws Error if schema doesn't exist
+ */
+async function updateSchema(schema, schemaFileId) {
+    if (!schema.name || !schema.version) {
+        throw new Error('Schema must have a name and version');
+    }
+    const filePath = getSchemaFilePath$1(schema.name, schema.version, schemaFileId);
+    // Check if schema exists
+    const exists = await BaseFileManager.pathExists(filePath);
+    if (!exists) {
+        throw new Error(`Schema ${schema.name} v${schema.version} does not exist`);
+    }
+    // Write updated schema to file
+    const content = JSON.stringify(schema, null, 2);
+    await BaseFileManager.saveFile(filePath, content);
+}
+/**
+ * Delete a schema file
+ * @param name - The name of the schema
+ * @param version - The version of the schema
+ * @param schemaFileId - Schema file ID (required)
+ * @throws Error if schema doesn't exist
+ */
+async function deleteSchema(name, version, schemaFileId) {
+    const filePath = getSchemaFilePath$1(name, version, schemaFileId);
+    // Check if schema exists
+    const exists = await BaseFileManager.pathExists(filePath);
+    if (!exists) {
+        throw new Error(`Schema ${name} v${version} does not exist`);
+    }
+    // Delete the file
+    const fs = await BaseFileManager.getFs();
+    BaseFileManager.getPathModule();
+    try {
+        await fs.promises.unlink(filePath);
+    }
+    catch (error) {
+        throw new Error(`Failed to delete schema ${name} v${version}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
 /**
  * List all schema files in the working directory
  * Only returns files that are NOT already complete schema files (i.e., files without $schema field)
@@ -14141,6 +14308,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)
@@ -14173,6 +14358,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
@@ -14366,14 +14572,93 @@ 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$6('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$6(`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(drizzleOrm.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$6(`Migrated schema: ${schemaName} v${schemaFile.version}`);
+            }
+            else {
+                logger$6(`Schema ${schemaName} already exists in database, skipping`);
+            }
+        }
+        catch (error) {
+            logger$6(`Error migrating schema file ${schemaFileInfo.filePath}:`, error);
+        }
+    }
+    logger$6(`Migration complete: ${migratedCount} schemas migrated`);
+    return migratedCount;
+}
+/**
+ * Extract the schema name from a schemaId string
+ * @param schemaId - Schema ID in the format `${schemaName}-${schemaVersion}`
+ * @returns The schema name, or null if the format is invalid
+ */
+function getSchemaNameFromId(schemaId) {
+    if (!schemaId) {
+        return null;
+    }
+    const lastDashIndex = schemaId.lastIndexOf('-');
+    if (lastDashIndex === -1 || lastDashIndex === 0 || lastDashIndex === schemaId.length - 1) {
+        return null;
+    }
+    return schemaId.substring(0, lastDashIndex);
+}
 
 var schema = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    createSchema: createSchema,
+    deleteSchema: deleteSchema,
+    filterLatestSchemas: filterLatestSchemas,
+    findSchemaByName: findSchemaByName,
     getLatestSchemaVersion: getLatestSchemaVersion,
+    getSchemaNameFromId: getSchemaNameFromId,
     listCompleteSchemaFiles: listCompleteSchemaFiles,
     listLatestSchemaFiles: listLatestSchemaFiles,
     listSchemaFiles: listSchemaFiles,
-    loadAllSchemasFromDb: loadAllSchemasFromDb
+    loadAllSchemasFromDb: loadAllSchemasFromDb,
+    migrateFileSchemasToDb: migrateFileSchemasToDb,
+    readSchema: readSchema,
+    updateSchema: updateSchema
 });
 
 const { sha3_256 } = sha3__namespace;
@@ -16234,6 +16519,8 @@ const processSchemaFiles = xstate.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: [] };
@@ -16892,6 +17179,155 @@ function unregisterSeedQueryLocalSource() {
     registered = false;
 }
 
+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(drizzleOrm.eq(seeds.localId, item.seedLocalId));
+    if (item.seedUid)
+        conditions.push(drizzleOrm.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] : drizzleOrm.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 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(drizzleOrm.or(drizzleOrm.isNotNull(seeds.uid), drizzleOrm.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(drizzleOrm.or(drizzleOrm.inArray(htmlEmbeddedImageCoPublish.parentSeedLocalId, seedLocalIds), drizzleOrm.inArray(htmlEmbeddedImageCoPublish.htmlSeedLocalId, seedLocalIds), drizzleOrm.inArray(htmlEmbeddedImageCoPublish.imageSeedLocalId, seedLocalIds)));
+    await appDb
+        .delete(arweaveL1FinalizeJobs)
+        .where(drizzleOrm.inArray(arweaveL1FinalizeJobs.seedLocalId, seedLocalIds));
+    await appDb
+        .delete(publishProcesses)
+        .where(drizzleOrm.inArray(publishProcesses.seedLocalId, seedLocalIds));
+    await appDb.delete(metadata$1).where(drizzleOrm.inArray(metadata$1.seedLocalId, seedLocalIds));
+    await appDb.delete(versions).where(drizzleOrm.inArray(versions.seedLocalId, seedLocalIds));
+    await appDb.delete(seeds).where(drizzleOrm.inArray(seeds.localId, seedLocalIds));
+}
+
 const logger$3 = debug('seedSdk:client');
 const clientManager = xstate.createActor(clientManagerMachine, {
     input: {
@@ -17020,6 +17456,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.
@@ -17247,7 +17706,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 = Promise.resolve().then(function () { return require('./ModelProperty-Dgd4tGrB.js'); })
+const modelPropertyImportPromise = Promise.resolve().then(function () { return require('./ModelProperty-BA26rMV8.js'); })
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -17264,7 +17723,7 @@ function getModelProperty() {
 }
 // Lazy import cache for Schema to avoid circular dependency
 let SchemaClass = null;
-const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-dkd-eo3B.js'); })
+const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-Hgwq3L34.js'); })
     .then(module => {
     SchemaClass = module.Schema;
     return SchemaClass;
@@ -19169,7 +19628,7 @@ function resolveSdkDrizzleMigrationsDir(sdkRootDir) {
         })();
     // Also resolve relative to this module so temp-cwd tests / odd roots still find
     // packages/sdk/src/db/drizzle (or dist/db/drizzle after publish).
-    const moduleDir = path.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cjs/index-CRBI6dSD.js', document.baseURI).href))));
+    const moduleDir = path.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cjs/index-BD1b6zAi.js', document.baseURI).href))));
     const candidates = [
         path.join(root, 'db', 'drizzle'), // production: sdkRoot is dist/
         path.join(root, 'dist', 'db', 'drizzle'), // sdk package root with built dist
@@ -19239,7 +19698,7 @@ class NodeDb {
         logger$1('[Db.prepareDb] running migrations from %s', outDir);
         await migrator.migrate(db, { migrationsFolder: outDir });
         this.db = db;
-        const { backfillMetadataPropertyIds } = await Promise.resolve().then(function () { return require('./backfillMetadataPropertyIds-ClLuj3s6.js'); });
+        const { backfillMetadataPropertyIds } = await Promise.resolve().then(function () { return require('./backfillMetadataPropertyIds-BWJI4eCj.js'); });
         await backfillMetadataPropertyIds();
         return this.db;
     }
@@ -19788,7 +20247,6 @@ exports.getLatestPublishedVersionRow = getLatestPublishedVersionRow;
 exports.getLatestSchemaVersion = getLatestSchemaVersion;
 exports.getModelId = getModelId;
 exports.getModelIdByFileId = getModelIdByFileId;
-exports.getOwnedAddressesFromDb = getOwnedAddressesFromDb;
 exports.getPropertyData = getPropertyData$1;
 exports.getPropertyIdForModelAndName = getPropertyIdForModelAndName;
 exports.getRefValueType = getRefValueType;
@@ -19829,4 +20287,4 @@ exports.versions = versions;
 exports.waitForEntityIdle = waitForEntityIdle;
 exports.withSeed = withSeed;
 exports.writeProcessMachine = writeProcessMachine;
-//# sourceMappingURL=index-CRBI6dSD.js.map
+//# sourceMappingURL=index-BD1b6zAi.js.map