@seedprotocol/sdk 0.6.1 → 0.6.3

package/dist/cjs/{index-WOQkKWSU.js → index-C-POwaLs.js}

@@ -205,6 +205,10 @@ class BaseFileManager {
     static pathExists(filePath) {
         return BaseFileManager.requireImpl().pathExists(filePath);
     }
+    /** File size in bytes, or null if the path does not exist / cannot be stated. */
+    static getFileSize(filePath) {
+        return BaseFileManager.requireImpl().getFileSize(filePath);
+    }
     /**
      * Returns a list of filenames in the given directory (e.g. 'images', 'files').
      */
@@ -339,14 +343,9 @@ let revokeExecutor = null;
 function getRevokeExecutor() {
     return revokeExecutor;
 }
-let getAdditionalSyncAddresses = null;
-function getGetAdditionalSyncAddresses() {
-    return getAdditionalSyncAddresses;
-}
 
 var publishConfig = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getGetAdditionalSyncAddresses: getGetAdditionalSyncAddresses,
     getPublisherForNewSeedsWithTimeout: getPublisherForNewSeedsWithTimeout,
     getRevokeExecutor: getRevokeExecutor,
     getUploadExecutor: getUploadExecutor
@@ -1000,7 +999,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-BphJm1e3.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-DvIIhBnK.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$v('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -1184,7 +1183,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-z1fBr4Rv.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-FdzNqyGo.js'); });
             const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             const schemaSnapshot = schema.getService().getSnapshot();
@@ -1428,7 +1427,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-z1fBr4Rv.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-FdzNqyGo.js'); });
             const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             schema.getService().send({ type: 'markAsDraft', propertyKey: 'schema:models' });
@@ -1472,10 +1471,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-DWmIhQqz.js'); });
+            const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-pxRoOs79.js'); });
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-z1fBr4Rv.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-FdzNqyGo.js'); });
             const { Schema } = schemaMod;
             // Validate model structure
             const structureResult = validationService.validateModelStructure(context);
@@ -1585,7 +1584,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-BphJm1e3.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-DvIIhBnK.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$t('ModelProperty not available from dynamic import');
@@ -1688,7 +1687,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-DWmIhQqz.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-pxRoOs79.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
@@ -1706,7 +1705,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-z1fBr4Rv.js'); });
+                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-FdzNqyGo.js'); });
                             const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData.schemaName, {
                                 waitForReady: false,
@@ -1742,7 +1741,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-DWmIhQqz.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-pxRoOs79.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -1757,7 +1756,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-z1fBr4Rv.js'); });
+                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-FdzNqyGo.js'); });
                             const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData._schemaName, {
                                 waitForReady: false,
@@ -1786,7 +1785,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-DWmIhQqz.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-pxRoOs79.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -1865,6 +1864,60 @@ function matchesUniqueConstraintText(text) {
         (text.includes('2067') && lower.includes('constraint')));
 }
 
+/**
+ * Lowercase + trim an address for persist and compare.
+ * Does not checksum or validate — test and placeholder addresses must keep working.
+ */
+function normalizeHexAddress(addr) {
+    return addr.trim().toLowerCase();
+}
+/**
+ * Lowercase, drop empties, and dedupe (first-seen order).
+ */
+function normalizeAddressList(addrs) {
+    if (!addrs?.length)
+        return [];
+    const seen = new Set();
+    const out = [];
+    for (const addr of addrs) {
+        if (addr == null || addr === '')
+            continue;
+        const normalized = normalizeHexAddress(String(addr));
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out;
+}
+/**
+ * Lowercase a publisher stamp. Empty / null → undefined (omit on write).
+ */
+function normalizePublisher(publisher) {
+    if (publisher == null || publisher === '')
+        return undefined;
+    const normalized = normalizeHexAddress(publisher);
+    return normalized || undefined;
+}
+/**
+ * Normalizes AddressConfiguration to { owned, watched }.
+ * - string[] -> { owned: addresses, watched: [] }
+ * - { owned, watched? } -> { owned, watched: watched ?? [] }
+ * Addresses are lowercased and deduped.
+ */
+function normalizeAddressConfig(addresses) {
+    if (!addresses) {
+        return { owned: [], watched: [] };
+    }
+    if (Array.isArray(addresses)) {
+        return { owned: normalizeAddressList(addresses), watched: [] };
+    }
+    return {
+        owned: normalizeAddressList(addresses.owned),
+        watched: normalizeAddressList(addresses.watched),
+    };
+}
+
 const logger$r = debug('seedSdk:helpers:db');
 /**
  * Resolve property_id from model name/type and property name.
@@ -3207,13 +3260,13 @@ function parseAddressConfig(value) {
     try {
         const parsed = JSON.parse(value);
         if (Array.isArray(parsed)) {
-            return { owned: parsed, watched: [] };
+            return normalizeAddressConfig(parsed);
         }
         if (parsed && typeof parsed === 'object' && Array.isArray(parsed.owned)) {
-            return {
+            return normalizeAddressConfig({
                 owned: parsed.owned,
                 watched: Array.isArray(parsed.watched) ? parsed.watched : [],
-            };
+            });
         }
         return null;
     }
@@ -3230,27 +3283,12 @@ const getWatchedAddressesFromDb = async () => {
     return config?.watched ?? [];
 };
 /**
- * Returns addresses for useItems/getItemsData addressFilter.
- * Encapsulates owned (with additional sync addresses) and watched logic.
+ * Returns persisted owned or watched addresses for list filters.
+ * Does not include `getAdditionalSyncAddresses` (those are extra EAS indexers).
  */
 const getAddressesForItemsFilter = async (addressFilter) => {
     if (addressFilter === 'owned') {
-        const { getGetAdditionalSyncAddresses } = await Promise.resolve().then(function () { return publishConfig; });
-        let ownedAddresses = await getOwnedAddressesFromDb();
-        const additionalGetter = getGetAdditionalSyncAddresses();
-        if (additionalGetter) {
-            const additional = await additionalGetter();
-            if (additional?.length) {
-                const seen = new Set(ownedAddresses.map((a) => a.toLowerCase()));
-                for (const addr of additional) {
-                    if (addr && !seen.has(addr.toLowerCase())) {
-                        seen.add(addr.toLowerCase());
-                        ownedAddresses = [...ownedAddresses, addr];
-                    }
-                }
-            }
-        }
-        return ownedAddresses;
+        return getOwnedAddressesFromDb();
     }
     return getWatchedAddressesFromDb();
 };
@@ -3827,7 +3865,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-BphJm1e3.js'); });
+                    const mod = await Promise.resolve().then(function () { return require('./ModelProperty-DvIIhBnK.js'); });
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -4207,7 +4245,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-BphJm1e3.js'); }).then(({ ModelProperty }) => {
+                                    Promise.resolve().then(function () { return require('./ModelProperty-DvIIhBnK.js'); }).then(({ ModelProperty }) => {
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
                                                 const property = await ModelProperty.createById(propertyFileId);
@@ -4502,6 +4540,111 @@ const modelMachine = xstate.setup({
     },
 });
 
+/**
+ * Proxy [[GetOwnProperty]] that stays compatible with the target.
+ * Never overrides an own descriptor, never invents on a non-extensible target,
+ * and never promotes a prototype accessor to an own descriptor.
+ */
+function getInvariantSafePropertyDescriptor(target, prop, invent) {
+    const own = Reflect.getOwnPropertyDescriptor(target, prop);
+    if (own)
+        return own;
+    if (!invent)
+        return undefined;
+    if (!Object.isExtensible(target))
+        return undefined;
+    return {
+        enumerable: true,
+        configurable: true,
+        value: invent.value,
+        writable: invent.writable ?? true,
+    };
+}
+/**
+ * Creates a reactive Proxy that intercepts property access and assignment
+ * to read from and write to an actor service's context.
+ *
+ * This enables automatic React re-renders when properties change, as the
+ * React hooks subscribe to the actor service which gets updated when properties
+ * are set via the proxy.
+ *
+ * @param config Configuration object
+ * @returns A proxied instance that behaves like the original but with reactive properties
+ *
+ * @note TypeScript's Proxy type doesn't automatically preserve method signatures,
+ * so we use Proxied<T> to ensure all methods and properties are recognized.
+ * The Proxy implementation preserves all methods via Reflect.get, so this is safe.
+ */
+function createReactiveProxy(config) {
+    const { instance, trackedProperties, getContext, sendUpdate } = config;
+    // Convert readonly array to regular array for includes() checks
+    const trackedPropsSet = new Set(trackedProperties);
+    // Create the proxy - TypeScript needs explicit type assertion to preserve all methods
+    // The Proxy preserves all methods via Reflect.get, so we assert it maintains type T
+    // Using 'as unknown as T' forces TypeScript to recognize all methods and properties
+    const proxy = new Proxy(instance, {
+        get(target, prop) {
+            // Handle special properties that should not be proxied
+            // These need direct access to the underlying instance
+            if (prop === '_service') {
+                return Reflect.get(target, prop);
+            }
+            // If it's a tracked property, read from actor context
+            if (typeof prop === 'string' && trackedPropsSet.has(prop)) {
+                const context = getContext(instance);
+                return context[prop];
+            }
+            // For methods and non-tracked properties, use Reflect
+            return Reflect.get(target, prop);
+        },
+        set(target, prop, value) {
+            // Handle special properties
+            if (prop === '_service') {
+                return Reflect.set(target, prop, value);
+            }
+            // If it's a tracked property, send update to actor
+            if (typeof prop === 'string' && trackedPropsSet.has(prop)) {
+                sendUpdate(instance, prop, value);
+                return true; // Indicate success
+            }
+            // For non-tracked properties, use Reflect. Also trigger sendUpdate for virtual
+            // 'value' so the callback runs when .value is assigned (e.g. ItemProperty).
+            if (typeof prop === 'string' && prop === 'value') {
+                sendUpdate(instance, prop, value);
+            }
+            return Reflect.set(target, prop, value);
+        },
+        has(target, prop) {
+            // Check if property exists in context or on target
+            if (typeof prop === 'string' && trackedPropsSet.has(prop)) {
+                const context = getContext(instance);
+                return prop in context;
+            }
+            return Reflect.has(target, prop);
+        },
+        ownKeys(target) {
+            // Only return keys that actually exist on the target object
+            // This is required when the target is non-extensible (e.g., frozen by Immer)
+            // Tracked properties are virtual (read from context), so we don't include them here
+            // They're accessible via the get trap, but don't appear in ownKeys
+            return Reflect.ownKeys(target);
+        },
+        getOwnPropertyDescriptor(target, prop) {
+            let invent;
+            if (typeof prop === 'string' && trackedPropsSet.has(prop)) {
+                const context = getContext(instance);
+                if (prop in context) {
+                    invent = { value: context[prop] };
+                }
+            }
+            return getInvariantSafePropertyDescriptor(target, prop, invent);
+        }
+    });
+    // Force TypeScript to recognize all methods and properties are preserved
+    // The Proxy implementation preserves all methods via Reflect.get, so this is safe
+    return proxy;
+}
+
 const ENV = (typeof process !== 'undefined' && process.env)
     ? process.env
     : (typeof window !== 'undefined' && window.env)
@@ -4822,14 +4965,14 @@ const createSeed = async ({ type, seedUid }) => {
     // if the EAS schema hasn't been published yet
     const appDb = BaseDb.getAppDb();
     const newSeedLocalId = generateId();
-    const publisher = await getPublisherForNewSeedsWithTimeout();
+    const publisher = normalizePublisher(await getPublisherForNewSeedsWithTimeout());
     await appDb.insert(seeds).values({
         localId: newSeedLocalId,
         type,
         uid: seedUid,
         createdAt: Date.now(),
         schemaUid: schemaUid || null,
-        ...(publisher != null && publisher !== '' && { publisher }),
+        ...(publisher && { publisher }),
     });
     return newSeedLocalId;
 };
@@ -4837,7 +4980,7 @@ const createSeed = async ({ type, seedUid }) => {
 const createVersion = async ({ seedLocalId, seedUid, seedType, uid, }) => {
     const appDb = BaseDb.getAppDb();
     const newVersionLocalId = generateId();
-    const publisher = await getPublisherForNewSeedsWithTimeout();
+    const publisher = normalizePublisher(await getPublisherForNewSeedsWithTimeout());
     await appDb.insert(versions).values({
         localId: newVersionLocalId,
         createdAt: Date.now(),
@@ -4845,7 +4988,7 @@ const createVersion = async ({ seedLocalId, seedUid, seedType, uid, }) => {
         seedUid: seedUid ?? null,
         seedType,
         uid: uid ?? null,
-        ...(publisher != null && publisher !== '' && { publisher }),
+        ...(publisher && { publisher }),
     });
     return newVersionLocalId;
 };
@@ -5188,7 +5331,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-z1fBr4Rv.js'); });
+                    const { Schema } = await Promise.resolve().then(function () { return require('./Schema-FdzNqyGo.js'); });
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false });
                     const schemaContext = schemaInstance.getService().getSnapshot().context;
                     if (schemaContext.models?.[modelName]?.properties) {
@@ -5237,7 +5380,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await Promise.resolve().then(function () { return require('./index-Bp16LrkZ.js'); });
+                const schemaMod = await Promise.resolve().then(function () { return require('./index-D_ph4zut.js'); });
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
@@ -5284,7 +5427,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-Bp16LrkZ.js'); });
+                    const schemaMod = await Promise.resolve().then(function () { return require('./index-D_ph4zut.js'); });
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -5541,9 +5684,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-yFW9CKSW.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-D2VZHZnu.js'); });
             const { getPublishUploads } = getPublishUploadsMod;
-            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-DXHDgXU3.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-BvmVTKoc.js'); });
             const { getPublishPayload } = getPublishPayloadMod;
             const uploads = await getPublishUploads(item);
             let uploadedTransactions = [];
@@ -5903,6 +6046,8 @@ const INTERNAL_PROPERTY_NAMES = [
     '_markedForDeletion',
     // SDK-internal: wallet address of attester; never publish as property attestation
     'publisher',
+    // SDK-internal: Unix timestamp when attestations were revoked; never a schema field
+    'revokedAt',
 ];
 const VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA = '0x13c0fd59d69dbce40501a41f8b37768d26dd2e2bb0cad64615334d84f7b9bdf6';
 const defaultAttestationData = {
@@ -6253,6 +6398,130 @@ async function batchLatestPublishedVersionBySeedLocalIds(seedLocalIds) {
     return out;
 }
 
+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;
+}
+/**
+ * Local draft that has never been attested: no publisher, no real uid, no attestationRaw.
+ */
+function isLocalUnsealedDraft(row) {
+    const publisher = row.publisher;
+    if (publisher != null && publisher !== '')
+        return false;
+    if (!eas.isPlaceholderUid(row.uid))
+        return false;
+    if (row.attestationRaw != null && row.attestationRaw !== '')
+        return false;
+    return true;
+}
+/** Case-insensitive membership in the persisted owned set. */
+function publisherIsInOwnedSet(publisher, ownedAddresses) {
+    if (publisher == null || publisher === '')
+        return false;
+    const ownedSet = new Set(normalizeAddressList(ownedAddresses));
+    return ownedSet.has(normalizeHexAddress(publisher));
+}
+/**
+ * Shared ownership predicate.
+ * - Session has owned addresses: only a publisher in that set is owned (null is never owned).
+ * - Session has no owned addresses: local unsealed drafts are owned so pre-connect authoring works.
+ */
+function isSeedRowOwned(row, ownedAddresses) {
+    const publisher = resolvePublisherFromSeedRow(row);
+    if (ownedAddresses.length === 0) {
+        return isLocalUnsealedDraft({ ...row, publisher: publisher ?? row.publisher });
+    }
+    return publisherIsInOwnedSet(publisher, ownedAddresses);
+}
+/**
+ * SQL for `addressFilter: 'owned' | 'watched'`. Empty list → no rows (`1=0`).
+ * Compares `lower(publisher)` so checksummed rows match persisted lowercase owned.
+ */
+function publisherInAddressListSql(column, addresses) {
+    const normalized = normalizeAddressList(addresses);
+    if (normalized.length === 0) {
+        return drizzleOrm.sql `1=0`;
+    }
+    return drizzleOrm.inArray(drizzleOrm.sql `lower(${column})`, normalized);
+}
+/**
+ * Checks if the current user owns the item (publisher is in persisted owned addresses).
+ *
+ * When the session has owned addresses, only a matching publisher is owned —
+ * `publisher IS NULL` is not treated as owned. Call `claimUnpublishedDrafts`
+ * after connect to stamp local drafts.
+ *
+ * When owned is empty, local unsealed drafts (no publisher, no real uid, no
+ * attestationRaw) are still owned so create/edit works before a wallet is connected.
+ *
+ * Does not include `getAdditionalSyncAddresses` (those are extra EAS indexers,
+ * not wallets the user controls).
+ */
+async function isItemOwned(item) {
+    const row = await getSeedRowForItem(item);
+    if (!row)
+        return false;
+    const ownedAddresses = await getOwnedAddressesFromDb();
+    return isSeedRowOwned(row, ownedAddresses);
+}
+/**
+ * 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,
+    isLocalUnsealedDraft: isLocalUnsealedDraft,
+    isSeedRowOwned: isSeedRowOwned,
+    publisherInAddressListSql: publisherInAddressListSql,
+    publisherIsInOwnedSet: publisherIsInOwnedSet,
+    resolvePublisherFromSeedRow: resolvePublisherFromSeedRow
+});
+
 /**
  * List item rows for list UIs. Only includes seeds that have at least one version.
  *
@@ -6273,16 +6542,11 @@ const getItemsData = async ({ modelName, deleted, includeEas = false, addressFil
     }
     if (addressFilter === 'owned') {
         const ownedAddresses = await getAddressesForItemsFilter('owned');
-        if (ownedAddresses.length > 0) {
-            conditions.push(drizzleOrm.or(drizzleOrm.inArray(seeds.publisher, ownedAddresses), drizzleOrm.isNull(seeds.publisher)));
-        }
+        conditions.push(publisherInAddressListSql(seeds.publisher, ownedAddresses));
     }
     else if (addressFilter === 'watched') {
         const watchedAddresses = await getAddressesForItemsFilter('watched');
-        if (watchedAddresses.length === 0) {
-            return [];
-        }
-        conditions.push(drizzleOrm.inArray(seeds.publisher, watchedAddresses));
+        conditions.push(publisherInAddressListSql(seeds.publisher, watchedAddresses));
     }
     if (deleted) {
         conditions.push(drizzleOrm.or(drizzleOrm.isNotNull(seeds._markedForDeletion), drizzleOrm.eq(seeds._markedForDeletion, 1)));
@@ -6524,7 +6788,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-Bp16LrkZ.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-D_ph4zut.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -6843,6 +7107,7 @@ const updateMetadata = async (metadataValues, propertyRecordSchema) => {
     }
     // Publisher is immutable once set: do not overwrite existing publisher
     if (rest.publisher != null && rest.publisher !== '') {
+        rest.publisher = normalizePublisher(rest.publisher) ?? rest.publisher;
         const [row] = await appDb
             .select({ publisher: metadata$1.publisher })
             .from(metadata$1)
@@ -7527,7 +7792,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-Bp16LrkZ.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-D_ph4zut.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -7890,7 +8155,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-DSh60oEw.js'); });
+                            const { getPropertySchema } = await Promise.resolve().then(function () { return require('./property-DkUtJxV2.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 +8620,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-Bp16LrkZ.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-D_ph4zut.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-DWmIhQqz.js'); });
+        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-pxRoOs79.js'); });
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -8525,8 +8790,8 @@ class MetadataValidationError extends Error {
 const createMetadata = async (metadataValues, propertyRecordSchema, options) => {
     const appDb = BaseDb.getAppDb();
     metadataValues.localId = generateId();
-    const publisher = await getPublisherForNewSeedsWithTimeout();
-    if (publisher != null && publisher !== '') {
+    const publisher = normalizePublisher(await getPublisherForNewSeedsWithTimeout());
+    if (publisher) {
         metadataValues.publisher = publisher;
     }
     if (!metadataValues.modelType && metadataValues.modelName) {
@@ -8555,7 +8820,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-DWmIhQqz.js'); });
+        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-pxRoOs79.js'); });
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
             ? normalizeDataType(String(propertyRecordSchema.refValueType))
@@ -9148,7 +9413,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-Bp16LrkZ.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-D_ph4zut.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -9897,95 +10162,6 @@ async function runDestroyLifecycle(instance, config) {
     }
 }
 
-/**
- * Creates a reactive Proxy that intercepts property access and assignment
- * to read from and write to an actor service's context.
- *
- * This enables automatic React re-renders when properties change, as the
- * React hooks subscribe to the actor service which gets updated when properties
- * are set via the proxy.
- *
- * @param config Configuration object
- * @returns A proxied instance that behaves like the original but with reactive properties
- *
- * @note TypeScript's Proxy type doesn't automatically preserve method signatures,
- * so we use Proxied<T> to ensure all methods and properties are recognized.
- * The Proxy implementation preserves all methods via Reflect.get, so this is safe.
- */
-function createReactiveProxy(config) {
-    const { instance, trackedProperties, getContext, sendUpdate } = config;
-    // Convert readonly array to regular array for includes() checks
-    const trackedPropsSet = new Set(trackedProperties);
-    // Create the proxy - TypeScript needs explicit type assertion to preserve all methods
-    // The Proxy preserves all methods via Reflect.get, so we assert it maintains type T
-    // Using 'as unknown as T' forces TypeScript to recognize all methods and properties
-    const proxy = new Proxy(instance, {
-        get(target, prop) {
-            // Handle special properties that should not be proxied
-            // These need direct access to the underlying instance
-            if (prop === '_service') {
-                return Reflect.get(target, prop);
-            }
-            // If it's a tracked property, read from actor context
-            if (typeof prop === 'string' && trackedPropsSet.has(prop)) {
-                const context = getContext(instance);
-                return context[prop];
-            }
-            // For methods and non-tracked properties, use Reflect
-            return Reflect.get(target, prop);
-        },
-        set(target, prop, value) {
-            // Handle special properties
-            if (prop === '_service') {
-                return Reflect.set(target, prop, value);
-            }
-            // If it's a tracked property, send update to actor
-            if (typeof prop === 'string' && trackedPropsSet.has(prop)) {
-                sendUpdate(instance, prop, value);
-                return true; // Indicate success
-            }
-            // For non-tracked properties, use Reflect. Also trigger sendUpdate for virtual
-            // 'value' so the callback runs when .value is assigned (e.g. ItemProperty).
-            if (typeof prop === 'string' && prop === 'value') {
-                sendUpdate(instance, prop, value);
-            }
-            return Reflect.set(target, prop, value);
-        },
-        has(target, prop) {
-            // Check if property exists in context or on target
-            if (typeof prop === 'string' && trackedPropsSet.has(prop)) {
-                const context = getContext(instance);
-                return prop in context;
-            }
-            return Reflect.has(target, prop);
-        },
-        ownKeys(target) {
-            // Only return keys that actually exist on the target object
-            // This is required when the target is non-extensible (e.g., frozen by Immer)
-            // Tracked properties are virtual (read from context), so we don't include them here
-            // They're accessible via the get trap, but don't appear in ownKeys
-            return Reflect.ownKeys(target);
-        },
-        getOwnPropertyDescriptor(target, prop) {
-            if (typeof prop === 'string' && trackedPropsSet.has(prop)) {
-                const context = getContext(instance);
-                if (prop in context) {
-                    return {
-                        enumerable: true,
-                        configurable: true,
-                        value: context[prop],
-                        writable: true,
-                    };
-                }
-            }
-            return Reflect.getOwnPropertyDescriptor(target, prop);
-        }
-    });
-    // Force TypeScript to recognize all methods and properties are preserved
-    // The Proxy implementation preserves all methods via Reflect.get, so this is safe
-    return proxy;
-}
-
 /** Parent Html property `propertyValue` after publish (66-char seed uid). */
 const HTML_PROP_SEED_UID_RE = /^0x[a-fA-F0-9]{64}$/;
 // Start loading Model at module load time (non-blocking)
@@ -10192,7 +10368,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await Promise.resolve().then(function () { return require('./index-Bp16LrkZ.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./index-D_ph4zut.js'); });
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -11343,7 +11519,8 @@ const updateSeedUid = async ({ seedLocalId, seedUid, publisher, attestationCreat
         return;
     }
     const appDb = BaseDb.getAppDb();
-    let shouldSetPublisher = publisher != null && publisher !== '';
+    const normalizedPublisher = normalizePublisher(publisher);
+    let shouldSetPublisher = normalizedPublisher != null;
     if (shouldSetPublisher) {
         const [row] = await appDb
             .select({ publisher: seeds.publisher })
@@ -11358,7 +11535,7 @@ const updateSeedUid = async ({ seedLocalId, seedUid, publisher, attestationCreat
         .update(seeds)
         .set({
         uid: seedUid,
-        ...(shouldSetPublisher && { publisher }),
+        ...(shouldSetPublisher && { publisher: normalizedPublisher }),
         ...(attestationCreatedAt != null && { attestationCreatedAt }),
         updatedAt: Date.now(),
     })
@@ -11500,12 +11677,12 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-yFW9CKSW.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-D2VZHZnu.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-DXHDgXU3.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-BvmVTKoc.js'); });
             const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions, options);
         };
@@ -11624,6 +11801,7 @@ class Item {
             'latestVersionUid',
             'publishedVersionUid',
             'publishedVersionLocalId',
+            'revokedAt',
         ];
         const keysFromInitial = Object.keys(initialValues).filter((key) => !metadataKeys.includes(key));
         const schemaNameForModel = initialValues.schemaName;
@@ -11929,19 +12107,14 @@ class Item {
                         return Reflect.ownKeys(target);
                     },
                     getOwnPropertyDescriptor(target, prop) {
-                        // Handle tracked properties
+                        let invent;
                         if (typeof prop === 'string' && TRACKED_PROPERTIES$1.includes(prop)) {
                             const context = target._getSnapshotContext();
                             if (prop in context) {
-                                return {
-                                    enumerable: true,
-                                    configurable: true,
-                                    value: context[prop],
-                                    writable: true,
-                                };
+                                invent = { value: context[prop] };
                             }
                         }
-                        return Reflect.getOwnPropertyDescriptor(target, prop);
+                        return getInvariantSafePropertyDescriptor(target, prop, invent);
                     },
                 });
                 this.registerItemInInstanceCache(proxiedInstance);
@@ -12109,19 +12282,14 @@ class Item {
                 return Reflect.ownKeys(target);
             },
             getOwnPropertyDescriptor(target, prop) {
-                // Handle tracked properties
+                let invent;
                 if (typeof prop === 'string' && TRACKED_PROPERTIES$1.includes(prop)) {
                     const context = target._getSnapshotContext();
                     if (prop in context) {
-                        return {
-                            enumerable: true,
-                            configurable: true,
-                            value: context[prop],
-                            writable: true,
-                        };
+                        invent = { value: context[prop] };
                     }
                 }
-                return Reflect.getOwnPropertyDescriptor(target, prop);
+                return getInvariantSafePropertyDescriptor(target, prop, invent);
             },
         });
         this.registerItemInInstanceCache(proxiedInstance);
@@ -12433,6 +12601,7 @@ class Item {
                 }
             },
             enumerable: true,
+            configurable: true,
         });
         state.definedPropertyNames.add(propertyName);
     }
@@ -13074,24 +13243,6 @@ class ConflictError extends Error {
     }
 }
 
-/**
- * Normalizes AddressConfiguration to { owned, watched }.
- * - string[] -> { owned: addresses, watched: [] }
- * - { owned, watched? } -> { owned, watched: watched ?? [] }
- */
-function normalizeAddressConfig(addresses) {
-    if (!addresses) {
-        return { owned: [], watched: [] };
-    }
-    if (Array.isArray(addresses)) {
-        return { owned: addresses, watched: [] };
-    }
-    return {
-        owned: addresses.owned ?? [],
-        watched: addresses.watched ?? [],
-    };
-}
-
 let writeTail = Promise.resolve();
 function enqueueEasSyncDbWrite(fn) {
     const next = writeTail.then(fn);
@@ -13188,7 +13339,7 @@ const runEasSync = xstate.fromPromise(async ({ input, }) => {
         requestPayload: input.requestPayload,
         persistedSnapshot: input.runningSnapshot,
     });
-    const { runSyncFromEas } = await Promise.resolve().then(function () { return require('./syncDbWithEas-pVjTHk3y.js'); });
+    const { runSyncFromEas } = await Promise.resolve().then(function () { return require('./syncDbWithEas-DRoys7eo.js'); });
     try {
         await runSyncFromEas(toRunSyncArg(input.options));
         await finalizeEasSyncProcessRow(rowId, {
@@ -13972,8 +14123,8 @@ const saveConfig = xstate.fromCallback(({ sendBack, input: { context } }) => {
                 throw new Error('App DB not found');
             }
             const endpointsValueString = JSON.stringify(endpoints);
-            const owned = ownedAddresses ?? addresses ?? [];
-            const watched = watchedAddresses ?? [];
+            const owned = normalizeAddressList(ownedAddresses ?? addresses ?? []);
+            const watched = normalizeAddressList(watchedAddresses ?? []);
             const addressesValueString = JSON.stringify({ owned, watched });
             // TODO: Figure out how to define on conflict with multiple rows added
             await appDb
@@ -13988,20 +14139,18 @@ const saveConfig = xstate.fromCallback(({ sendBack, input: { context } }) => {
                     value: endpointsValueString,
                 },
             });
-            if (owned.length > 0 || watched.length > 0) {
-                await appDb
-                    .insert(appState)
-                    .values({
-                    key: 'addresses',
+            await appDb
+                .insert(appState)
+                .values({
+                key: 'addresses',
+                value: addressesValueString,
+            })
+                .onConflictDoUpdate({
+                target: appState.key,
+                set: {
                     value: addressesValueString,
-                })
-                    .onConflictDoUpdate({
-                    target: appState.key,
-                    set: {
-                        value: addressesValueString,
-                    },
-                });
-            }
+                },
+            });
             await appDb
                 .insert(appState)
                 .values({
@@ -17179,85 +17328,7 @@ 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 = () => ({
+const emptyResult$1 = () => ({
     removedSeedLocalIds: [],
     removedSeedUids: [],
 });
@@ -17275,11 +17346,11 @@ function normalizeAddresses(addresses) {
 async function findLocalOnchainCopiesForAddresses(addresses) {
     const normalized = normalizeAddresses(addresses);
     if (normalized.length === 0) {
-        return emptyResult();
+        return emptyResult$1();
     }
     const appDb = BaseDb.getAppDb();
     if (!appDb) {
-        return emptyResult();
+        return emptyResult$1();
     }
     const addressSet = new Set(normalized);
     const candidateRows = (await appDb
@@ -17328,6 +17399,57 @@ async function hardDeleteLocalSeedsByLocalIds(seedLocalIds) {
     await appDb.delete(seeds).where(drizzleOrm.inArray(seeds.localId, seedLocalIds));
 }
 
+const emptyResult = () => ({
+    seeds: 0,
+    versions: 0,
+    metadata: 0,
+});
+/**
+ * Stamp local seeds/versions/metadata that have no publisher and no real uid.
+ * Does not touch sealed rows (real EAS uid or attestationRaw).
+ */
+async function claimUnpublishedDrafts(publisher) {
+    const normalized = normalizePublisher(publisher);
+    if (!normalized)
+        return emptyResult();
+    const appDb = BaseDb.getAppDb();
+    if (!appDb)
+        return emptyResult();
+    const now = Date.now();
+    const claimTable = async (table) => {
+        const rows = (await appDb
+            .select({
+            localId: table.localId,
+            uid: table.uid,
+            publisher: table.publisher,
+            attestationRaw: table.attestationRaw,
+        })
+            .from(table));
+        const ids = rows
+            .filter((row) => typeof row.localId === 'string' &&
+            row.localId !== '' &&
+            isLocalUnsealedDraft(row))
+            .map((row) => row.localId);
+        if (ids.length === 0)
+            return 0;
+        await appDb
+            .update(table)
+            .set({ publisher: normalized, updatedAt: now })
+            .where(drizzleOrm.inArray(table.localId, ids));
+        return ids.length;
+    };
+    const [seedCount, versionCount, metadataCount] = await Promise.all([
+        claimTable(seeds),
+        claimTable(versions),
+        claimTable(metadata$1),
+    ]);
+    return {
+        seeds: seedCount,
+        versions: versionCount,
+        metadata: metadataCount,
+    };
+}
+
 const logger$3 = debug('seedSdk:client');
 const clientManager = xstate.createActor(clientManagerMachine, {
     input: {
@@ -17456,6 +17578,15 @@ const clientInstance = {
         ensureInitialized();
         return getWatchedAddressesFromDb();
     },
+    /**
+     * Stamp local seeds/versions/metadata that have no publisher and no real uid.
+     * Sealed rows (real EAS uid or attestationRaw) are left unchanged.
+     * Use after `setAddresses` on connect; `setPublishWallet` does this automatically.
+     */
+    claimUnpublishedDrafts: async (publisher) => {
+        ensureInitialized();
+        return claimUnpublishedDrafts(publisher);
+    },
     /**
      * Hard-delete local on-chain seed copies for the given publisher addresses.
      * Drafts (no uid / attestationRaw) are kept. Chain is untouched; reconnect can rehydrate via syncFromEas.
@@ -17706,7 +17837,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-BphJm1e3.js'); })
+const modelPropertyImportPromise = Promise.resolve().then(function () { return require('./ModelProperty-DvIIhBnK.js'); })
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -17723,7 +17854,7 @@ function getModelProperty() {
 }
 // Lazy import cache for Schema to avoid circular dependency
 let SchemaClass = null;
-const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-z1fBr4Rv.js'); })
+const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-FdzNqyGo.js'); })
     .then(module => {
     SchemaClass = module.Schema;
     return SchemaClass;
@@ -18181,37 +18312,25 @@ class Model {
             getOwnPropertyDescriptor(target, prop) {
                 // Handle 'name' as an alias for 'modelName'
                 if (prop === 'name') {
-                    const context = target._getSnapshotContext();
-                    return {
-                        enumerable: true,
-                        configurable: true,
-                        value: context.modelName,
-                        writable: true,
-                    };
+                    return getInvariantSafePropertyDescriptor(target, prop, {
+                        value: target._getSnapshotContext().modelName,
+                    });
                 }
                 // Handle 'id' property - returns the modelFileId
                 if (prop === 'id') {
-                    const context = target._getSnapshotContext();
-                    return {
-                        enumerable: true,
-                        configurable: true,
-                        value: context.id, // id is now the schemaFileId (string)
+                    return getInvariantSafePropertyDescriptor(target, prop, {
+                        value: target._getSnapshotContext().id, // id is now the schemaFileId (string)
                         writable: false, // id is read-only
-                    };
+                    });
                 }
-                // Handle tracked properties
+                let invent;
                 if (typeof prop === 'string' && TRACKED_PROPERTIES.includes(prop)) {
                     const context = target._getSnapshotContext();
                     if (prop in context) {
-                        return {
-                            enumerable: true,
-                            configurable: true,
-                            value: context[prop],
-                            writable: true,
-                        };
+                        invent = { value: context[prop] };
                     }
                 }
-                return Reflect.getOwnPropertyDescriptor(target, prop);
+                return getInvariantSafePropertyDescriptor(target, prop, invent);
             },
         });
         // Step 8: Store in new ID-based cache
@@ -19488,6 +19607,15 @@ class NodeFileManager {
     async pathExists(filePath) {
         return await fsAsync__namespace.access(filePath).then(() => true).catch(() => false);
     }
+    async getFileSize(filePath) {
+        try {
+            const stat = await fsAsync__namespace.stat(filePath);
+            return stat.size;
+        }
+        catch {
+            return null;
+        }
+    }
     async listImageFiles() {
         return this.listFiles('images');
     }
@@ -19628,7 +19756,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-WOQkKWSU.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-C-POwaLs.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
@@ -19698,7 +19826,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--9WN2zaG.js'); });
+        const { backfillMetadataPropertyIds } = await Promise.resolve().then(function () { return require('./backfillMetadataPropertyIds-D0o5VwBh.js'); });
         await backfillMetadataPropertyIds();
         return this.db;
     }
@@ -20263,6 +20391,8 @@ exports.modelSchemas = modelSchemas;
 exports.modelUids = modelUids;
 exports.models = models$1;
 exports.normalizeDataType = normalizeDataType;
+exports.normalizeHexAddress = normalizeHexAddress;
+exports.normalizePublisher = normalizePublisher;
 exports.parseListPropertyValueFromStorage = parseListPropertyValueFromStorage;
 exports.parseMarkdownFrontmatter = parseMarkdownFrontmatter;
 exports.processSeedConfig = processSeedConfig;
@@ -20287,4 +20417,4 @@ exports.versions = versions;
 exports.waitForEntityIdle = waitForEntityIdle;
 exports.withSeed = withSeed;
 exports.writeProcessMachine = writeProcessMachine;
-//# sourceMappingURL=index-WOQkKWSU.js.map
+//# sourceMappingURL=index-C-POwaLs.js.map