@hashgraphonline/standards-sdk 0.1.144 → 0.1.146

package/dist/es/standards-sdk.es47.js

@@ -1,464 +1,409 @@
-import { HCS } from "./standards-sdk.es3.js";
-import { isSSREnvironment } from "./standards-sdk.es118.js";
-class ResourceManager {
-  constructor(networkType, logger, hcs, options = {}) {
-    this.cache = /* @__PURE__ */ new Map();
-    this.currentCacheSize = 0;
-    this.supportedImageTypes = /* @__PURE__ */ new Set([
-      "image/png",
-      "image/jpeg",
-      "image/jpg",
-      "image/gif",
-      "image/svg+xml",
-      "image/webp"
-    ]);
-    this.dangerousJSPatterns = [
-      /eval\s*\(/g,
-      /Function\s*\(/g,
-      /setTimeout\s*\(\s*["'].*["']/g,
-      /setInterval\s*\(\s*["'].*["']/g,
-      /document\.write/g,
-      /innerHTML\s*=/g,
-      /outerHTML\s*=/g
-    ];
-    this.dangerousCSSPatterns = [
-      /javascript\s*:/gi,
-      /@import.*url\s*\(\s*["']?javascript:/gi,
-      /expression\s*\(/gi,
-      /behavior\s*:/gi
-    ];
+class BlockStateManager {
+  constructor(logger) {
+    this.blockStates = /* @__PURE__ */ new Map();
+    this.stateListeners = /* @__PURE__ */ new Map();
+    this.messageHandlers = /* @__PURE__ */ new Map();
+    this.schemas = /* @__PURE__ */ new Map();
+    this.persistentBlocks = /* @__PURE__ */ new Set();
+    this.unusedBlocks = /* @__PURE__ */ new Set();
+    this.maxBlockStates = 1e3;
     this.logger = logger;
-    this.hcs = hcs || new HCS();
-    this.options = {
-      cacheTTL: options.cacheTTL || 3e5,
-      maxCacheSize: options.maxCacheSize || 50 * 1024 * 1024,
-      maxResourceSize: options.maxResourceSize || 5 * 1024 * 1024
-    };
   }
   /**
-   * Load CSS resource from HCS-3
+   * Create isolated state for a block instance
    */
-  async loadCSS(topicId) {
-    this.logger.debug("Loading CSS resource", { topicId });
-    try {
-      const resource = await this.loadResource(topicId);
-      if (resource.contentType !== "text/css") {
-        throw new Error(`Expected CSS resource, got ${resource.contentType}`);
+  createBlockState(blockId, initialState) {
+    this.logger.debug("Creating block state", { blockId });
+    if (this.schemas.has(blockId)) {
+      this.validateState(blockId, initialState);
+    }
+    while (this.blockStates.size >= this.maxBlockStates) {
+      if (this.unusedBlocks.size > 0) {
+        this.cleanupUnusedStates();
+      } else {
+        this.evictOldestBlock();
       }
-      const content = resource.content;
-      const sanitized = this.sanitizeCSS(content);
-      this.logger.debug("CSS resource loaded successfully", {
-        topicId,
-        size: content.length,
-        sanitized: sanitized.length !== content.length
-      });
-      return sanitized;
-    } catch (error) {
-      this.logger.error("Failed to load CSS resource", { topicId, error });
-      throw new Error(
-        `Failed to load CSS resource: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
     }
+    this.blockStates.set(blockId, { ...initialState });
+    this.logger.debug("Block state created", {
+      blockId,
+      stateKeys: Object.keys(initialState)
+    });
   }
   /**
-   * Load JavaScript resource from HCS-3
+   * Get current state for a block
    */
-  async loadJS(topicId) {
-    this.logger.debug("Loading JavaScript resource", { topicId });
-    try {
-      const resource = await this.loadResource(topicId);
-      if (!resource.contentType.includes("javascript") && !resource.contentType.includes("ecmascript")) {
-        throw new Error(
-          `Expected JavaScript resource, got ${resource.contentType}`
-        );
-      }
-      const content = resource.content;
-      if (content.length > this.options.maxResourceSize) {
-        throw new Error("JavaScript resource too large");
-      }
-      const sanitized = this.sanitizeJavaScript(content);
-      this.logger.debug("JavaScript resource loaded successfully", {
-        topicId,
-        size: content.length,
-        sanitized: sanitized.length !== content.length
-      });
-      return sanitized;
-    } catch (error) {
-      this.logger.error("Failed to load JavaScript resource", {
-        topicId,
-        error
-      });
-      throw new Error(
-        `Failed to load JavaScript resource: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
+  getBlockState(blockId) {
+    if (!this.blockStates.has(blockId)) {
+      return null;
     }
+    return { ...this.blockStates.get(blockId) };
   }
   /**
-   * Load image resource from HCS-3 as Blob
+   * Check if block state exists
    */
-  async loadImage(topicId) {
-    this.logger.debug("Loading image resource", { topicId });
-    try {
-      const resource = await this.loadResource(topicId);
-      if (!this.supportedImageTypes.has(resource.contentType)) {
-        throw new Error(`Unsupported image format: ${resource.contentType}`);
+  hasBlockState(blockId) {
+    return this.blockStates.has(blockId);
+  }
+  /**
+   * Update block state and emit events
+   */
+  updateBlockState(blockId, updates) {
+    if (!this.blockStates.has(blockId)) {
+      throw new Error(`Block state not found: ${blockId}`);
+    }
+    const oldState = { ...this.blockStates.get(blockId) };
+    const newState = { ...oldState, ...updates };
+    if (this.schemas.has(blockId)) {
+      this.validateState(blockId, newState);
+    }
+    this.blockStates.set(blockId, newState);
+    const listeners = this.stateListeners.get(blockId) || [];
+    for (const listener of listeners) {
+      try {
+        listener(newState, oldState, blockId);
+      } catch (error) {
+        this.logger.error("State change listener error", { blockId, error });
       }
-      const content = resource.content;
-      const view = new Uint8Array(content);
-      const blob = new Blob([view.buffer], { type: resource.contentType });
-      this.logger.debug("Image resource loaded successfully", {
-        topicId,
-        size: content.length,
-        type: resource.contentType
-      });
-      return blob;
-    } catch (error) {
-      this.logger.error("Failed to load image resource", { topicId, error });
-      throw new Error(
-        `Failed to load image resource: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
     }
+    this.logger.debug("Block state updated", { blockId, updates });
   }
   /**
-   * Load template resource from HCS-3
+   * Destroy block state and cleanup
    */
-  async loadTemplate(topicId) {
-    this.logger.debug("Loading template resource", { topicId });
-    try {
-      const resource = await this.loadResource(topicId);
-      const content = resource.content;
-      this.validateTemplateSyntax(content);
-      const sanitized = this.sanitizeTemplate(content);
-      this.logger.debug("Template resource loaded successfully", {
-        topicId,
-        size: content.length
-      });
-      return sanitized;
-    } catch (error) {
-      this.logger.error("Failed to load template resource", { topicId, error });
-      throw new Error(
-        `Failed to load template resource: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
+  destroyBlockState(blockId) {
+    this.logger.debug("Destroying block state", { blockId });
+    this.blockStates.delete(blockId);
+    this.stateListeners.delete(blockId);
+    this.messageHandlers.delete(blockId);
+    this.schemas.delete(blockId);
+    this.persistentBlocks.delete(blockId);
+    this.unusedBlocks.delete(blockId);
+    this.logger.debug("Block state destroyed", { blockId });
+  }
+  /**
+   * Listen for state changes on a block
+   */
+  onStateChange(blockId, listener) {
+    if (!this.stateListeners.has(blockId)) {
+      this.stateListeners.set(blockId, []);
     }
+    this.stateListeners.get(blockId).push(listener);
   }
   /**
-   * Load resource with integrity verification
+   * Remove state change listener
    */
-  async loadWithIntegrityCheck(topicId, expectedHash) {
-    this.logger.debug("Loading resource with integrity check", {
-      topicId,
-      expectedHash
-    });
-    try {
-      const resource = await this.loadResource(topicId);
-      const verified = await this.verifyIntegrity(
-        resource.content,
-        expectedHash
-      );
-      if (!verified) {
-        throw new Error("Resource integrity verification failed");
+  removeStateChangeListener(blockId, listener) {
+    const listeners = this.stateListeners.get(blockId);
+    if (listeners) {
+      const index = listeners.indexOf(listener);
+      if (index > -1) {
+        listeners.splice(index, 1);
       }
-      this.logger.debug("Resource integrity verified", { topicId });
-      return {
-        content: resource.content,
-        verified,
-        contentType: resource.contentType
-      };
-    } catch (error) {
-      this.logger.error("Resource integrity check failed", { topicId, error });
-      throw error;
     }
   }
   /**
-   * Verify content integrity using SHA-256 hash
+   * Listen for messages sent to a block
    */
-  async verifyIntegrity(content, expectedHash) {
-    try {
-      if (isSSREnvironment()) {
-        this.logger.warn("Integrity verification skipped in SSR environment");
-        return true;
+  onBlockMessage(blockId, handler) {
+    if (!this.messageHandlers.has(blockId)) {
+      this.messageHandlers.set(blockId, []);
+    }
+    this.messageHandlers.get(blockId).push(handler);
+  }
+  /**
+   * Send message from one block to another
+   */
+  sendBlockMessage(fromBlock, toBlock, type, payload) {
+    const message = {
+      type,
+      payload,
+      fromBlock,
+      toBlock
+    };
+    const handlers = this.messageHandlers.get(toBlock) || [];
+    for (const handler of handlers) {
+      try {
+        handler(message);
+      } catch (error) {
+        this.logger.error("Block message handler error", {
+          fromBlock,
+          toBlock,
+          type,
+          error
+        });
       }
-      if (typeof crypto === "undefined" || !crypto.subtle) {
-        this.logger.warn(
-          "WebCrypto not available, skipping integrity verification"
-        );
-        return true;
+    }
+    this.logger.debug("Block message sent", { fromBlock, toBlock, type });
+  }
+  /**
+   * Broadcast message to all blocks
+   */
+  broadcastMessage(type, payload) {
+    for (const blockId of this.blockStates.keys()) {
+      const handlers = this.messageHandlers.get(blockId) || [];
+      const message = {
+        type,
+        payload,
+        fromBlock: "system",
+        toBlock: blockId
+      };
+      for (const handler of handlers) {
+        try {
+          handler(message);
+        } catch (error) {
+          this.logger.error("Broadcast message handler error", {
+            blockId,
+            type,
+            error
+          });
+        }
       }
-      const buffer = typeof content === "string" ? new TextEncoder().encode(content) : content;
-      const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-      const copy = new Uint8Array(bytes);
-      const hashBuffer = await crypto.subtle.digest("SHA-256", copy.buffer);
-      const hashArray = Array.from(new Uint8Array(hashBuffer));
-      const actualHash = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-      return actualHash === expectedHash.toLowerCase();
-    } catch (error) {
-      this.logger.error("Error verifying integrity", { error });
-      return false;
     }
+    this.logger.debug("Message broadcasted", {
+      type,
+      blockCount: this.blockStates.size
+    });
   }
   /**
-   * Load multiple dependencies in correct order
+   * Bind action result to block state
    */
-  async loadDependencies(dependencies) {
-    this.logger.debug("Loading dependencies", { count: dependencies.length });
+  async bindActionResult(blockId, actionName, result, binding) {
+    if (!this.blockStates.has(blockId)) {
+      throw new Error(`Block state not found: ${blockId}`);
+    }
+    const currentState = this.getBlockState(blockId);
+    let newState;
     try {
-      this.detectCircularDependencies(dependencies);
-      const sorted = this.topologicalSort(dependencies);
-      const results = [];
-      for (const dep of sorted) {
-        let content;
-        switch (dep.type) {
-          case "css":
-            content = await this.loadCSS(dep.topicId);
-            break;
-          case "js":
-            content = await this.loadJS(dep.topicId);
-            break;
-          case "template":
-            content = await this.loadTemplate(dep.topicId);
-            break;
-          case "image":
-            const blob = await this.loadImage(dep.topicId);
-            content = new Uint8Array(await blob.arrayBuffer());
-            break;
-          default:
-            throw new Error(`Unsupported dependency type: ${dep.type}`);
-        }
-        results.push({
-          topicId: dep.topicId,
-          content,
-          contentType: this.getContentTypeForType(dep.type),
-          type: dep.type
-        });
+      if (result.success && binding.onSuccess) {
+        newState = binding.onSuccess(currentState, result);
+      } else if (!result.success && binding.onError) {
+        newState = binding.onError(currentState, result);
+      } else {
+        return;
       }
-      this.logger.debug("Dependencies loaded successfully", {
-        count: results.length
+      if (newState) {
+        this.updateBlockState(blockId, newState);
+      }
+      this.logger.debug("Action result bound to state", {
+        blockId,
+        actionName,
+        success: result.success
       });
-      return results;
     } catch (error) {
-      this.logger.error("Failed to load dependencies", { error });
+      this.logger.error("Action result binding failed", {
+        blockId,
+        actionName,
+        error
+      });
       throw error;
     }
   }
   /**
-   * Clear resource cache
+   * Persist block state to storage
    */
-  clearCache() {
-    this.cache.clear();
-    this.currentCacheSize = 0;
-    this.logger.debug("Resource cache cleared");
+  async persistBlockState(blockId) {
+    if (!this.storageBackend) {
+      this.logger.warn("No storage backend configured");
+      this.persistentBlocks.add(blockId);
+      return;
+    }
+    if (!this.blockStates.has(blockId)) {
+      throw new Error(`Block state not found: ${blockId}`);
+    }
+    try {
+      const state = this.blockStates.get(blockId);
+      await this.storageBackend.setItem(blockId, JSON.stringify(state));
+      this.persistentBlocks.add(blockId);
+      this.logger.debug("Block state persisted", { blockId });
+    } catch (error) {
+      this.logger.error("Failed to persist block state", { blockId, error });
+    }
   }
   /**
-   * Get current cache size for testing
+   * Restore block state from storage
    */
-  getCacheSize() {
-    return this.currentCacheSize;
+  async restoreBlockState(blockId) {
+    if (!this.storageBackend) {
+      this.logger.warn("No storage backend configured");
+      return;
+    }
+    try {
+      const stored = await this.storageBackend.getItem(blockId);
+      if (stored) {
+        const state = JSON.parse(stored);
+        this.blockStates.set(blockId, state);
+        this.persistentBlocks.add(blockId);
+        this.logger.debug("Block state restored", { blockId });
+      }
+    } catch (error) {
+      this.logger.error("Failed to restore block state", { blockId, error });
+    }
   }
   /**
-   * Load resource with caching
+   * Check if block state is persistent
    */
-  async loadResource(topicId) {
-    const cached = this.getFromCache(topicId);
-    if (cached) {
-      this.logger.debug("Resource loaded from cache", { topicId });
-      return cached;
-    }
-    const blob = await this.hcs.retrieveHCS1Data(topicId);
-    const contentType = blob.type || "application/octet-stream";
-    let content;
-    if (contentType.startsWith("text/") || contentType.includes("javascript") || contentType.includes("json")) {
-      content = await blob.text();
-    } else {
-      content = new Uint8Array(await blob.arrayBuffer());
-    }
-    const resource = {
-      content,
-      contentType,
-      size: blob.size
-    };
-    this.addToCache(topicId, resource);
-    return resource;
+  isPersistent(blockId) {
+    return this.persistentBlocks.has(blockId);
   }
   /**
-   * Get resource from cache if valid
+   * Set storage backend
    */
-  getFromCache(topicId) {
-    const entry = this.cache.get(topicId);
-    if (!entry) return null;
-    if (Date.now() - entry.timestamp > this.options.cacheTTL) {
-      this.removeFromCache(topicId);
-      return null;
-    }
-    return entry.data;
+  setStorageBackend(backend) {
+    this.storageBackend = backend;
   }
   /**
-   * Add resource to cache with size management
+   * Set validation schema for a block
    */
-  addToCache(topicId, resource) {
-    const size = typeof resource.content === "string" ? resource.content.length : resource.content.byteLength;
-    if (size > this.options.maxCacheSize / 2) {
-      this.logger.warn("Resource too large for cache", { topicId, size });
-      return;
-    }
-    while (this.currentCacheSize + size > this.options.maxCacheSize && this.cache.size > 0) {
-      this.evictOldestEntry();
-    }
-    const entry = {
-      data: resource,
-      timestamp: Date.now(),
-      size
-    };
-    this.cache.set(topicId, entry);
-    this.currentCacheSize += size;
-    this.logger.debug("Resource added to cache", {
-      topicId,
-      size,
-      totalCacheSize: this.currentCacheSize
-    });
+  setBlockStateSchema(blockId, schema) {
+    this.schemas.set(blockId, schema);
+    this.logger.debug("Block state schema set", { blockId });
   }
   /**
-   * Remove resource from cache
+   * Set maximum number of block states
    */
-  removeFromCache(topicId) {
-    const entry = this.cache.get(topicId);
-    if (entry) {
-      this.cache.delete(topicId);
-      this.currentCacheSize -= entry.size;
-    }
+  setMaxBlockStates(max) {
+    this.maxBlockStates = max;
   }
   /**
-   * Evict oldest cache entry
+   * Get active block count
    */
-  evictOldestEntry() {
-    let oldest = null;
-    let oldestTime = Date.now();
-    for (const [topicId, entry] of this.cache) {
-      if (entry.timestamp < oldestTime) {
-        oldestTime = entry.timestamp;
-        oldest = topicId;
-      }
-    }
-    if (oldest) {
-      this.removeFromCache(oldest);
-      this.logger.debug("Evicted oldest cache entry", { topicId: oldest });
-    }
+  getActiveBlockCount() {
+    return this.blockStates.size;
   }
   /**
-   * Sanitize CSS content
+   * Mark block as unused for cleanup
    */
-  sanitizeCSS(css) {
-    let sanitized = css;
-    for (const pattern of this.dangerousCSSPatterns) {
-      sanitized = sanitized.replace(pattern, "");
-    }
-    return sanitized;
+  markBlockUnused(blockId) {
+    this.unusedBlocks.add(blockId);
   }
   /**
-   * Sanitize JavaScript content
+   * Clean up unused block states
    */
-  sanitizeJavaScript(js) {
-    let sanitized = js;
-    for (const pattern of this.dangerousJSPatterns) {
-      sanitized = sanitized.replace(pattern, "");
+  cleanupUnusedStates() {
+    for (const blockId of this.unusedBlocks) {
+      this.destroyBlockState(blockId);
     }
-    return sanitized;
+    this.unusedBlocks.clear();
+    this.logger.debug("Unused states cleaned up");
   }
   /**
-   * Sanitize template content
+   * Evict oldest non-persistent block to make room
    */
-  sanitizeTemplate(template) {
-    return template.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "").replace(/on\w+\s*=\s*["'][^"']*["']/gi, "").replace(/javascript\s*:/gi, "");
+  evictOldestBlock() {
+    for (const blockId of this.blockStates.keys()) {
+      if (!this.persistentBlocks.has(blockId)) {
+        this.destroyBlockState(blockId);
+        this.logger.debug("Evicted block to make room", { blockId });
+        return;
+      }
+    }
+    this.logger.warn("Cannot evict blocks - all are persistent");
   }
   /**
-   * Validate template syntax
+   * Get listener count for a block (for testing)
    */
-  validateTemplateSyntax(template) {
-    const openBraces = (template.match(/\{\{/g) || []).length;
-    const closeBraces = (template.match(/\}\}/g) || []).length;
-    if (openBraces !== closeBraces) {
-      throw new Error("Invalid template syntax: unmatched braces");
-    }
-    const openBlocks = (template.match(/\{\{#\w+/g) || []).length;
-    const closeBlocks = (template.match(/\{\{\/\w+/g) || []).length;
-    if (openBlocks !== closeBlocks) {
-      throw new Error("Invalid template syntax: unclosed block helpers");
-    }
+  getListenerCount(blockId) {
+    const stateListeners = this.stateListeners.get(blockId)?.length || 0;
+    const messageHandlers = this.messageHandlers.get(blockId)?.length || 0;
+    return stateListeners + messageHandlers;
   }
   /**
-   * Detect circular dependencies
+   * Validate state against schema
    */
-  detectCircularDependencies(dependencies) {
-    const dependencyMap = /* @__PURE__ */ new Map();
-    for (const dep of dependencies) {
-      dependencyMap.set(dep.topicId, dep.depends || []);
-    }
-    const visited = /* @__PURE__ */ new Set();
-    const visiting = /* @__PURE__ */ new Set();
-    const visit = (topicId) => {
-      if (visiting.has(topicId)) {
-        throw new Error("Circular dependency detected");
+  validateState(blockId, state) {
+    const schema = this.schemas.get(blockId);
+    if (!schema) return;
+    if (schema.type === "object") {
+      if (typeof state !== "object" || state === null) {
+        throw new Error("State validation failed: expected object");
       }
-      if (visited.has(topicId)) return;
-      visiting.add(topicId);
-      const deps = dependencyMap.get(topicId) || [];
-      for (const dep of deps) {
-        visit(dep);
+      if (schema.required) {
+        for (const prop of schema.required) {
+          if (!(prop in state)) {
+            throw new Error(
+              `State validation failed: missing required property '${prop}'`
+            );
+          }
+        }
+      }
+      if (schema.properties) {
+        for (const [prop, propSchema] of Object.entries(schema.properties)) {
+          if (prop in state) {
+            const value = state[prop];
+            const expectedType = propSchema.type;
+            if (expectedType === "string" && typeof value !== "string") {
+              throw new Error(
+                `State validation failed: property '${prop}' must be string`
+              );
+            }
+            if (expectedType === "number" && typeof value !== "number") {
+              throw new Error(
+                `State validation failed: property '${prop}' must be number`
+              );
+            }
+            if (expectedType === "number" && propSchema.minimum !== void 0) {
+              if (value < propSchema.minimum) {
+                throw new Error(
+                  `State validation failed: property '${prop}' below minimum`
+                );
+              }
+            }
+          }
+        }
       }
-      visiting.delete(topicId);
-      visited.add(topicId);
-    };
-    for (const dep of dependencies) {
-      visit(dep.topicId);
     }
   }
   /**
-   * Topological sort of dependencies
+   * Set block state (alias for updateBlockState)
    */
-  topologicalSort(dependencies) {
-    const dependencyMap = /* @__PURE__ */ new Map();
-    const dependsMap = /* @__PURE__ */ new Map();
-    for (const dep of dependencies) {
-      dependencyMap.set(dep.topicId, dep);
-      dependsMap.set(dep.topicId, dep.depends || []);
+  setBlockState(blockId, state) {
+    if (!this.blockStates.has(blockId)) {
+      this.createBlockState(blockId, state);
+    } else {
+      this.updateBlockState(blockId, state);
     }
-    const sorted = [];
-    const visited = /* @__PURE__ */ new Set();
-    const visit = (topicId) => {
-      if (visited.has(topicId)) return;
-      const deps = dependsMap.get(topicId) || [];
-      for (const dep of deps) {
-        visit(dep);
-      }
-      visited.add(topicId);
-      const depObj = dependencyMap.get(topicId);
-      if (depObj) {
-        sorted.push(depObj);
-      }
-    };
-    for (const dep of dependencies) {
-      visit(dep.topicId);
+  }
+  /**
+   * Remove block state
+   */
+  removeBlockState(blockId) {
+    this.blockStates.delete(blockId);
+    this.stateListeners.delete(blockId);
+    this.messageHandlers.delete(blockId);
+    this.persistentBlocks.delete(blockId);
+    this.schemas.delete(blockId);
+    if (this.storageBackend) {
+      this.storageBackend.removeItem(blockId).catch((error) => {
+        this.logger.error("Failed to remove persisted state", {
+          blockId,
+          error
+        });
+      });
     }
-    return sorted;
+    this.logger.debug("Block state removed", { blockId });
   }
   /**
-   * Get content type for dependency type
+   * Send message to a block
    */
-  getContentTypeForType(type) {
-    switch (type) {
-      case "css":
-        return "text/css";
-      case "js":
-        return "application/javascript";
-      case "template":
-        return "text/html";
-      case "image":
-        return "image/*";
-      default:
-        return "application/octet-stream";
+  sendMessage(blockId, type, data, fromBlock = "system") {
+    const handlers = this.messageHandlers.get(blockId) || [];
+    const message = {
+      type,
+      payload: data,
+      fromBlock,
+      toBlock: blockId
+    };
+    for (const handler of handlers) {
+      try {
+        handler(message);
+      } catch (error) {
+        this.logger.error("Message handler error", { blockId, type, error });
+      }
     }
   }
 }
 export {
-  ResourceManager
+  BlockStateManager
 };
 //# sourceMappingURL=standards-sdk.es47.js.map