@seedprotocol/sdk 0.5.1 → 0.5.2

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

@@ -12,6 +12,7 @@ var pluralize = require('pluralize');
 var typebox = require('@sinclair/typebox');
 var nanoid = require('nanoid');
 var nanoidDictionary = require('nanoid-dictionary');
+var query = require('@seedprotocol/query');
 var casing = require('drizzle-orm/casing');
 var lodashEs = require('lodash-es');
 var rxjs = require('rxjs');
@@ -24,7 +25,6 @@ var client = require('@libsql/client');
 var libsql = require('drizzle-orm/libsql');
 var migrator = require('drizzle-orm/libsql/migrator');
 var yaml = require('js-yaml');
-require('@seedprotocol/webpack');
 var child_process = require('child_process');
 var node$1 = require('@seedprotocol/arweave/node');
 var node = require('@seedprotocol/eas/node');
@@ -988,21 +988,6 @@ const convertTxIdToImage = async (txId) => {
     const imageBlob = new Blob([uint]);
     return URL.createObjectURL(imageBlob);
 };
-const parseEasRelationPropertyName = (easPropertyName) => {
-    // Split the input string on the first underscore
-    const [singularProperty, modelName, idSegment] = easPropertyName.split('_');
-    // If there are any other parts, assume it is a list (e.g., has 'ids' or other suffix)
-    const isList = idSegment === 'ids';
-    // Create the final property name by pluralizing the singular part
-    const propertyName = singularProperty.endsWith('s')
-        ? singularProperty
-        : singularProperty + 's';
-    return {
-        propertyName, // Plural form of the property name
-        modelName, // Model name extracted from the second part
-        isList, // True if the property is a list (e.g., 'ids' is present)
-    };
-};
 
 const logger$v = debug('seedSdk:model:actors:loadOrCreateModel');
 /**
@@ -1015,7 +1000,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-CmuGJvyi.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-Dgd4tGrB.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$v('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -1199,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-gpFnZMhB.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-dkd-eo3B.js'); });
             const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             const schemaSnapshot = schema.getService().getSnapshot();
@@ -1443,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-gpFnZMhB.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-dkd-eo3B.js'); });
             const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             schema.getService().send({ type: 'markAsDraft', propertyKey: 'schema:models' });
@@ -1487,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-E3xTSRai.js'); });
+            const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-BMnjcVWV.js'); });
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-gpFnZMhB.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-dkd-eo3B.js'); });
             const { Schema } = schemaMod;
             // Validate model structure
             const structureResult = validationService.validateModelStructure(context);
@@ -1600,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-CmuGJvyi.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-Dgd4tGrB.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$t('ModelProperty not available from dynamic import');
@@ -1703,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-E3xTSRai.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-BMnjcVWV.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
@@ -1721,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-gpFnZMhB.js'); });
+                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-dkd-eo3B.js'); });
                             const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData.schemaName, {
                                 waitForReady: false,
@@ -1757,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-E3xTSRai.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-BMnjcVWV.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -1772,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-gpFnZMhB.js'); });
+                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-dkd-eo3B.js'); });
                             const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData._schemaName, {
                                 waitForReady: false,
@@ -1801,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-E3xTSRai.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-BMnjcVWV.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -3842,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-CmuGJvyi.js'); });
+                    const mod = await Promise.resolve().then(function () { return require('./ModelProperty-Dgd4tGrB.js'); });
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -4222,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-CmuGJvyi.js'); }).then(({ ModelProperty }) => {
+                                    Promise.resolve().then(function () { return require('./ModelProperty-Dgd4tGrB.js'); }).then(({ ModelProperty }) => {
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
                                                 const property = await ModelProperty.createById(propertyFileId);
@@ -5203,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-gpFnZMhB.js'); });
+                    const { Schema } = await Promise.resolve().then(function () { return require('./Schema-dkd-eo3B.js'); });
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false });
                     const schemaContext = schemaInstance.getService().getSnapshot().context;
                     if (schemaContext.models?.[modelName]?.properties) {
@@ -5252,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-9Z2FOvLD.js'); });
+                const schemaMod = await Promise.resolve().then(function () { return require('./index-Dx19j60c.js'); });
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
@@ -5299,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-9Z2FOvLD.js'); });
+                    const schemaMod = await Promise.resolve().then(function () { return require('./index-Dx19j60c.js'); });
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -5556,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-BjgxgrKD.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-Dt-DS-lo.js'); });
             const { getPublishUploads } = getPublishUploadsMod;
-            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-C1nOOXp_.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-B_G_6qkE.js'); });
             const { getPublishPayload } = getPublishPayloadMod;
             const uploads = await getPublishUploads(item);
             let uploadedTransactions = [];
@@ -6072,6 +6057,14 @@ async function getLatestPublishedVersionRow(seedLocalId) {
 }
 
 const logger$l = debug('seedSdk:db:read:getItemData');
+/**
+ * Assemble flat ItemData for Item / liveQuery / draft-head authoring.
+ *
+ * For **published chain JSON** (Seed → latest attested Version → properties),
+ * prefer `getPublishedSeedRecord` from `@seedprotocol/sdk` or
+ * `getSeed` / `queryBySchema` from `@seedprotocol/query`. This function remains
+ * the correct path for local-head / draft-wins property selection used by Item.
+ */
 const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     if (!seedLocalId && !seedUid) {
         throw new Error('[db/queries] [getItem] no seedLocalId or seedUid');
@@ -6531,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-9Z2FOvLD.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-Dx19j60c.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -7393,7 +7386,7 @@ async function fetchHtmlViaRawAcrossGateways(txId) {
         return undefined;
     try {
         const resolved = arweave.getResolvedSeedGatewayEndpoints();
-        if (!resolved || resolved.activePath !== 'hyper-sidecar') {
+        if (!resolved || (resolved.activePath !== 'hyper-sidecar' && resolved.activePath !== 'http-proxy')) {
             const { ensureReadGatewaySelected } = await import('@seedprotocol/arweave');
             await ensureReadGatewaySelected().catch(() => { });
         }
@@ -7534,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-9Z2FOvLD.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-Dx19j60c.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -7897,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-D3Ww2_Qh.js'); });
+                            const { getPropertySchema } = await Promise.resolve().then(function () { return require('./property-628qAHpN.js'); });
                             let schemaFromFile = await getPropertySchema(normalizedModelName, propertyName);
                             if (!schemaFromFile?.validation) {
                                 // Fallback: get validation from schemaData in database (Schema context may not be loaded yet)
@@ -8362,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-9Z2FOvLD.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-Dx19j60c.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-E3xTSRai.js'); });
+        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-BMnjcVWV.js'); });
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -8562,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-E3xTSRai.js'); });
+        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-BMnjcVWV.js'); });
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
             ? normalizeDataType(String(propertyRecordSchema.refValueType))
@@ -9155,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-9Z2FOvLD.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-Dx19j60c.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -10199,7 +10192,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await Promise.resolve().then(function () { return require('./index-9Z2FOvLD.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./index-Dx19j60c.js'); });
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -11108,7 +11101,7 @@ class ItemProperty {
     }
     async save() {
         const ctx = this._getSnapshotContext();
-        const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-DhWda0J9.js'); });
+        const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-3Tc1-Yrc.js'); });
         await assertItemOwned({
             seedLocalId: ctx?.seedLocalId ?? undefined,
             seedUid: ctx?.seedUid ?? undefined,
@@ -11447,7 +11440,7 @@ class Item {
             });
         };
         this.unpublish = async () => {
-            const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-DhWda0J9.js'); });
+            const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-3Tc1-Yrc.js'); });
             const { getRevokeExecutor } = await Promise.resolve().then(function () { return publishConfig; });
             await assertItemOwned(this);
             const seedUid = this.seedUid;
@@ -11471,7 +11464,7 @@ class Item {
             this._service.send({ type: 'updateContext', revokedAt });
         };
         this.publish = async () => {
-            const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-DhWda0J9.js'); });
+            const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-3Tc1-Yrc.js'); });
             await assertItemOwned(this);
             this._service.send({ type: 'startPublish' });
             return new Promise((resolve, reject) => {
@@ -11507,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-BjgxgrKD.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-Dt-DS-lo.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-C1nOOXp_.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-B_G_6qkE.js'); });
             const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions, options);
         };
@@ -13006,7 +12999,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-DhWda0J9.js'); });
+        const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-3Tc1-Yrc.js'); });
         await assertItemOwned(this);
         const context = this._getSnapshotContext();
         const cacheKeys = Item.collectInstanceCacheKeysForInstance(this);
@@ -13162,7 +13155,7 @@ const runEasSync = xstate.fromPromise(async ({ input, }) => {
         requestPayload: input.requestPayload,
         persistedSnapshot: input.runningSnapshot,
     });
-    const { runSyncFromEas } = await Promise.resolve().then(function () { return require('./syncDbWithEas-Dht3_7UD.js'); });
+    const { runSyncFromEas } = await Promise.resolve().then(function () { return require('./syncDbWithEas-DOBtMPw-.js'); });
     try {
         await runSyncFromEas(toRunSyncArg(input.options));
         await finalizeEasSyncProcessRow(rowId, {
@@ -13577,6 +13570,7 @@ const platformClassesInit = xstate.fromCallback(({ sendBack, input: { context, e
                 gatewayHyperKey: resolvedGateway.gatewayHyperKey,
                 gatewaySidecarHost: gatewayConfig.hyper?.localSidecarHost,
                 gatewaySidecarPort: gatewayConfig.hyper?.localSidecarPort,
+                gatewayProxyBaseUrl: resolvedGateway.proxyBaseUrl ?? gatewayConfig.proxyBaseUrl,
                 addresses: normalizedAddresses.owned,
                 ownedAddresses: normalizedAddresses.owned,
                 watchedAddresses: normalizedAddresses.watched,
@@ -13586,7 +13580,7 @@ const platformClassesInit = xstate.fromCallback(({ sendBack, input: { context, e
                 schema,
                 syncFromEasOnAddressChange: options.syncFromEasOnAddressChange ?? true,
             } });
-        if (resolvedGateway.activePath !== 'hyper-sidecar') {
+        if (resolvedGateway.activePath !== 'hyper-sidecar' && resolvedGateway.activePath !== 'http-proxy') {
             void arweave.ensureReadGatewaySelected().catch(() => {
                 /* non-blocking warm-up for read gateway probe */
             });
@@ -13925,7 +13919,7 @@ const addModelsToDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
 const logger$7 = debug('seedSdk:client:actors:saveConfig');
 const saveConfig = xstate.fromCallback(({ sendBack, input: { context } }) => {
     logger$7('saveConfig starting');
-    const { endpoints, addresses, ownedAddresses, watchedAddresses, arweaveDomain, uploadApiBaseUrl, gatewayTransport, gatewayHyperKey, gatewaySidecarHost, gatewaySidecarPort, } = context;
+    const { endpoints, addresses, ownedAddresses, watchedAddresses, arweaveDomain, uploadApiBaseUrl, gatewayTransport, gatewayHyperKey, gatewaySidecarHost, gatewaySidecarPort, gatewayProxyBaseUrl, } = context;
     // Validate endpoints - required for proper initialization
     // If endpoints are missing or invalid, initialization should fail
     if (!endpoints || !endpoints.filePaths || !endpoints.files) {
@@ -14005,6 +13999,7 @@ const saveConfig = xstate.fromCallback(({ sendBack, input: { context } }) => {
             if (gatewaySidecarPort != null) {
                 await persistKey('gatewaySidecarPort', String(gatewaySidecarPort));
             }
+            await persistKey('gatewayProxyBaseUrl', gatewayProxyBaseUrl);
         }
         catch (error) {
             logger$7('[internal/actors] [saveConfig] Error saving config:', error);
@@ -16500,6 +16495,403 @@ const clientManagerMachine = xstate.setup({
     },
 });
 
+function msToUnixSeconds(ms) {
+    if (ms == null || !Number.isFinite(ms))
+        return 0;
+    // Heuristic: values already in seconds are small; ms are large
+    if (ms > 1e12)
+        return Math.floor(ms / 1000);
+    if (ms > 1e10)
+        return Math.floor(ms / 1000);
+    return Math.floor(ms);
+}
+function toSnakeCaseName(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
+        .toLowerCase();
+}
+function parsePropertyValue(raw) {
+    if (raw == null)
+        return '';
+    const t = raw.trim();
+    if ((t.startsWith('[') && t.endsWith(']')) ||
+        (t.startsWith('{') && t.endsWith('}'))) {
+        try {
+            return JSON.parse(t);
+        }
+        catch {
+            return raw;
+        }
+    }
+    return raw;
+}
+function attestationFromRaw(raw) {
+    if (!raw || !raw.trim())
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed.id === 'string')
+            return parsed;
+    }
+    catch {
+        // fall through
+    }
+    return null;
+}
+function seedRowToAttestation(row) {
+    if (!row.uid || !eas.isValidEasAttestationUid(row.uid))
+        return null;
+    const fromRaw = attestationFromRaw(row.attestationRaw);
+    if (fromRaw) {
+        const schemaName = row.schemaName ??
+            fromRaw.schema?.schemaNames?.[0]?.name ??
+            row.type ??
+            'unknown';
+        return {
+            ...fromRaw,
+            id: row.uid,
+            schema: {
+                schemaNames: [{ name: schemaName }],
+            },
+            timeCreated: fromRaw.timeCreated ||
+                msToUnixSeconds(row.attestationCreatedAt),
+            attester: fromRaw.attester ?? row.publisher ?? undefined,
+            schemaId: fromRaw.schemaId || row.schemaUid || '',
+        };
+    }
+    const schemaName = row.schemaName ?? row.type ?? 'unknown';
+    return {
+        id: row.uid,
+        decodedDataJson: '',
+        refUID: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        schemaId: row.schemaUid || '',
+        timeCreated: msToUnixSeconds(row.attestationCreatedAt),
+        attester: row.publisher ?? undefined,
+        schema: { schemaNames: [{ name: schemaName }] },
+    };
+}
+function versionRowToAttestation(row) {
+    if (!row.uid || !eas.isValidEasAttestationUid(row.uid))
+        return null;
+    if (!row.seedUid)
+        return null;
+    const fromRaw = attestationFromRaw(row.attestationRaw);
+    if (fromRaw) {
+        return {
+            ...fromRaw,
+            id: row.uid,
+            refUID: row.seedUid,
+            timeCreated: fromRaw.timeCreated ||
+                msToUnixSeconds(row.attestationCreatedAt),
+            attester: fromRaw.attester ?? row.publisher ?? undefined,
+        };
+    }
+    return {
+        id: row.uid,
+        decodedDataJson: '',
+        refUID: row.seedUid,
+        schemaId: '',
+        timeCreated: msToUnixSeconds(row.attestationCreatedAt),
+        attester: row.publisher ?? undefined,
+    };
+}
+function metadataRowToAttestation(row) {
+    if (!row.uid || !eas.isValidEasAttestationUid(row.uid))
+        return null;
+    if (!row.versionUid)
+        return null;
+    const fromRaw = attestationFromRaw(row.attestationRaw);
+    if (fromRaw) {
+        return {
+            ...fromRaw,
+            id: row.uid,
+            refUID: row.versionUid,
+            schemaId: fromRaw.schemaId || row.schemaUid || '',
+            timeCreated: fromRaw.timeCreated ||
+                msToUnixSeconds(row.attestationCreatedAt),
+            attester: fromRaw.attester ?? row.publisher ?? undefined,
+        };
+    }
+    const name = row.propertyName
+        ? toSnakeCaseName(row.propertyName)
+        : 'unknown';
+    const value = parsePropertyValue(row.propertyValue);
+    const type = row.easDataType || 'string';
+    return {
+        id: row.uid,
+        decodedDataJson: JSON.stringify([{ value: { name, value, type } }]),
+        refUID: row.versionUid,
+        schemaId: row.schemaUid || '',
+        timeCreated: msToUnixSeconds(row.attestationCreatedAt),
+        attester: row.publisher ?? undefined,
+    };
+}
+async function resolveSchemaNameForSeedType(appDb, seedType) {
+    if (!seedType)
+        return null;
+    const normalized = lodashEs.startCase(seedType);
+    try {
+        const schemaRows = await appDb
+            .select({ schemaName: schemas.name })
+            .from(models$1)
+            .innerJoin(modelSchemas, drizzleOrm.eq(models$1.id, modelSchemas.modelId))
+            .innerJoin(schemas, drizzleOrm.eq(modelSchemas.schemaId, schemas.id))
+            .where(drizzleOrm.eq(models$1.name, normalized))
+            .limit(1);
+        if (schemaRows[0]?.schemaName)
+            return schemaRows[0].schemaName;
+    }
+    catch {
+        // ignore
+    }
+    return seedType;
+}
+function monthBoundsUnix(year, month) {
+    const startDate = new Date(year, month - 1, 1);
+    const endDate = new Date(year, month, 0, 23, 59, 59);
+    const startTs = Math.floor(startDate.getTime() / 1000);
+    const endTs = Math.floor(endDate.getTime() / 1000) + 1;
+    return { startTs, endTs };
+}
+async function listPublishedSeedRows(schemaName, opts) {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb)
+        return [];
+    const snakeType = schemaName.includes('_')
+        ? schemaName
+        : schemaName.replace(/([A-Z])/g, (m, i) => i === 0 ? m.toLowerCase() : `_${m.toLowerCase()}`);
+    // Prefer exact type match (EAS schema names are usually lowercase singular)
+    const typeCandidates = Array.from(new Set([schemaName, schemaName.toLowerCase(), snakeType.toLowerCase()]));
+    const rows = await appDb
+        .select({
+        uid: seeds.uid,
+        schemaUid: seeds.schemaUid,
+        type: seeds.type,
+        publisher: seeds.publisher,
+        attestationRaw: seeds.attestationRaw,
+        attestationCreatedAt: seeds.attestationCreatedAt,
+        revokedAt: seeds.revokedAt,
+        markedForDeletion: seeds._markedForDeletion,
+    })
+        .from(seeds)
+        .where(drizzleOrm.and(drizzleOrm.inArray(seeds.type, typeCandidates), drizzleOrm.isNotNull(seeds.uid), drizzleOrm.or(drizzleOrm.isNull(seeds.revokedAt), drizzleOrm.eq(seeds.revokedAt, 0)), drizzleOrm.or(drizzleOrm.isNull(seeds._markedForDeletion), drizzleOrm.eq(seeds._markedForDeletion, 0))))
+        .orderBy(drizzleOrm.desc(seeds.attestationCreatedAt));
+    const out = [];
+    for (const row of rows) {
+        if (!row.uid || !eas.isValidEasAttestationUid(row.uid))
+            continue;
+        // Must have at least one published version
+        const versionRows = await appDb
+            .select({
+            uid: versions.uid,
+        })
+            .from(versions)
+            .where(drizzleOrm.eq(versions.seedUid, row.uid))
+            .orderBy(drizzleOrm.desc(versions.createdAt));
+        const hasPublished = versionRows.some((v) => v.uid && eas.isValidEasAttestationUid(v.uid));
+        if (!hasPublished)
+            continue;
+        const schemaResolved = await resolveSchemaNameForSeedType(appDb, row.type);
+        const att = seedRowToAttestation({
+            ...row,
+            schemaName: schemaResolved === schemaName ? schemaName : (schemaResolved ?? schemaName),
+        });
+        if (!att)
+            continue;
+        // Force requested schema name so assembleSeeds filters correctly
+        att.schema = { schemaNames: [{ name: schemaName }] };
+        if (opts?.startTs != null || opts?.endTs != null) {
+            const t = att.timeCreated;
+            if (opts.startTs != null && t < opts.startTs)
+                continue;
+            if (opts.endTs != null && t >= opts.endTs)
+                continue;
+        }
+        out.push(att);
+    }
+    return out;
+}
+/**
+ * SDK local QueryDataSource: published Seeds/Versions/metadata from SQLite.
+ */
+function createLocalQueryDataSource() {
+    return {
+        kind: 'local',
+        async getSeedByUid(seedUid) {
+            const appDb = BaseDb.getAppDb();
+            if (!appDb || !seedUid)
+                return null;
+            const rows = await appDb
+                .select({
+                uid: seeds.uid,
+                schemaUid: seeds.schemaUid,
+                type: seeds.type,
+                publisher: seeds.publisher,
+                attestationRaw: seeds.attestationRaw,
+                attestationCreatedAt: seeds.attestationCreatedAt,
+                revokedAt: seeds.revokedAt,
+            })
+                .from(seeds)
+                .where(drizzleOrm.eq(seeds.uid, seedUid))
+                .limit(1);
+            const row = rows[0];
+            if (!row?.uid || !eas.isValidEasAttestationUid(row.uid))
+                return null;
+            if (row.revokedAt != null && row.revokedAt !== 0)
+                return null;
+            const schemaName = await resolveSchemaNameForSeedType(appDb, row.type);
+            return seedRowToAttestation({ ...row, schemaName });
+        },
+        async listSeedsBySchemaName(schemaName, opts) {
+            const all = await listPublishedSeedRows(schemaName);
+            return all.slice(opts.skip, opts.skip + opts.limit);
+        },
+        async listSeedsBySchemaNameForMonth(schemaName, year, month) {
+            const { startTs, endTs } = monthBoundsUnix(year, month);
+            return listPublishedSeedRows(schemaName, { startTs, endTs });
+        },
+        async getVersionsForSeed(seedUid) {
+            return this.getVersionsForSeeds([seedUid]);
+        },
+        async getVersionsForSeeds(seedUids) {
+            const appDb = BaseDb.getAppDb();
+            if (!appDb || seedUids.length === 0)
+                return [];
+            const rows = await appDb
+                .select({
+                uid: versions.uid,
+                seedUid: versions.seedUid,
+                publisher: versions.publisher,
+                attestationRaw: versions.attestationRaw,
+                attestationCreatedAt: versions.attestationCreatedAt,
+            })
+                .from(versions)
+                .where(drizzleOrm.inArray(versions.seedUid, seedUids));
+            const out = [];
+            for (const row of rows) {
+                const att = versionRowToAttestation(row);
+                if (att)
+                    out.push(att);
+            }
+            return out;
+        },
+        async getPropertiesForVersionUids(versionUids) {
+            const appDb = BaseDb.getAppDb();
+            if (!appDb || versionUids.length === 0)
+                return [];
+            const rows = await appDb
+                .select({
+                uid: metadata$1.uid,
+                schemaUid: metadata$1.schemaUid,
+                propertyName: metadata$1.propertyName,
+                propertyValue: metadata$1.propertyValue,
+                easDataType: metadata$1.easDataType,
+                versionUid: metadata$1.versionUid,
+                publisher: metadata$1.publisher,
+                attestationRaw: metadata$1.attestationRaw,
+                attestationCreatedAt: metadata$1.attestationCreatedAt,
+            })
+                .from(metadata$1)
+                .where(drizzleOrm.inArray(metadata$1.versionUid, versionUids));
+            const out = [];
+            for (const row of rows) {
+                const att = metadataRowToAttestation(row);
+                if (att)
+                    out.push(att);
+            }
+            return out;
+        },
+        async getSeedsByUids(uids) {
+            const appDb = BaseDb.getAppDb();
+            if (!appDb || uids.length === 0)
+                return [];
+            const rows = await appDb
+                .select({
+                uid: seeds.uid,
+                schemaUid: seeds.schemaUid,
+                type: seeds.type,
+                publisher: seeds.publisher,
+                attestationRaw: seeds.attestationRaw,
+                attestationCreatedAt: seeds.attestationCreatedAt,
+                revokedAt: seeds.revokedAt,
+            })
+                .from(seeds)
+                .where(drizzleOrm.inArray(seeds.uid, uids));
+            const out = [];
+            for (const row of rows) {
+                if (row.revokedAt != null && row.revokedAt !== 0)
+                    continue;
+                const schemaName = await resolveSchemaNameForSeedType(appDb, row.type);
+                const att = seedRowToAttestation({ ...row, schemaName });
+                if (att)
+                    out.push(att);
+            }
+            return out;
+        },
+        async readStorageBody(ref) {
+            try {
+                if (ref.localPathHint) {
+                    const text = await BaseFileManager.readFileAsString(ref.localPathHint);
+                    if (text)
+                        return text;
+                }
+                // Common layout: html/{name}.html under filesDir
+                if (typeof ref.value === 'string') {
+                    const v = ref.value.trim();
+                    // Absolute or relative file path already on disk
+                    if (v.includes('/') && !v.startsWith('http')) {
+                        try {
+                            const text = await BaseFileManager.readFileAsString(v);
+                            if (text)
+                                return text;
+                        }
+                        catch {
+                            // try under html/
+                        }
+                    }
+                    const htmlPath = BaseFileManager.getFilesPath('html', v.endsWith('.html') ? v : `${v}.html`);
+                    try {
+                        const text = await BaseFileManager.readFileAsString(htmlPath);
+                        if (text)
+                            return text;
+                    }
+                    catch {
+                        // fall through
+                    }
+                }
+            }
+            catch {
+                return null;
+            }
+            return null;
+        },
+    };
+}
+
+let registered = false;
+/**
+ * Register the SDK SQLite/files adapter with `@seedprotocol/query`.
+ * Safe to call multiple times; re-registers with a fresh adapter instance.
+ * No-op when the app DB is not ready yet (unless `force`).
+ */
+function registerSeedQueryLocalSource(options) {
+    try {
+        query.registerLocalQuerySource(createLocalQueryDataSource());
+        registered = true;
+        return true;
+    }
+    catch (err) {
+        console.warn('[sdk/query] registerSeedQueryLocalSource failed:', err);
+        return false;
+    }
+}
+/** Unregister local query source (tests / client unload). */
+function unregisterSeedQueryLocalSource() {
+    query.clearLocalQuerySource();
+    registered = false;
+}
+
 const logger$3 = debug('seedSdk:client');
 const clientManager = xstate.createActor(clientManagerMachine, {
     input: {
@@ -16604,6 +16996,8 @@ const clientInstance = {
             }
             throw error;
         }
+        // Wire `@seedprotocol/query` local source once DB is ready
+        registerSeedQueryLocalSource();
     },
     setAddresses: async (addresses) => {
         ensureInitialized();
@@ -16665,10 +17059,12 @@ const clientInstance = {
     },
     stop: () => {
         ensureInitialized();
+        unregisterSeedQueryLocalSource();
         clientManager.stop();
     },
     unload: () => {
         ensureInitialized();
+        unregisterSeedQueryLocalSource();
         clientManager.stop();
         subscription.unsubscribe();
     },
@@ -16851,7 +17247,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-CmuGJvyi.js'); })
+const modelPropertyImportPromise = Promise.resolve().then(function () { return require('./ModelProperty-Dgd4tGrB.js'); })
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -16868,7 +17264,7 @@ function getModelProperty() {
 }
 // Lazy import cache for Schema to avoid circular dependency
 let SchemaClass = null;
-const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-gpFnZMhB.js'); })
+const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-dkd-eo3B.js'); })
     .then(module => {
     SchemaClass = module.Schema;
     return SchemaClass;
@@ -18773,7 +19169,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-vk2DeF2D.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-CRBI6dSD.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
@@ -18843,7 +19239,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-_bivrvRs.js'); });
+        const { backfillMetadataPropertyIds } = await Promise.resolve().then(function () { return require('./backfillMetadataPropertyIds-ClLuj3s6.js'); });
         await backfillMetadataPropertyIds();
         return this.db;
     }
@@ -19045,6 +19441,27 @@ const saveModelsFromMarkdown = async (filePath, db) => {
     return modelDefinitions;
 };
 
+/**
+ * Webpack / Next.js config helper for Seed Protocol apps.
+ */
+const withSeed = (config, webpack, isServer) => {
+    config.plugins.push(new webpack.NormalModuleReplacementPlugin(/node:/, (resource) => {
+        resource.request = resource.request.replace(/^node:/, '');
+    }));
+    if (!isServer) {
+        config.resolve.alias['fs'] = '@zenfs/core';
+        config.resolve.alias['node:fs'] = '@zenfs/core';
+        config.resolve.alias['node:path'] = 'path-browserify';
+        config.resolve.alias['path'] = 'path-browserify';
+    }
+    if (isServer) {
+        config.externals.push('@sqlite.org/sqlite-wasm');
+        config.externals.push('chokidar');
+        config.externals.push('arweave');
+    }
+    return config;
+};
+
 const logger = debug('seedSdk:node:helpers:PathResolver');
 class NodePathResolver {
     /** @deprecated Prefer BasePathResolver static methods or configure(). */
@@ -19388,7 +19805,6 @@ exports.modelSchemas = modelSchemas;
 exports.modelUids = modelUids;
 exports.models = models$1;
 exports.normalizeDataType = normalizeDataType;
-exports.parseEasRelationPropertyName = parseEasRelationPropertyName;
 exports.parseListPropertyValueFromStorage = parseListPropertyValueFromStorage;
 exports.parseMarkdownFrontmatter = parseMarkdownFrontmatter;
 exports.processSeedConfig = processSeedConfig;
@@ -19411,5 +19827,6 @@ exports.transformImportToSchemaFile = transformImportToSchemaFile;
 exports.unloadEntity = unloadEntity;
 exports.versions = versions;
 exports.waitForEntityIdle = waitForEntityIdle;
+exports.withSeed = withSeed;
 exports.writeProcessMachine = writeProcessMachine;
-//# sourceMappingURL=index-vk2DeF2D.js.map
+//# sourceMappingURL=index-CRBI6dSD.js.map