@xyo-network/bridge-pub-sub 2.107.3 → 2.107.5

package/dist/browser/index.cjs

@@ -1,2 +1,1055 @@
-"use strict";var T=Object.defineProperty;var De=Object.getOwnPropertyDescriptor;var Me=Object.getOwnPropertyNames;var Re=Object.prototype.hasOwnProperty;var d=(a,e)=>T(a,"name",{value:e,configurable:!0});var Ee=(a,e)=>{for(var s in e)T(a,s,{get:e[s],enumerable:!0})},Pe=(a,e,s,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of Me(e))!Re.call(a,r)&&r!==s&&T(a,r,{get:()=>e[r],enumerable:!(t=De(e,r))||t.enumerable});return a};var Qe=a=>Pe(T({},"__esModule",{value:!0}),a);var We={};Ee(We,{AbstractModuleHost:()=>$,AsyncQueryBusClient:()=>M,AsyncQueryBusHost:()=>_,AsyncQueryBusModuleHost:()=>X,AsyncQueryBusModuleProxy:()=>E,Pending:()=>b,PubSubBridge:()=>H,PubSubBridgeConfigSchema:()=>L,PubSubBridgeModuleResolver:()=>Q,PubSubBridgeSchema:()=>V});module.exports=Qe(We);var ee=require("@xylabs/object");var $=class extends ee.Base{static{d(this,"AbstractModuleHost")}};var oe=require("@xylabs/assert"),ne=require("@xylabs/delay"),ae=require("@xylabs/forget"),D=require("@xylabs/timer"),le=require("@xyo-network/boundwitness-model"),de=require("@xyo-network/diviner-boundwitness-model"),j=require("@xyo-network/payload-builder"),ce=require("lru-cache");var S=require("@xylabs/assert"),te=require("@xylabs/object"),U=require("@xyo-network/archivist-model"),O=require("@xyo-network/diviner-model"),W=require("@xyo-network/module-model"),re=require("async-mutex"),ie=require("lru-cache");var Fe=100,He=6e4,se=1e3,q=class extends te.Base{static{d(this,"AsyncQueryBusBase")}_lastState;_targetConfigs={};_targetQueries={};_lastResolveFailure={};_queriesArchivist;_queriesDiviner;_reResolveDelay=1e3*5;_resolveMutex=new re.Mutex;_responsesArchivist;_responsesDiviner;constructor(e){super(e)}get config(){return this.params.config}get pollFrequency(){let e=this.config?.pollFrequency??se;return e<Fe||e>He?se:e}get rootModule(){return this.params.rootModule}get lastState(){let e={max:1e3,ttl:0};return this._lastState=this._lastState??new ie.LRUCache(e),this._lastState}async queriesArchivist(){return await this._resolveMutex.runExclusive(async()=>(this._queriesArchivist=this._queriesArchivist??await this.resolve((0,S.assertEx)(this.config?.intersect?.queries?.archivist,()=>"No queries Archivist defined"),U.isArchivistInstance),this._queriesArchivist))}async queriesDiviner(){return await this._resolveMutex.runExclusive(async()=>(this._queriesDiviner=this._queriesDiviner??await this.resolve((0,S.assertEx)(this.config?.intersect?.queries?.boundWitnessDiviner,()=>"No queries Diviner defined"),O.isDivinerInstance),this._queriesDiviner))}async responsesArchivist(){return await this._resolveMutex.runExclusive(async()=>(this._responsesArchivist=this._responsesArchivist??await this.resolve((0,S.assertEx)(this.config?.intersect?.responses?.archivist,()=>"No responses Archivist defined"),U.isArchivistInstance),this._responsesArchivist))}async responsesDiviner(){return await this._resolveMutex.runExclusive(async()=>(this._responsesDiviner=this._responsesDiviner??await this.resolve((0,S.assertEx)(this.config?.intersect?.responses?.boundWitnessDiviner,()=>"No responses Diviner defined"),O.isDivinerInstance),this._responsesDiviner))}async commitState(e,s){await Promise.resolve();let t=this.lastState.get(e);t&&t>=s||this.lastState.set(e,s)}async retrieveState(e){await Promise.resolve();let s=this.lastState.get(e);if(s===void 0){let t=Date.now()-1e3;return this.lastState.set(e,t),t}else return s}async resolve(e,s){if(Date.now()-(this._lastResolveFailure[e]??0)<this._reResolveDelay)return;this._lastResolveFailure[e]=Date.now();let t=await W.ResolveHelper.resolveModuleIdentifier(this.rootModule,e);if(t){if(s(t))return delete this._lastResolveFailure[e],t;this.logger?.warn(`Unable to resolve responsesDiviner as correct type [${e}][${t?.constructor?.name}]: ${t.id}`)}else this.logger?.debug(`Unable to resolve queriesArchivist [${e}] [${await W.ResolveHelper.traceModuleIdentifier(this.rootModule,e)}]`)}};var b="pending";var M=class extends q{static{d(this,"AsyncQueryBusClient")}_queryCache;_pollCount=0;_pollId;constructor(e){super(e)}get queryCacheConfig(){let e=this.config?.queryCache===!0?{}:this.config?.queryCache;return{max:100,ttl:1e3*60,...e}}get started(){return!!this._pollId}get queryCache(){let e=this.queryCacheConfig,s={noUpdateTTL:!1,ttlAutopurge:!0};return this._queryCache=this._queryCache??new ce.LRUCache({...e,...s}),this._queryCache}listeningAddresses(){return this._queryCache?.keys()}async send(e,s,t){this.logger?.debug(`Begin issuing query to: ${e}`);let r={...s?.$meta,destination:[e]},i=await j.PayloadBuilder.build({...s,$meta:r}),o=(0,oe.assertEx)(await this.queriesArchivist(),()=>`Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`),n=i?.$hash??Object.keys(await j.PayloadBuilder.toDataHashMap([i]))[0];this.logger?.debug(`Issuing query: ${n} to: ${e}`);let l=t?[i,...t]:[i],c=await o.insert?.(l);if(this.logger?.debug(`Issued query: ${n} to: ${e}`),this.queryCache.set(n,b),!c)throw new Error("Unable to issue query to queryArchivist");return new Promise((p,y)=>{this.logger?.debug(`Polling for response to query: ${n}`);let u=100;(0,ae.forget)(d(async()=>{try{this.start();let f=this.queryCache.get(n);for(;f!==void 0;){if(await(0,ne.delay)(u),f=this.queryCache.get(n),f&&f!==b){this.logger?.log(`Returning response to query: ${n}`),p(f);return}u=Math.floor(u*1.2),u>1e3&&(u=1e3)}this.logger?.error("Timeout waiting for query response"),y({message:"Timeout waiting for query response",query:"network.xyo.boundwitness",schema:"network.xyo.error.module",sources:[n]});return}finally{this.stop()}},"pollForResponse")())})}poll(){this._pollId=(0,D.setTimeoutEx)(async()=>{try{await this.processIncomingResponses()}catch(e){this.logger?.error?.(`Error in main loop: ${e}`)}finally{this._pollId&&(0,D.clearTimeoutEx)(this._pollId),this._pollId=void 0,this.poll()}},this.pollFrequency)}processIncomingResponses=d(async()=>{let e=await this.responsesArchivist();if(e){let s=await this.responsesDiviner();if(s){let t=[...this.queryCache.entries()].filter(([r,i])=>i===b);await Promise.allSettled(t.map(async([r,i])=>{if(i===b){let o={limit:1,order:"desc",schema:de.BoundWitnessDivinerQuerySchema,sourceQuery:r},n=await s.divine([o]);if(n&&n.length>0){let l=n.find(le.isBoundWitnessWithMeta);if(l&&l?.$meta?.sourceQuery===r){this.logger?.debug(`Found response to query: ${r}`);let c=l.payload_hashes?.length>0?await e.get(l.payload_hashes):[];this.queryCache.set(r,[l,c,[]])}}}}))}}},"processIncomingResponses");start(){this._pollCount===0&&this.poll(),this._pollCount++}stop(){this._pollCount--,this._pollCount<=0&&(this._pollId&&(0,D.clearTimeoutEx)(this._pollId),this._pollId=void 0,this._pollCount=0)}};var he=require("@xylabs/array"),v=require("@xylabs/assert"),R=require("@xylabs/timer"),ue=require("@xyo-network/boundwitness-model"),pe=require("@xyo-network/bridge-model"),fe=require("@xyo-network/diviner-boundwitness-model"),g=require("@xyo-network/module-model"),k=require("@xyo-network/payload-builder");var G=4,Y=64,Te=16,Le=4,Ne=64,Be=16,_=class extends q{static{d(this,"AsyncQueryBusHost")}_exposedAddresses=new Set;_exposeOptions={};_idle=!1;_lastQueryTime;_pollId;constructor(e){super(e)}get exposedAddresses(){return this._exposedAddresses}get idlePollFrequency(){let e=this.config?.idlePollFrequency??Te*this.pollFrequency;return e<this.pollFrequency*G?G*this.pollFrequency:e>this.pollFrequency*Y?Y*this.pollFrequency:e}get idleThreshold(){let e=this.config?.idleThreshold??Be*this.idlePollFrequency;return e<this.idlePollFrequency*Le?G*this.pollFrequency:e>this.idlePollFrequency*Ne?Y*this.pollFrequency:e}get perAddressBatchQueryLimit(){return this.config?.perAddressBatchQueryLimit??10}get started(){return!!this._pollId}expose(e,s){let{failOnAlreadyExposed:t}=s??{};if((0,pe.isBridgeInstance)(e))this.logger?.warn(`Attempted to expose a BridgeModule [${e.id}] - Not exposing`);else return(0,v.assertEx)(!t||!this._exposedAddresses.has(e.address),()=>`Address already exposed: ${e.id} [${e.address}]`),this._exposedAddresses.add(e.address),this._exposeOptions[e.address]={...s},this.logger?.debug(`${e.id} exposed [${e.address}]`),e}async listeningModules(){let e=[...this.config?.listeningModules??[],...this.exposedAddresses.values()];return await Promise.all(e.map(async t=>(0,v.assertEx)((0,g.asModuleInstance)(await(0,g.resolveAddressToInstance)(this.rootModule,t)),()=>`Unable to resolve listeningModule [${t}]`)))}start(){this.started&&console.warn("AsyncQueryBus starting when already started"),this.poll()}stop(){this.started||console.warn("AsyncQueryBus stopping when already stopped"),this._pollId&&(0,R.clearTimeoutEx)(this._pollId),this._pollId=void 0}async unexpose(e,s=!0){let t=(0,g.asModuleInstance)(await this.rootModule.resolve(e,{maxDepth:10}));return t&&((0,v.assertEx)(!s||this._exposedAddresses.has(t.address),()=>`Address not exposed [${t.address}][${t.id}]`),this._exposedAddresses.delete(t.address),delete this._exposeOptions[t.address],this.logger?.debug(`${t.address} [${t.id}] unexposed`)),t}callLocalModule=d(async(e,s)=>{this._idle=!1,this._lastQueryTime=Date.now();let t=e.id,r=(0,v.assertEx)(await this.queriesArchivist(),()=>`Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`),i=(0,v.assertEx)(await this.responsesArchivist(),()=>`Unable to contact responsesArchivist [${this.config?.intersect?.queries?.archivist}]`),o=s.$meta?.destination;if(o&&o?.includes(e.address)){let n=s.payload_hashes.indexOf(s.query);if(n!==-1){let l=s.payload_schemas[n];if(e.queries.includes(l)){let c=await r.get(s.payload_hashes);this.params.onQueryFulfillStarted?.({payloads:c,query:s});let m=await k.PayloadBuilder.toAllHashMap(c),p=(await k.PayloadBuilder.build(s)).$hash;if(!(0,he.containsAll)(Object.keys(m),s.payload_hashes)){this.logger?.error(`Error processing command ${p} for module ${t}, missing payloads`);return}try{let y=m[s.query].schema;this.logger?.debug(`Issuing query ${y} (${p}) addressed to module: ${t}`);let u=await e.query(s,c,{allowedQueries:this._exposeOptions[e.address]?.allowedQueries,schema:g.ModuleConfigSchema}),[A,f,I]=u;this.logger?.debug(`Replying to query ${p} addressed to module: ${t}`),(await i.insert([A,...f,...I])).length===0&&this.logger?.error(`Error replying to query ${p} addressed to module: ${t}`),s?.timestamp&&await this.commitState(e.address,s.timestamp),this.params.onQueryFulfillFinished?.({payloads:c,query:s,result:u,status:"success"})}catch(y){this.params.onQueryFulfillFinished?.({payloads:c,query:s,status:"failure"}),this.logger?.error(`Error processing query ${p} for module ${t}: ${y}`)}}}}},"callLocalModule");findQueriesToAddress=d(async e=>{let s=(0,v.assertEx)(this.config?.intersect?.queries?.boundWitnessDiviner,()=>"No queries Diviner defined"),t=await this.queriesDiviner();if(t){let r=await this.retrieveState(e),i=[e],o=this.perAddressBatchQueryLimit,n={destination:i,limit:o,order:"asc",schema:fe.BoundWitnessDivinerQuerySchema,timestamp:r+1},c=(await t.divine([n])).filter(ue.isQueryBoundWitnessWithMeta),m=c.length>0?Math.max(...c.map(p=>p.timestamp??r))+1:Date.now();return await this.commitState(e,m),this.logger?.debug("findQueriesToAddress",e,r,m),c}else this.logger?.warn(`Unable to resolve queriesBoundWitnessDiviner [${s}] [${await g.ResolveHelper.traceModuleIdentifier(this.rootModule,s)}]`)},"findQueriesToAddress");poll(){this._pollId=(0,R.setTimeoutEx)(async()=>{try{await this.processIncomingQueries()}catch(s){this.logger?.error?.(`Error in main loop: ${s}`)}finally{this._pollId&&(0,R.clearTimeoutEx)(this._pollId),this._pollId=void 0,this.poll()}let e=Date.now();this.idleThreshold<e-(this._lastQueryTime??e)&&(this._idle=!0)},this._idle?this.idlePollFrequency:this.pollFrequency)}processIncomingQueries=d(async()=>{this.logger?.debug("Checking for inbound queries");let e=await this.listeningModules();await Promise.allSettled(e.map(async s=>{try{let t=s.id;this.logger?.debug(`Checking for inbound queries to ${t} [${s.address}]`);let r=await this.findQueriesToAddress(s.address)??[];if(r.length===0)return;this.logger?.debug(`Found queries addressed to local module: ${t}`);for(let i of r)await this.callLocalModule(s,i)}catch(t){this.logger?.error(`Error processing queries for address ${s.address}: ${t}`)}}))},"processIncomingQueries")};var X=class extends ${static{d(this,"AsyncQueryBusModuleHost")}_busHost;constructor(e){super(e)}async start(){let e=this.params.config.listeningModules??(await this.params.module.resolve("*",{direction:"down"})).map(s=>s.address);this._busHost=new _({config:{...this.params.config,listeningModules:e},logger:this.params.logger,rootModule:this.params.module}),this._busHost?.start()}stop(){this._busHost?.stop()}};var me=require("@xylabs/assert"),J=require("@xylabs/exists"),z=require("@xylabs/forget"),ge=require("@xylabs/hex"),ye=require("@xyo-network/bridge-abstract"),K=require("@xyo-network/module-model");var E=class a extends ye.AbstractModuleProxy{static{d(this,"AsyncQueryBusModuleProxy")}static createCount=0;constructor(e){a.createCount=a.createCount+1,Math.floor(a.createCount/10)===a.createCount/10&&console.log(`AsyncQueryBusModuleProxy.createCount: ${a.createCount}`),super(e)}get id(){return this.address}get modName(){}async proxyQueryHandler(e,s){this.archiving&&this.isAllowedArchivingQuery(e.schema)&&(0,z.forget)(this.storeToArchivists([e,...s??[]]));let t=await this.params.busClient.send(this.address,e,s);return this.archiving&&this.isAllowedArchivingQuery(e.schema)&&(0,z.forget)(this.storeToArchivists(t.flat())),t}async publicChildren(){return(await Promise.all(Object.values(await this.childAddressMap()).filter(J.exists).map(e=>this.resolve(e)))).filter(J.exists)}async resolve(e="*",s={}){let t={address:this.address,dead:this.dead,downResolver:this.downResolver,logger:this.logger,module:this,transformers:this.moduleIdentifierTransformers,upResolver:this.upResolver};if(e==="*")return await this.publicChildren();switch(typeof e){case"string":{let r=e.split(":"),i=(0,me.assertEx)(r.shift(),()=>"Missing first"),o=r.join(":"),n=(0,ge.isAddress)(i)?i:this.childAddressByName(i);if(!n)return;let l=await this.params.host.resolve(n);return o?await l?.resolve(o):l}case"object":return(await K.ResolveHelper.resolve(t,e,s)).filter(r=>r.address!==this.address);default:return(await K.ResolveHelper.resolve(t,e,s)).filter(r=>r.address!==this.address)}}async startHandler(){return await super.startHandler()}};var V="network.xyo.bridge.pubsub";var L=`${V}.config`;var w=require("@xylabs/assert"),F=require("@xylabs/exists"),x=require("@xylabs/forget"),qe=require("@xylabs/hex"),be=require("@xylabs/object"),Ce=require("@xyo-network/bridge-abstract"),h=require("@xyo-network/module-model"),Ie=require("@xyo-network/node-model"),$e=require("@xyo-network/payload-model"),Se=require("async-mutex");var P=require("@xylabs/assert"),ve=require("@xylabs/hex"),_e=require("@xyo-network/account"),N=require("@xyo-network/bridge-abstract"),we=require("@xyo-network/config-payload-plugin"),C=require("@xyo-network/module-model"),xe=require("async-mutex"),Ae=require("lru-cache");var Q=class extends N.AbstractBridgeModuleResolver{static{d(this,"PubSubBridgeModuleResolver")}_resolvedCache=new Ae.LRUCache({max:1e3});_resolvedCacheMutex=new xe.Mutex;async resolveHandler(e,s){let t=await super.resolveHandler(e,s);if(t.length>0)return t;let r=e.split(":"),i=(0,P.assertEx)(r.shift(),()=>"Missing module identifier"),o=await C.ResolveHelper.transformModuleIdentifier(i);(0,P.assertEx)((0,ve.isAddress)(o),()=>`Invalid module address: ${o}`);let n=r.join(":"),l=await this._resolvedCacheMutex.runExclusive(async()=>{let m=this._resolvedCache.get(o);if(m)return r.length<=0?m:m.resolve(n,{...s,maxDepth:(s?.maxDepth??5)-1});let p=_e.Account.randomSync(),y={account:p,archiving:this.params.archiving,busClient:this.params.busClient,config:{schema:C.ModuleConfigSchema},host:this,moduleAddress:o,onQuerySendFinished:this.params.onQuerySendFinished,onQuerySendStarted:this.params.onQuerySendStarted},u=new E(y),A=await u.state();if(A){let I=A.find(B=>B.schema===we.ConfigSchema)?.config,Z=(0,P.assertEx)(A.find(B=>B.schema===I),()=>"Unable to locate config");u.setConfig(Z)}await u.start?.();let f=(0,N.wrapModuleWithType)(u,p);return(0,P.assertEx)((0,C.asModuleInstance)(f,{}),()=>`Failed to asModuleInstance [${e}]`),this._resolvedCache.set(f.address,f),f}),c=n.length>0?await l.resolve(n,s):l;return c?[c]:[]}};function Ue(a,e,s,t){var r=arguments.length,i=r<3?e:t===null?t=Object.getOwnPropertyDescriptor(e,s):t,o;if(typeof Reflect=="object"&&typeof Reflect.decorate=="function")i=Reflect.decorate(a,e,s,t);else for(var n=a.length-1;n>=0;n--)(o=a[n])&&(i=(r<3?o(i):r>3?o(e,s,i):o(e,s))||i);return r>3&&i&&Object.defineProperty(e,s,i),i}d(Ue,"_ts_decorate");var Oe="PubSubBridge",H=class extends Ce.AbstractBridge{static{d(this,"PubSubBridge")}static configSchemas=[...super.configSchemas,L];static defaultConfigSchema=L;_configRootAddress="";_configStateStoreArchivist="";_configStateStoreBoundWitnessDiviner="";_exposedAddresses=[];_lastState;_busClient;_busHost;_discoverRootsMutex=new Se.Mutex;_resolver;get resolver(){return this._resolver=this._resolver??new Q({additionalSigners:this.additionalSigners,archiving:{...this.archiving,resolveArchivists:this.resolveArchivingArchivists.bind(this)},bridge:this,busClient:(0,w.assertEx)(this.busClient(),()=>"busClient not configured"),onQuerySendFinished:d(e=>{(0,x.forget)(this.emit("querySendFinished",{module:this,...e}))},"onQuerySendFinished"),onQuerySendStarted:d(e=>{(0,x.forget)(this.emit("querySendStarted",{module:this,...e}))},"onQuerySendStarted"),root:this,wrapperAccount:this.account}),this._resolver}get moduleName(){return this.modName??Oe}async connect(e,s=5){let t=(0,w.assertEx)(await h.ResolveHelper.transformModuleIdentifier(e),()=>`Unable to transform module identifier: ${e}`),r=await this.resolve(t);if(r)return r.address;let[i]=await this.resolver.resolveHandler(e);return await this.connectInstance(i,s)}async disconnect(e){let s=(0,w.assertEx)(await h.ResolveHelper.transformModuleIdentifier(e),()=>`Unable to transform module identifier: ${e}`),t=await this.resolve(s);if(t)return this.downResolver.remove(t.address),t.address}async exposeChild(e,s){let{maxDepth:t=5}=s??{};console.log(`exposeChild: ${e.address} ${e?.id} ${t}`),(0,w.assertEx)(this.busHost(),()=>"Not configured as a host").expose(e);let i=t>0?await e.publicChildren?.()??[]:[];this.logger.log(`childrenToExpose [${e.id}][${e.address}]: ${(0,be.toJsonString)(i.map(l=>l.id))}`);let o=(await Promise.all(i.map(l=>this.exposeChild(l,{maxDepth:t-1,required:!1})))).flat().filter(F.exists),n=[e,...o];for(let l of n)this.logger?.log(`exposed: ${l.address} [${e.id}]`);return n}async exposeHandler(e,s){let{required:t=!0}=s??{},r=await(0,h.resolveAddressToInstanceUp)(this,e);if(console.log(`exposeHandler: ${e} ${r?.id}`),t&&!r)throw new Error(`Unable to find required module: ${e}`);return r?this.exposeChild(r,s):[]}exposedHandler(){let e=this.busHost()?.exposedAddresses;return e?[...e]:[]}async getRoots(e){return await this._discoverRootsMutex.runExclusive(async()=>{if(this._roots===void 0||e){let s=(await Promise.all((this.config.roots??[]).map(r=>{try{return h.ResolveHelper.transformModuleIdentifier(r)}catch(i){this.logger?.warn("Unable to transform module identifier:",r,i);return}}))).filter(F.exists),t=(await Promise.all(s.map(async r=>{try{return await this.resolver.resolveHandler(r)}catch(i){this.logger?.warn("Unable to resolve root:",r,i);return}}))).flat().filter(F.exists);for(let r of t)this.downResolver.add(r);this._roots=t}return this._roots})}async resolve(e="*",s={}){let t=this._roots??[],r=s.direction==="up"?[this]:[...t,this];if(e==="*"){let i=(s.maxDepth??1)-1;return i<=0?r:[...r,...(await Promise.all(t.map(o=>o.resolve("*",{...s,maxDepth:i})))).flat()]}switch(typeof e){case"string":{let i=e.split(":"),o=(0,w.assertEx)(i.shift(),()=>"Missing first part"),n=(0,qe.isAddress)(o)?await(0,h.resolveAddressToInstance)(this,o,void 0,[],s.direction):this._roots?.find(l=>l.id===o);return i.length===0?n:n?.resolve(i.join(":"),s)}case"object":{let i=[];if((0,h.isAddressModuleFilter)(e))for(let o of r)o.modName&&e.address.includes(o.address)&&i.push(o);return i}default:return}}async startHandler(){return this.busHost()?.start(),await super.startHandler()}async unexposeHandler(e,s){let{maxDepth:t=2,required:r=!0}=s??{},o=await(0,w.assertEx)(this.busHost(),()=>"Not configured as a host").unexpose(e,r);if(o){let n=t>0?await o.publicChildren?.()??[]:[],l=(await Promise.all(n.map(c=>this.unexposeHandler(c.address,{maxDepth:t-1,required:!1})))).flat().filter(F.exists);return[o,...l]}return[]}busClient(){return!this._busClient&&this.config.client&&(this._busClient=new M({config:this.config.client,logger:this.logger,rootModule:this})),this._busClient}busHost(){return!this._busHost&&this.config.host&&(this._busHost=new _({config:this.config.host,logger:this.logger,onQueryFulfillFinished:d(e=>{this.archiving&&this.isAllowedArchivingQuery(e.query.schema)&&(0,x.forget)(this.storeToArchivists(e.result?.flat()??[])),(0,x.forget)(this.emit("queryFulfillFinished",{module:this,...e}))},"onQueryFulfillFinished"),onQueryFulfillStarted:d(e=>{this.archiving&&this.isAllowedArchivingQuery(e.query.schema)&&(0,x.forget)(this.storeToArchivists([e.query,...e.payloads??[]])),(0,x.forget)(this.emit("queryFulfillStarted",{module:this,...e}))},"onQueryFulfillStarted"),rootModule:this})),this._busHost}async connectInstance(e,s=5){if(e){if(this.downResolver.add(e),s>0){let t=(0,Ie.asNodeInstance)(e);if(t){let i=((await t.state())?.filter((0,$e.isPayloadOfSchemaType)(h.AddressSchema)).map(o=>o.address)??[]).filter(o=>o!==e.address);await Promise.all(i.map(o=>this.connect(o,s-1)))}}return this.logger?.log(`Connect: ${e.id}`),e.address}}stopHandler(e){return this.busHost()?.stop(),!0}};H=Ue([(0,h.creatableModule)()],H);
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AbstractModuleHost: () => AbstractModuleHost,
+  AsyncQueryBusClient: () => AsyncQueryBusClient,
+  AsyncQueryBusHost: () => AsyncQueryBusHost,
+  AsyncQueryBusModuleHost: () => AsyncQueryBusModuleHost,
+  AsyncQueryBusModuleProxy: () => AsyncQueryBusModuleProxy,
+  Pending: () => Pending,
+  PubSubBridge: () => PubSubBridge,
+  PubSubBridgeConfigSchema: () => PubSubBridgeConfigSchema,
+  PubSubBridgeModuleResolver: () => PubSubBridgeModuleResolver,
+  PubSubBridgeSchema: () => PubSubBridgeSchema
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/AbstractModuleHost/AbstractModuleHost.ts
+var import_object = require("@xylabs/object");
+var AbstractModuleHost = class extends import_object.Base {
+  static {
+    __name(this, "AbstractModuleHost");
+  }
+};
+
+// src/AsyncQueryBus/AsyncQueryBusClient.ts
+var import_assert2 = require("@xylabs/assert");
+var import_delay = require("@xylabs/delay");
+var import_forget = require("@xylabs/forget");
+var import_timer = require("@xylabs/timer");
+var import_boundwitness_model = require("@xyo-network/boundwitness-model");
+var import_diviner_boundwitness_model = require("@xyo-network/diviner-boundwitness-model");
+var import_payload_builder = require("@xyo-network/payload-builder");
+var import_lru_cache2 = require("lru-cache");
+
+// src/AsyncQueryBus/AsyncQueryBusBase.ts
+var import_assert = require("@xylabs/assert");
+var import_object2 = require("@xylabs/object");
+var import_archivist_model = require("@xyo-network/archivist-model");
+var import_diviner_model = require("@xyo-network/diviner-model");
+var import_module_model = require("@xyo-network/module-model");
+var import_async_mutex = require("async-mutex");
+var import_lru_cache = require("lru-cache");
+var POLLING_FREQUENCY_MIN = 100;
+var POLLING_FREQUENCY_MAX = 6e4;
+var POLLING_FREQUENCY_DEFAULT = 1e3;
+var AsyncQueryBusBase = class extends import_object2.Base {
+  static {
+    __name(this, "AsyncQueryBusBase");
+  }
+  _lastState;
+  _targetConfigs = {};
+  _targetQueries = {};
+  _lastResolveFailure = {};
+  _queriesArchivist;
+  _queriesDiviner;
+  _reResolveDelay = 1e3 * 5;
+  _resolveMutex = new import_async_mutex.Mutex();
+  _responsesArchivist;
+  _responsesDiviner;
+  constructor(params) {
+    super(params);
+  }
+  get config() {
+    return this.params.config;
+  }
+  get pollFrequency() {
+    const frequency = this.config?.pollFrequency ?? POLLING_FREQUENCY_DEFAULT;
+    if (frequency < POLLING_FREQUENCY_MIN || frequency > POLLING_FREQUENCY_MAX) {
+      return POLLING_FREQUENCY_DEFAULT;
+    }
+    return frequency;
+  }
+  get rootModule() {
+    return this.params.rootModule;
+  }
+  /**
+  * A cache of the last offset of the Diviner process per address
+  */
+  get lastState() {
+    const requiredConfig = {
+      max: 1e3,
+      ttl: 0
+    };
+    this._lastState = this._lastState ?? new import_lru_cache.LRUCache(requiredConfig);
+    return this._lastState;
+  }
+  async queriesArchivist() {
+    return await this._resolveMutex.runExclusive(async () => {
+      this._queriesArchivist = this._queriesArchivist ?? await this.resolve((0, import_assert.assertEx)(this.config?.intersect?.queries?.archivist, () => "No queries Archivist defined"), import_archivist_model.isArchivistInstance);
+      return this._queriesArchivist;
+    });
+  }
+  async queriesDiviner() {
+    return await this._resolveMutex.runExclusive(async () => {
+      this._queriesDiviner = this._queriesDiviner ?? await this.resolve((0, import_assert.assertEx)(this.config?.intersect?.queries?.boundWitnessDiviner, () => "No queries Diviner defined"), import_diviner_model.isDivinerInstance);
+      return this._queriesDiviner;
+    });
+  }
+  async responsesArchivist() {
+    return await this._resolveMutex.runExclusive(async () => {
+      this._responsesArchivist = this._responsesArchivist ?? await this.resolve((0, import_assert.assertEx)(this.config?.intersect?.responses?.archivist, () => "No responses Archivist defined"), import_archivist_model.isArchivistInstance);
+      return this._responsesArchivist;
+    });
+  }
+  async responsesDiviner() {
+    return await this._resolveMutex.runExclusive(async () => {
+      this._responsesDiviner = this._responsesDiviner ?? await this.resolve((0, import_assert.assertEx)(this.config?.intersect?.responses?.boundWitnessDiviner, () => "No responses Diviner defined"), import_diviner_model.isDivinerInstance);
+      return this._responsesDiviner;
+    });
+  }
+  /**
+  * Commit the internal state of the process. This is similar
+  * to a transaction completion in a database and should only be called
+  * when results have been successfully persisted to the appropriate
+  * external stores.
+  * @param address The module address to commit the state for
+  * @param nextState The state to commit
+  */
+  async commitState(address, nextState) {
+    await Promise.resolve();
+    const lastState = this.lastState.get(address);
+    if (lastState && lastState >= nextState) return;
+    this.lastState.set(address, nextState);
+  }
+  /**
+  * Retrieves the last state of the process. Used to recover state after
+  * preemptions, reboots, etc.
+  */
+  async retrieveState(address) {
+    await Promise.resolve();
+    const state = this.lastState.get(address);
+    if (state === void 0) {
+      const newState = Date.now() - 1e3;
+      this.lastState.set(address, newState);
+      return newState;
+    } else {
+      return state;
+    }
+  }
+  async resolve(id, typeCheck) {
+    if (Date.now() - (this._lastResolveFailure[id] ?? 0) < this._reResolveDelay) {
+      return;
+    }
+    this._lastResolveFailure[id] = Date.now();
+    const resolved = await import_module_model.ResolveHelper.resolveModuleIdentifier(this.rootModule, id);
+    if (resolved) {
+      if (typeCheck(resolved)) {
+        delete this._lastResolveFailure[id];
+        return resolved;
+      } else {
+        this.logger?.warn(`Unable to resolve responsesDiviner as correct type [${id}][${resolved?.constructor?.name}]: ${resolved.id}`);
+      }
+    } else {
+      this.logger?.debug(`Unable to resolve queriesArchivist [${id}] [${await import_module_model.ResolveHelper.traceModuleIdentifier(this.rootModule, id)}]`);
+    }
+  }
+};
+
+// src/AsyncQueryBus/model/QueryStatus.ts
+var Pending = "pending";
+
+// src/AsyncQueryBus/AsyncQueryBusClient.ts
+var AsyncQueryBusClient = class extends AsyncQueryBusBase {
+  static {
+    __name(this, "AsyncQueryBusClient");
+  }
+  _queryCache;
+  _pollCount = 0;
+  _pollId;
+  constructor(params) {
+    super(params);
+  }
+  get queryCacheConfig() {
+    const queryCacheConfig = this.config?.queryCache === true ? {} : this.config?.queryCache;
+    return {
+      max: 100,
+      ttl: 1e3 * 60,
+      ...queryCacheConfig
+    };
+  }
+  get started() {
+    return !!this._pollId;
+  }
+  /**
+  * A cache of queries that have been issued
+  */
+  get queryCache() {
+    const config = this.queryCacheConfig;
+    const requiredConfig = {
+      noUpdateTTL: false,
+      ttlAutopurge: true
+    };
+    this._queryCache = this._queryCache ?? new import_lru_cache2.LRUCache({
+      ...config,
+      ...requiredConfig
+    });
+    return this._queryCache;
+  }
+  listeningAddresses() {
+    return this._queryCache?.keys();
+  }
+  async send(address, query, payloads) {
+    this.logger?.debug(`Begin issuing query to: ${address}`);
+    const $meta = {
+      ...query?.$meta,
+      destination: [
+        address
+      ]
+    };
+    const routedQuery = await import_payload_builder.PayloadBuilder.build({
+      ...query,
+      $meta
+    });
+    const queryArchivist = (0, import_assert2.assertEx)(await this.queriesArchivist(), () => `Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`);
+    const routedQueryHash = (
+      // Trust the signed hash if it's there
+      routedQuery?.$hash ?? // TODO: What is the right way to find the dataHash
+      Object.keys(await import_payload_builder.PayloadBuilder.toDataHashMap([
+        routedQuery
+      ]))[0]
+    );
+    this.logger?.debug(`Issuing query: ${routedQueryHash} to: ${address}`);
+    const data = payloads ? [
+      routedQuery,
+      ...payloads
+    ] : [
+      routedQuery
+    ];
+    const insertResult = await queryArchivist.insert?.(data);
+    this.logger?.debug(`Issued query: ${routedQueryHash} to: ${address}`);
+    this.queryCache.set(routedQueryHash, Pending);
+    if (!insertResult) throw new Error("Unable to issue query to queryArchivist");
+    const context = new Promise((resolve, reject) => {
+      this.logger?.debug(`Polling for response to query: ${routedQueryHash}`);
+      let nextDelay = 100;
+      const pollForResponse = /* @__PURE__ */ __name(async () => {
+        try {
+          this.start();
+          let response = this.queryCache.get(routedQueryHash);
+          while (response !== void 0) {
+            await (0, import_delay.delay)(nextDelay);
+            response = this.queryCache.get(routedQueryHash);
+            if (response && response !== Pending) {
+              this.logger?.log(`Returning response to query: ${routedQueryHash}`);
+              resolve(response);
+              return;
+            }
+            nextDelay = Math.floor(nextDelay * 1.2);
+            if (nextDelay > 1e3) nextDelay = 1e3;
+          }
+          this.logger?.error("Timeout waiting for query response");
+          const error = {
+            message: "Timeout waiting for query response",
+            query: "network.xyo.boundwitness",
+            schema: "network.xyo.error.module",
+            sources: [
+              routedQueryHash
+            ]
+          };
+          reject(error);
+          return;
+        } finally {
+          this.stop();
+        }
+      }, "pollForResponse");
+      (0, import_forget.forget)(pollForResponse());
+    });
+    return context;
+  }
+  /**
+  * Runs the background divine process on a loop with a delay
+  * specified by the `config.pollFrequency`
+  */
+  poll() {
+    this._pollId = (0, import_timer.setTimeoutEx)(async () => {
+      try {
+        await this.processIncomingResponses();
+      } catch (e) {
+        this.logger?.error?.(`Error in main loop: ${e}`);
+      } finally {
+        if (this._pollId) (0, import_timer.clearTimeoutEx)(this._pollId);
+        this._pollId = void 0;
+        this.poll();
+      }
+    }, this.pollFrequency);
+  }
+  /**
+  * Background process for processing incoming responses to previously issued queries
+  */
+  processIncomingResponses = /* @__PURE__ */ __name(async () => {
+    const responseArchivist = await this.responsesArchivist();
+    if (responseArchivist) {
+      const responseBoundWitnessDiviner = await this.responsesDiviner();
+      if (responseBoundWitnessDiviner) {
+        const pendingCommands = [
+          ...this.queryCache.entries()
+        ].filter(([_, status]) => status === Pending);
+        await Promise.allSettled(pendingCommands.map(async ([sourceQuery, status]) => {
+          if (status === Pending) {
+            const divinerQuery = {
+              limit: 1,
+              order: "desc",
+              schema: import_diviner_boundwitness_model.BoundWitnessDivinerQuerySchema,
+              sourceQuery
+            };
+            const result = await responseBoundWitnessDiviner.divine([
+              divinerQuery
+            ]);
+            if (result && result.length > 0) {
+              const response = result.find(import_boundwitness_model.isBoundWitnessWithMeta);
+              if (response && response?.$meta?.sourceQuery === sourceQuery) {
+                this.logger?.debug(`Found response to query: ${sourceQuery}`);
+                const payloads = response.payload_hashes?.length > 0 ? await responseArchivist.get(response.payload_hashes) : [];
+                this.queryCache.set(sourceQuery, [
+                  response,
+                  payloads,
+                  []
+                ]);
+              }
+            }
+          }
+        }));
+      }
+    }
+  }, "processIncomingResponses");
+  start() {
+    if (this._pollCount === 0) {
+      this.poll();
+    }
+    this._pollCount++;
+  }
+  stop() {
+    this._pollCount--;
+    if (this._pollCount <= 0) {
+      if (this._pollId) (0, import_timer.clearTimeoutEx)(this._pollId);
+      this._pollId = void 0;
+      this._pollCount = 0;
+    }
+  }
+};
+
+// src/AsyncQueryBus/AsyncQueryBusHost.ts
+var import_array = require("@xylabs/array");
+var import_assert3 = require("@xylabs/assert");
+var import_timer2 = require("@xylabs/timer");
+var import_boundwitness_model2 = require("@xyo-network/boundwitness-model");
+var import_bridge_model = require("@xyo-network/bridge-model");
+var import_diviner_boundwitness_model2 = require("@xyo-network/diviner-boundwitness-model");
+var import_module_model2 = require("@xyo-network/module-model");
+var import_payload_builder2 = require("@xyo-network/payload-builder");
+var IDLE_POLLING_FREQUENCY_RATIO_MIN = 4;
+var IDLE_POLLING_FREQUENCY_RATIO_MAX = 64;
+var IDLE_POLLING_FREQUENCY_RATIO_DEFAULT = 16;
+var IDLE_THRESHOLD_RATIO_MIN = 4;
+var IDLE_THRESHOLD_RATIO_MAX = 64;
+var IDLE_THRESHOLD_RATIO_DEFAULT = 16;
+var AsyncQueryBusHost = class extends AsyncQueryBusBase {
+  static {
+    __name(this, "AsyncQueryBusHost");
+  }
+  _exposedAddresses = /* @__PURE__ */ new Set();
+  _exposeOptions = {};
+  _idle = false;
+  _lastQueryTime;
+  _pollId;
+  constructor(params) {
+    super(params);
+  }
+  get exposedAddresses() {
+    return this._exposedAddresses;
+  }
+  get idlePollFrequency() {
+    const frequency = this.config?.idlePollFrequency ?? IDLE_POLLING_FREQUENCY_RATIO_DEFAULT * this.pollFrequency;
+    if (frequency < this.pollFrequency * IDLE_POLLING_FREQUENCY_RATIO_MIN) {
+      return IDLE_POLLING_FREQUENCY_RATIO_MIN * this.pollFrequency;
+    }
+    if (frequency > this.pollFrequency * IDLE_POLLING_FREQUENCY_RATIO_MAX) {
+      return IDLE_POLLING_FREQUENCY_RATIO_MAX * this.pollFrequency;
+    }
+    return frequency;
+  }
+  get idleThreshold() {
+    const threshold = this.config?.idleThreshold ?? IDLE_THRESHOLD_RATIO_DEFAULT * this.idlePollFrequency;
+    if (threshold < this.idlePollFrequency * IDLE_THRESHOLD_RATIO_MIN) {
+      return IDLE_POLLING_FREQUENCY_RATIO_MIN * this.pollFrequency;
+    }
+    if (threshold > this.idlePollFrequency * IDLE_THRESHOLD_RATIO_MAX) {
+      return IDLE_POLLING_FREQUENCY_RATIO_MAX * this.pollFrequency;
+    }
+    return threshold;
+  }
+  get perAddressBatchQueryLimit() {
+    return this.config?.perAddressBatchQueryLimit ?? 10;
+  }
+  get started() {
+    return !!this._pollId;
+  }
+  expose(module2, options) {
+    const { failOnAlreadyExposed } = options ?? {};
+    if ((0, import_bridge_model.isBridgeInstance)(module2)) {
+      this.logger?.warn(`Attempted to expose a BridgeModule [${module2.id}] - Not exposing`);
+    } else {
+      (0, import_assert3.assertEx)(!failOnAlreadyExposed || !this._exposedAddresses.has(module2.address), () => `Address already exposed: ${module2.id} [${module2.address}]`);
+      this._exposedAddresses.add(module2.address);
+      this._exposeOptions[module2.address] = {
+        ...options
+      };
+      this.logger?.debug(`${module2.id} exposed [${module2.address}]`);
+      return module2;
+    }
+  }
+  async listeningModules() {
+    const exposedModules = [
+      ...this.config?.listeningModules ?? [],
+      ...this.exposedAddresses.values()
+    ];
+    const mods = await Promise.all(exposedModules.map(async (exposedModule) => (0, import_assert3.assertEx)((0, import_module_model2.asModuleInstance)(await (0, import_module_model2.resolveAddressToInstance)(this.rootModule, exposedModule)), () => `Unable to resolve listeningModule [${exposedModule}]`)));
+    return mods;
+  }
+  start() {
+    if (this.started) {
+      console.warn("AsyncQueryBus starting when already started");
+    }
+    this.poll();
+  }
+  stop() {
+    if (!this.started) {
+      console.warn("AsyncQueryBus stopping when already stopped");
+    }
+    if (this._pollId) (0, import_timer2.clearTimeoutEx)(this._pollId);
+    this._pollId = void 0;
+  }
+  async unexpose(id, validate = true) {
+    const module2 = (0, import_module_model2.asModuleInstance)(await this.rootModule.resolve(id, {
+      maxDepth: 10
+    }));
+    if (module2) {
+      (0, import_assert3.assertEx)(!validate || this._exposedAddresses.has(module2.address), () => `Address not exposed [${module2.address}][${module2.id}]`);
+      this._exposedAddresses.delete(module2.address);
+      delete this._exposeOptions[module2.address];
+      this.logger?.debug(`${module2.address} [${module2.id}] unexposed`);
+    }
+    return module2;
+  }
+  // eslint-disable-next-line complexity
+  callLocalModule = /* @__PURE__ */ __name(async (localModule, query) => {
+    this._idle = false;
+    this._lastQueryTime = Date.now();
+    const localModuleName = localModule.id;
+    const queryArchivist = (0, import_assert3.assertEx)(await this.queriesArchivist(), () => `Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`);
+    const responsesArchivist = (0, import_assert3.assertEx)(await this.responsesArchivist(), () => `Unable to contact responsesArchivist [${this.config?.intersect?.queries?.archivist}]`);
+    const queryDestination = query.$meta?.destination;
+    if (queryDestination && queryDestination?.includes(localModule.address)) {
+      const queryIndex = query.payload_hashes.indexOf(query.query);
+      if (queryIndex !== -1) {
+        const querySchema = query.payload_schemas[queryIndex];
+        if (localModule.queries.includes(querySchema)) {
+          const queryPayloads = await queryArchivist.get(query.payload_hashes);
+          this.params.onQueryFulfillStarted?.({
+            payloads: queryPayloads,
+            query
+          });
+          const queryPayloadsDict = await import_payload_builder2.PayloadBuilder.toAllHashMap(queryPayloads);
+          const queryHash = (await import_payload_builder2.PayloadBuilder.build(query)).$hash;
+          if (!(0, import_array.containsAll)(Object.keys(queryPayloadsDict), query.payload_hashes)) {
+            this.logger?.error(`Error processing command ${queryHash} for module ${localModuleName}, missing payloads`);
+            return;
+          }
+          try {
+            const querySchema2 = queryPayloadsDict[query.query].schema;
+            this.logger?.debug(`Issuing query ${querySchema2} (${queryHash}) addressed to module: ${localModuleName}`);
+            const result = await localModule.query(query, queryPayloads, {
+              allowedQueries: this._exposeOptions[localModule.address]?.allowedQueries,
+              schema: import_module_model2.ModuleConfigSchema
+            });
+            const [bw, payloads, errors] = result;
+            this.logger?.debug(`Replying to query ${queryHash} addressed to module: ${localModuleName}`);
+            const insertResult = await responsesArchivist.insert([
+              bw,
+              ...payloads,
+              ...errors
+            ]);
+            if (insertResult.length === 0) {
+              this.logger?.error(`Error replying to query ${queryHash} addressed to module: ${localModuleName}`);
+            }
+            if (query?.timestamp) {
+              await this.commitState(localModule.address, query.timestamp);
+            }
+            this.params.onQueryFulfillFinished?.({
+              payloads: queryPayloads,
+              query,
+              result,
+              status: "success"
+            });
+          } catch (error) {
+            this.params.onQueryFulfillFinished?.({
+              payloads: queryPayloads,
+              query,
+              status: "failure"
+            });
+            this.logger?.error(`Error processing query ${queryHash} for module ${localModuleName}: ${error}`);
+          }
+        }
+      }
+    }
+  }, "callLocalModule");
+  /**
+  * Finds unprocessed commands addressed to the supplied address
+  * @param address The address to find commands for
+  */
+  findQueriesToAddress = /* @__PURE__ */ __name(async (address) => {
+    const queriesDivinerId = (0, import_assert3.assertEx)(this.config?.intersect?.queries?.boundWitnessDiviner, () => "No queries Diviner defined");
+    const queriesBoundWitnessDiviner = await this.queriesDiviner();
+    if (queriesBoundWitnessDiviner) {
+      const prevState = await this.retrieveState(address);
+      const destination = [
+        address
+      ];
+      const limit = this.perAddressBatchQueryLimit;
+      const divinerQuery = {
+        destination,
+        limit,
+        order: "asc",
+        schema: import_diviner_boundwitness_model2.BoundWitnessDivinerQuerySchema,
+        timestamp: prevState + 1
+      };
+      const result = await queriesBoundWitnessDiviner.divine([
+        divinerQuery
+      ]);
+      const queries = result.filter(import_boundwitness_model2.isQueryBoundWitnessWithMeta);
+      const nextState = queries.length > 0 ? Math.max(...queries.map((c) => c.timestamp ?? prevState)) + 1 : Date.now();
+      await this.commitState(address, nextState);
+      this.logger?.debug("findQueriesToAddress", address, prevState, nextState);
+      return queries;
+    } else {
+      this.logger?.warn(`Unable to resolve queriesBoundWitnessDiviner [${queriesDivinerId}] [${await import_module_model2.ResolveHelper.traceModuleIdentifier(this.rootModule, queriesDivinerId)}]`);
+    }
+  }, "findQueriesToAddress");
+  /**
+  * Runs the background divine process on a loop with a delay
+  * specified by the `config.pollFrequency`
+  */
+  poll() {
+    this._pollId = (0, import_timer2.setTimeoutEx)(async () => {
+      try {
+        await this.processIncomingQueries();
+      } catch (e) {
+        this.logger?.error?.(`Error in main loop: ${e}`);
+      } finally {
+        if (this._pollId) (0, import_timer2.clearTimeoutEx)(this._pollId);
+        this._pollId = void 0;
+        this.poll();
+      }
+      const now = Date.now();
+      if (this.idleThreshold < now - (this._lastQueryTime ?? now)) {
+        this._idle = true;
+      }
+    }, this._idle ? this.idlePollFrequency : this.pollFrequency);
+  }
+  /**
+  * Background process for checking for inbound queries
+  */
+  processIncomingQueries = /* @__PURE__ */ __name(async () => {
+    this.logger?.debug("Checking for inbound queries");
+    const localModules = await this.listeningModules();
+    await Promise.allSettled(localModules.map(async (localModule) => {
+      try {
+        const localModuleName = localModule.id;
+        this.logger?.debug(`Checking for inbound queries to ${localModuleName} [${localModule.address}]`);
+        const queries = await this.findQueriesToAddress(localModule.address) ?? [];
+        if (queries.length === 0) return;
+        this.logger?.debug(`Found queries addressed to local module: ${localModuleName}`);
+        for (const query of queries) {
+          await this.callLocalModule(localModule, query);
+        }
+      } catch (error) {
+        this.logger?.error(`Error processing queries for address ${localModule.address}: ${error}`);
+      }
+    }));
+  }, "processIncomingQueries");
+};
+
+// src/AsyncQueryBus/ModuleHost/ModuleHost.ts
+var AsyncQueryBusModuleHost = class extends AbstractModuleHost {
+  static {
+    __name(this, "AsyncQueryBusModuleHost");
+  }
+  _busHost;
+  constructor(params) {
+    super(params);
+  }
+  async start() {
+    const listeningModules = this.params.config.listeningModules ?? (await this.params.module.resolve("*", {
+      direction: "down"
+    })).map((m) => m.address);
+    this._busHost = new AsyncQueryBusHost({
+      config: {
+        ...this.params.config,
+        listeningModules
+      },
+      logger: this.params.logger,
+      rootModule: this.params.module
+    });
+    this._busHost?.start();
+  }
+  stop() {
+    this._busHost?.stop();
+  }
+};
+
+// src/AsyncQueryBus/ModuleProxy/ModuleProxy.ts
+var import_assert4 = require("@xylabs/assert");
+var import_exists = require("@xylabs/exists");
+var import_forget2 = require("@xylabs/forget");
+var import_hex = require("@xylabs/hex");
+var import_bridge_abstract = require("@xyo-network/bridge-abstract");
+var import_module_model3 = require("@xyo-network/module-model");
+var AsyncQueryBusModuleProxy = class _AsyncQueryBusModuleProxy extends import_bridge_abstract.AbstractModuleProxy {
+  static {
+    __name(this, "AsyncQueryBusModuleProxy");
+  }
+  static createCount = 0;
+  constructor(params) {
+    _AsyncQueryBusModuleProxy.createCount = _AsyncQueryBusModuleProxy.createCount + 1;
+    if (Math.floor(_AsyncQueryBusModuleProxy.createCount / 10) === _AsyncQueryBusModuleProxy.createCount / 10) {
+      console.log(`AsyncQueryBusModuleProxy.createCount: ${_AsyncQueryBusModuleProxy.createCount}`);
+    }
+    super(params);
+  }
+  get id() {
+    return this.address;
+  }
+  get modName() {
+    return void 0;
+  }
+  async proxyQueryHandler(query, payloads) {
+    if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
+      (0, import_forget2.forget)(this.storeToArchivists([
+        query,
+        ...payloads ?? []
+      ]));
+    }
+    const result = await this.params.busClient.send(this.address, query, payloads);
+    if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
+      (0, import_forget2.forget)(this.storeToArchivists(result.flat()));
+    }
+    return result;
+  }
+  async publicChildren() {
+    return (await Promise.all(Object.values(await this.childAddressMap()).filter(import_exists.exists).map((address) => this.resolve(address)))).filter(import_exists.exists);
+  }
+  async resolve(idOrFilter = "*", options = {}) {
+    const config = {
+      address: this.address,
+      dead: this.dead,
+      downResolver: this.downResolver,
+      logger: this.logger,
+      module: this,
+      transformers: this.moduleIdentifierTransformers,
+      upResolver: this.upResolver
+    };
+    if (idOrFilter === "*") {
+      return await this.publicChildren();
+    }
+    switch (typeof idOrFilter) {
+      case "string": {
+        const parts = idOrFilter.split(":");
+        const first = (0, import_assert4.assertEx)(parts.shift(), () => "Missing first");
+        const remainingPath = parts.join(":");
+        const address = (0, import_hex.isAddress)(first) ? first : this.childAddressByName(first);
+        if (!address) return void 0;
+        const firstInstance = await this.params.host.resolve(address);
+        return remainingPath ? await firstInstance?.resolve(remainingPath) : firstInstance;
+      }
+      case "object": {
+        return (await import_module_model3.ResolveHelper.resolve(config, idOrFilter, options)).filter((mod) => mod.address !== this.address);
+      }
+      default: {
+        return (await import_module_model3.ResolveHelper.resolve(config, idOrFilter, options)).filter((mod) => mod.address !== this.address);
+      }
+    }
+  }
+  async startHandler() {
+    return await super.startHandler();
+  }
+};
+
+// src/Schema.ts
+var PubSubBridgeSchema = "network.xyo.bridge.pubsub";
+
+// src/Config.ts
+var PubSubBridgeConfigSchema = `${PubSubBridgeSchema}.config`;
+
+// src/PubSubBridge.ts
+var import_assert6 = require("@xylabs/assert");
+var import_exists2 = require("@xylabs/exists");
+var import_forget3 = require("@xylabs/forget");
+var import_hex3 = require("@xylabs/hex");
+var import_object3 = require("@xylabs/object");
+var import_bridge_abstract3 = require("@xyo-network/bridge-abstract");
+var import_module_model5 = require("@xyo-network/module-model");
+var import_node_model = require("@xyo-network/node-model");
+var import_payload_model = require("@xyo-network/payload-model");
+var import_async_mutex3 = require("async-mutex");
+
+// src/PubSubBridgeModuleResolver.ts
+var import_assert5 = require("@xylabs/assert");
+var import_hex2 = require("@xylabs/hex");
+var import_account = require("@xyo-network/account");
+var import_bridge_abstract2 = require("@xyo-network/bridge-abstract");
+var import_config_payload_plugin = require("@xyo-network/config-payload-plugin");
+var import_module_model4 = require("@xyo-network/module-model");
+var import_async_mutex2 = require("async-mutex");
+var import_lru_cache3 = require("lru-cache");
+var PubSubBridgeModuleResolver = class extends import_bridge_abstract2.AbstractBridgeModuleResolver {
+  static {
+    __name(this, "PubSubBridgeModuleResolver");
+  }
+  _resolvedCache = new import_lru_cache3.LRUCache({
+    max: 1e3
+  });
+  _resolvedCacheMutex = new import_async_mutex2.Mutex();
+  async resolveHandler(id, options) {
+    const parentResult = await super.resolveHandler(id, options);
+    if (parentResult.length > 0) {
+      return parentResult;
+    }
+    const idParts = id.split(":");
+    const untransformedFirstPart = (0, import_assert5.assertEx)(idParts.shift(), () => "Missing module identifier");
+    const firstPart = await import_module_model4.ResolveHelper.transformModuleIdentifier(untransformedFirstPart);
+    (0, import_assert5.assertEx)((0, import_hex2.isAddress)(firstPart), () => `Invalid module address: ${firstPart}`);
+    const remainderParts = idParts.join(":");
+    const instance = await this._resolvedCacheMutex.runExclusive(async () => {
+      const cachedMod = this._resolvedCache.get(firstPart);
+      if (cachedMod) {
+        const result2 = idParts.length <= 0 ? cachedMod : cachedMod.resolve(remainderParts, {
+          ...options,
+          maxDepth: (options?.maxDepth ?? 5) - 1
+        });
+        return result2;
+      }
+      const account = import_account.Account.randomSync();
+      const finalParams = {
+        account,
+        archiving: this.params.archiving,
+        busClient: this.params.busClient,
+        config: {
+          schema: import_module_model4.ModuleConfigSchema
+        },
+        host: this,
+        moduleAddress: firstPart,
+        onQuerySendFinished: this.params.onQuerySendFinished,
+        onQuerySendStarted: this.params.onQuerySendStarted
+      };
+      const proxy = new AsyncQueryBusModuleProxy(finalParams);
+      const state = await proxy.state();
+      if (state) {
+        const configSchema = state.find((payload) => payload.schema === import_config_payload_plugin.ConfigSchema)?.config;
+        const config = (0, import_assert5.assertEx)(state.find((payload) => payload.schema === configSchema), () => "Unable to locate config");
+        proxy.setConfig(config);
+      }
+      await proxy.start?.();
+      const wrapped = (0, import_bridge_abstract2.wrapModuleWithType)(proxy, account);
+      (0, import_assert5.assertEx)((0, import_module_model4.asModuleInstance)(wrapped, {}), () => `Failed to asModuleInstance [${id}]`);
+      this._resolvedCache.set(wrapped.address, wrapped);
+      return wrapped;
+    });
+    const result = remainderParts.length > 0 ? await instance.resolve(remainderParts, options) : instance;
+    return result ? [
+      result
+    ] : [];
+  }
+};
+
+// src/PubSubBridge.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+var moduleName = "PubSubBridge";
+var PubSubBridge = class extends import_bridge_abstract3.AbstractBridge {
+  static {
+    __name(this, "PubSubBridge");
+  }
+  static configSchemas = [
+    ...super.configSchemas,
+    PubSubBridgeConfigSchema
+  ];
+  static defaultConfigSchema = PubSubBridgeConfigSchema;
+  _configRootAddress = "";
+  _configStateStoreArchivist = "";
+  _configStateStoreBoundWitnessDiviner = "";
+  _exposedAddresses = [];
+  _lastState;
+  _busClient;
+  _busHost;
+  _discoverRootsMutex = new import_async_mutex3.Mutex();
+  _resolver;
+  get resolver() {
+    this._resolver = this._resolver ?? new PubSubBridgeModuleResolver({
+      additionalSigners: this.additionalSigners,
+      archiving: {
+        ...this.archiving,
+        resolveArchivists: this.resolveArchivingArchivists.bind(this)
+      },
+      bridge: this,
+      busClient: (0, import_assert6.assertEx)(this.busClient(), () => "busClient not configured"),
+      onQuerySendFinished: /* @__PURE__ */ __name((args) => {
+        (0, import_forget3.forget)(this.emit("querySendFinished", {
+          module: this,
+          ...args
+        }));
+      }, "onQuerySendFinished"),
+      onQuerySendStarted: /* @__PURE__ */ __name((args) => {
+        (0, import_forget3.forget)(this.emit("querySendStarted", {
+          module: this,
+          ...args
+        }));
+      }, "onQuerySendStarted"),
+      root: this,
+      wrapperAccount: this.account
+    });
+    return this._resolver;
+  }
+  get moduleName() {
+    return this.modName ?? moduleName;
+  }
+  async connect(id, maxDepth = 5) {
+    const transformedId = (0, import_assert6.assertEx)(await import_module_model5.ResolveHelper.transformModuleIdentifier(id), () => `Unable to transform module identifier: ${id}`);
+    const existingInstance = await this.resolve(transformedId);
+    if (existingInstance) {
+      return existingInstance.address;
+    }
+    const [instance] = await this.resolver.resolveHandler(id);
+    return await this.connectInstance(instance, maxDepth);
+  }
+  async disconnect(id) {
+    const transformedId = (0, import_assert6.assertEx)(await import_module_model5.ResolveHelper.transformModuleIdentifier(id), () => `Unable to transform module identifier: ${id}`);
+    const instance = await this.resolve(transformedId);
+    if (instance) {
+      this.downResolver.remove(instance.address);
+      return instance.address;
+    }
+  }
+  async exposeChild(mod, options) {
+    const { maxDepth = 5 } = options ?? {};
+    console.log(`exposeChild: ${mod.address} ${mod?.id} ${maxDepth}`);
+    const host = (0, import_assert6.assertEx)(this.busHost(), () => "Not configured as a host");
+    host.expose(mod);
+    const children = maxDepth > 0 ? await mod.publicChildren?.() ?? [] : [];
+    this.logger.log(`childrenToExpose [${mod.id}][${mod.address}]: ${(0, import_object3.toJsonString)(children.map((child) => child.id))}`);
+    const exposedChildren = (await Promise.all(children.map((child) => this.exposeChild(child, {
+      maxDepth: maxDepth - 1,
+      required: false
+    })))).flat().filter(import_exists2.exists);
+    const allExposed = [
+      mod,
+      ...exposedChildren
+    ];
+    for (const exposedMod of allExposed) this.logger?.log(`exposed: ${exposedMod.address} [${mod.id}]`);
+    return allExposed;
+  }
+  async exposeHandler(address, options) {
+    const { required = true } = options ?? {};
+    const mod = await (0, import_module_model5.resolveAddressToInstanceUp)(this, address);
+    console.log(`exposeHandler: ${address} ${mod?.id}`);
+    if (required && !mod) {
+      throw new Error(`Unable to find required module: ${address}`);
+    }
+    if (mod) {
+      return this.exposeChild(mod, options);
+    }
+    return [];
+  }
+  exposedHandler() {
+    const exposedSet = this.busHost()?.exposedAddresses;
+    return exposedSet ? [
+      ...exposedSet
+    ] : [];
+  }
+  async getRoots(force) {
+    return await this._discoverRootsMutex.runExclusive(async () => {
+      if (this._roots === void 0 || force) {
+        const rootAddresses = (await Promise.all((this.config.roots ?? []).map((id) => {
+          try {
+            return import_module_model5.ResolveHelper.transformModuleIdentifier(id);
+          } catch (ex) {
+            this.logger?.warn("Unable to transform module identifier:", id, ex);
+            return;
+          }
+        }))).filter(import_exists2.exists);
+        const rootInstances = (await Promise.all(rootAddresses.map(async (root) => {
+          try {
+            return await this.resolver.resolveHandler(root);
+          } catch (ex) {
+            this.logger?.warn("Unable to resolve root:", root, ex);
+            return;
+          }
+        }))).flat().filter(import_exists2.exists);
+        for (const instance of rootInstances) {
+          this.downResolver.add(instance);
+        }
+        this._roots = rootInstances;
+      }
+      return this._roots;
+    });
+  }
+  async resolve(idOrFilter = "*", options = {}) {
+    const roots = this._roots ?? [];
+    const workingSet = options.direction === "up" ? [
+      this
+    ] : [
+      ...roots,
+      this
+    ];
+    if (idOrFilter === "*") {
+      const remainingDepth = (options.maxDepth ?? 1) - 1;
+      return remainingDepth <= 0 ? workingSet : [
+        ...workingSet,
+        ...(await Promise.all(roots.map((mod) => mod.resolve("*", {
+          ...options,
+          maxDepth: remainingDepth
+        })))).flat()
+      ];
+    }
+    switch (typeof idOrFilter) {
+      case "string": {
+        const parts = idOrFilter.split(":");
+        const first = (0, import_assert6.assertEx)(parts.shift(), () => "Missing first part");
+        const firstInstance = (0, import_hex3.isAddress)(first) ? await (0, import_module_model5.resolveAddressToInstance)(this, first, void 0, [], options.direction) : this._roots?.find((mod) => mod.id === first);
+        return parts.length === 0 ? firstInstance : firstInstance?.resolve(parts.join(":"), options);
+      }
+      case "object": {
+        const results = [];
+        if ((0, import_module_model5.isAddressModuleFilter)(idOrFilter)) {
+          for (const mod of workingSet) {
+            if (mod.modName && idOrFilter.address.includes(mod.address)) results.push(mod);
+          }
+        }
+        return results;
+      }
+      default: {
+        return;
+      }
+    }
+  }
+  async startHandler() {
+    this.busHost()?.start();
+    return await super.startHandler();
+  }
+  async unexposeHandler(id, options) {
+    const { maxDepth = 2, required = true } = options ?? {};
+    const host = (0, import_assert6.assertEx)(this.busHost(), () => "Not configured as a host");
+    const module2 = await host.unexpose(id, required);
+    if (module2) {
+      const children = maxDepth > 0 ? await module2.publicChildren?.() ?? [] : [];
+      const exposedChildren = (await Promise.all(children.map((child) => this.unexposeHandler(child.address, {
+        maxDepth: maxDepth - 1,
+        required: false
+      })))).flat().filter(import_exists2.exists);
+      return [
+        module2,
+        ...exposedChildren
+      ];
+    }
+    return [];
+  }
+  busClient() {
+    if (!this._busClient && this.config.client) {
+      this._busClient = new AsyncQueryBusClient({
+        config: this.config.client,
+        logger: this.logger,
+        rootModule: this
+      });
+    }
+    return this._busClient;
+  }
+  busHost() {
+    if (!this._busHost && this.config.host) {
+      this._busHost = new AsyncQueryBusHost({
+        config: this.config.host,
+        logger: this.logger,
+        onQueryFulfillFinished: /* @__PURE__ */ __name((args) => {
+          if (this.archiving && this.isAllowedArchivingQuery(args.query.schema)) {
+            (0, import_forget3.forget)(this.storeToArchivists(args.result?.flat() ?? []));
+          }
+          (0, import_forget3.forget)(this.emit("queryFulfillFinished", {
+            module: this,
+            ...args
+          }));
+        }, "onQueryFulfillFinished"),
+        onQueryFulfillStarted: /* @__PURE__ */ __name((args) => {
+          if (this.archiving && this.isAllowedArchivingQuery(args.query.schema)) {
+            (0, import_forget3.forget)(this.storeToArchivists([
+              args.query,
+              ...args.payloads ?? []
+            ]));
+          }
+          (0, import_forget3.forget)(this.emit("queryFulfillStarted", {
+            module: this,
+            ...args
+          }));
+        }, "onQueryFulfillStarted"),
+        rootModule: this
+      });
+    }
+    return this._busHost;
+  }
+  async connectInstance(instance, maxDepth = 5) {
+    if (instance) {
+      this.downResolver.add(instance);
+      if (maxDepth > 0) {
+        const node = (0, import_node_model.asNodeInstance)(instance);
+        if (node) {
+          const state = await node.state();
+          const children = (state?.filter((0, import_payload_model.isPayloadOfSchemaType)(import_module_model5.AddressSchema)).map((s) => s.address) ?? []).filter((a) => a !== instance.address);
+          await Promise.all(children.map((child) => this.connect(child, maxDepth - 1)));
+        }
+      }
+      this.logger?.log(`Connect: ${instance.id}`);
+      return instance.address;
+    }
+  }
+  stopHandler(_timeout) {
+    this.busHost()?.stop();
+    return true;
+  }
+};
+PubSubBridge = _ts_decorate([
+  (0, import_module_model5.creatableModule)()
+], PubSubBridge);
 //# sourceMappingURL=index.cjs.map