@wirestate/core 0.6.0

package/cjs/development/lib.js

@@ -0,0 +1,1007 @@
+'use strict';
+
+var inversify = require('inversify');
+var tslib = require('tslib');
+
+var ERROR_CODE_GENERIC = 1;
+var ERROR_CODE_INVALID_ARGUMENTS = 51;
+var ERROR_CODE_BINDING_SCOPE = 52;
+var ERROR_CODE_FAILED_TO_RESOLVE_QUERY_HANDLER = 101;
+var ERROR_CODE_FAILED_TO_RESOLVE_COMMAND_HANDLER = 102;
+var ERROR_CODE_ACCESS_BEFORE_ACTIVATION = 200;
+var ERROR_CODE_ACCESS_AFTER_DISPOSAL = 201;
+
+/**
+ * A custom error class that contains generic error information for Wirestate-related issues.
+ *
+ * This class extends the native `Error` class and is used to represent errors specific
+ * to the Wirestate library, providing more structured error handling.
+ */
+var WirestateError = /** @class */function (_super) {
+  tslib.__extends(WirestateError, _super);
+  function WirestateError(code, detail) {
+    if (code === void 0) {
+      code = ERROR_CODE_GENERIC;
+    }
+    var _this = _super.call(this) || this;
+    /**
+     * Name or error class to help differentiate error class in minified environments.
+     */
+    _this.name = "WirestateError";
+    _this.code = code;
+    _this.message = detail || "Wirestate error.";
+    return _this;
+  }
+  return WirestateError;
+}(Error);
+
+/**
+ * Binds a constant value to a token in the container.
+ *
+ * @param container - target Inversify container
+ * @param entry - entry descriptor to bind
+ */
+function bindConstant(container, entry) {
+  if (entry.scopeBindingType && entry.scopeBindingType !== inversify.bindingScopeValues.Singleton) {
+    throw new WirestateError(ERROR_CODE_BINDING_SCOPE, "Provided unexpected binding scope for constant value.");
+  }
+  container.bind(entry.id).toConstantValue(entry.value);
+}
+
+/**
+ * Binds a constant value to a token in the container.
+ *
+ * @param container - target Inversify container
+ * @param entry - descriptor of entry to bind
+ */
+function bindDynamicValue(container, entry) {
+  var binding = container.bind(entry.id).toDynamicValue(function () {
+    if (entry.factory) {
+      return entry.factory();
+    }
+    return entry.value;
+  });
+  if (!entry.scopeBindingType) {
+    return;
+  } else if (entry.scopeBindingType === inversify.bindingScopeValues.Transient) {
+    binding.inTransientScope();
+  } else if (entry.scopeBindingType === inversify.bindingScopeValues.Request) {
+    binding.inRequestScope();
+  } else {
+    binding.inSingletonScope();
+  }
+}
+
+/**
+ * Command execution status.
+ */
+exports.ECommandStatus = void 0;
+(function (ECommandStatus) {
+  ECommandStatus["PENDING"] = "pending";
+  ECommandStatus["SETTLED"] = "settled";
+  ECommandStatus["ERROR"] = "error";
+})(exports.ECommandStatus || (exports.ECommandStatus = {}));
+
+/**
+ * Dispatches commands to handlers.
+ *
+ * Unlike queries, command execution always wraps the handler in a promise
+ * and returns a descriptor with task, status, and responder.
+ */
+var CommandBus = /** @class */function () {
+  function CommandBus() {
+    /**
+     * Internal handler storage.
+     * Uses a stack for each command type to support shadowing.
+     */
+    this.handlers = new Map();
+  }
+  /**
+   * Registers a command handler.
+   * Returns an unregister function.
+   *
+   * @param type - command type
+   * @param handler - handler function
+   * @returns unregister function
+   */
+  CommandBus.prototype.register = function (type, handler) {
+    var _this = this;
+    var stack = this.handlers.get(type);
+    if (!stack) {
+      stack = [];
+      this.handlers.set(type, stack);
+    }
+    stack.push(handler);
+    return function () {
+      var current = _this.handlers.get(type);
+      if (!current) {
+        return;
+      }
+      var index = current.indexOf(handler);
+      if (index >= 0) {
+        current.splice(index, 1);
+      }
+      // Clean empty stacks.
+      if (current.length === 0) {
+        _this.handlers.delete(type);
+      }
+    };
+  };
+  /**
+   * Dispatches a command to the last registered handler.
+   * Wraps the handler execution in a promise and returns a descriptor.
+   *
+   * @param type - command type
+   * @param data - command payload
+   * @returns command descriptor with task, status, and responder
+   *
+   * @throws if no handler is registered
+   */
+  CommandBus.prototype.command = function (type, data) {
+    var stack = this.handlers.get(type);
+    if (!(stack === null || stack === void 0 ? void 0 : stack.length)) {
+      throw new WirestateError(ERROR_CODE_FAILED_TO_RESOLVE_COMMAND_HANDLER, "No command handler registered in container for type: '".concat(String(type), "'."));
+    }
+    var handler = stack[stack.length - 1];
+    var descriptor = {
+      task: null,
+      status: exports.ECommandStatus.PENDING
+    };
+    descriptor.task = Promise.resolve().then(function () {
+      return handler(data);
+    }).then(function (result) {
+      descriptor.status = exports.ECommandStatus.SETTLED;
+      return result;
+    }).catch(function (error) {
+      descriptor.status = exports.ECommandStatus.ERROR;
+      throw error;
+    });
+    return descriptor;
+  };
+  /**
+   * Dispatches a command to the last registered handler, returning null if no handler exists.
+   *
+   * @param type - command type
+   * @param data - command payload
+   * @returns command descriptor or null if no handler is registered
+   */
+  CommandBus.prototype.commandOptional = function (type, data) {
+    var stack = this.handlers.get(type);
+    return (stack === null || stack === void 0 ? void 0 : stack.length) ? this.command(type, data) : null;
+  };
+  /**
+   * Checks if a handler is registered for the given type.
+   *
+   * @param type - command type
+   * @returns true if handler exists
+   */
+  CommandBus.prototype.has = function (type) {
+    var _a;
+    return Boolean((_a = this.handlers.get(type)) === null || _a === void 0 ? void 0 : _a.length);
+  };
+  /**
+   * Removes all registered handlers.
+   */
+  CommandBus.prototype.clear = function () {
+    this.handlers.clear();
+  };
+  return CommandBus;
+}();
+
+/**
+ * Token for the container-scoped seeds map.
+ */
+var SEEDS_TOKEN = Symbol("@wirestate/seeds");
+/**
+ * Token for the container-scoped shared seed object.
+ */
+var SEED_TOKEN = Symbol("@wirestate/seed");
+/**
+ * Map of class constructors to their declared query handlers.
+ * Inherited via a prototype chain at resolve time.
+ */
+var QUERY_HANDLER_METADATA = new WeakMap();
+/**
+ * Map of class constructors to their declared command handlers.
+ * Inherited via a prototype chain at resolve time.
+ */
+var COMMAND_HANDLER_METADATA = new WeakMap();
+/**
+ * Map of class constructors to their `@OnActivated`-decorated method names.
+ * Inherited via a prototype chain at resolve time.
+ */
+var ACTIVATED_HANDLER_METADATA = new WeakMap();
+/**
+ * Map of class constructors to their `@OnDeactivation`-decorated method names.
+ * Inherited via a prototype chain at resolve time.
+ */
+var DEACTIVATION_HANDLER_METADATA = new WeakMap();
+/**
+ * Map of class constructors for their declared event handlers.
+ * Inherited via a prototype chain at resolve time.
+ */
+var EVENT_HANDLER_METADATA = new WeakMap();
+/**
+ * Private storage for service-to-container references.
+ */
+var CONTAINER_REFS_BY_SERVICE = new WeakMap();
+/**
+ * Private storage for injected WireScope instances per service.
+ */
+var WIRE_SCOPES_BY_SERVICE = new WeakMap();
+/**
+ * Private storage for service event unsubscribers.
+ */
+var EVENT_UNSUBSCRIBERS_BY_SERVICE = new WeakMap();
+/**
+ * Private storage for service query unregisters.
+ */
+var QUERY_UNREGISTERS_BY_SERVICE = new WeakMap();
+/**
+ * Private storage for service command unregisters.
+ */
+var COMMAND_UNREGISTERS_BY_SERVICE = new WeakMap();
+
+/**
+ * Retrieves `@OnCommand` metadata from the class hierarchy.
+ * Returns handlers ordered from base to derived class.
+ *
+ * @param instance - service instance
+ * @returns metadata list
+ * @internal
+ */
+function getCommandHandlerMetadata(instance) {
+  var constructor = instance.constructor;
+  var chain = [];
+  // Traverse prototype chain up to Object/Function
+  while (typeof constructor === "function" && constructor !== Object && constructor !== Function.prototype) {
+    var own = COMMAND_HANDLER_METADATA.get(constructor);
+    if (own && own.length > 0) {
+      chain.push(own);
+    }
+    constructor = Object.getPrototypeOf(constructor);
+  }
+  // Reverse to ensure parent-first execution order.
+  return chain.reverse().flat();
+}
+
+/**
+ * Dispatches events to subscribers.
+ */
+var EventBus = /** @class */function () {
+  function EventBus() {
+    this.handlers = new Set();
+  }
+  /**
+   * Broadcasts an event to all subscribers.
+   *
+   * @param event - event to emit
+   */
+  EventBus.prototype.emit = function (event) {
+    // Snapshot prevents concurrent modification errors if handlers sub/unsub during emit.
+    var snapshot = Array.from(this.handlers);
+    for (var _i = 0, snapshot_1 = snapshot; _i < snapshot_1.length; _i++) {
+      var handler = snapshot_1[_i];
+      try {
+        handler(event);
+      } catch (error) {
+        // Prevent one failing listener from stalling the entire bus.
+        console.error("[wirestate] Event handler threw:", error);
+      }
+    }
+  };
+  /**
+   * Subscribes a handler to all events.
+   * Returns an unsubscribe function.
+   *
+   * @param handler - event handler function
+   * @returns unsubscribe function
+   */
+  EventBus.prototype.subscribe = function (handler) {
+    var _this = this;
+    this.handlers.add(handler);
+    return function () {
+      _this.handlers.delete(handler);
+    };
+  };
+  /**
+   * Removes all registered handlers.
+   *
+   * @internal
+   */
+  EventBus.prototype.clear = function () {
+    this.handlers.clear();
+  };
+  return EventBus;
+}();
+
+/**
+ * Dispatches queries to handlers.
+ */
+var QueryBus = /** @class */function () {
+  function QueryBus() {
+    /**
+     * Internal handler storage.
+     * Uses a stack for each query type to support shadowing (e.g., component-level vs service-level).
+     */
+    this.handlers = new Map();
+  }
+  /**
+   * Registers a query handler.
+   * Returns an unregister function.
+   *
+   * @param type - query type
+   * @param handler - handler function
+   * @returns unregister function
+   */
+  QueryBus.prototype.register = function (type, handler) {
+    var _this = this;
+    var stack = this.handlers.get(type);
+    if (!stack) {
+      stack = [];
+      this.handlers.set(type, stack);
+    }
+    stack.push(handler);
+    return function () {
+      var current = _this.handlers.get(type);
+      if (!current) {
+        return;
+      }
+      var index = current.indexOf(handler);
+      if (index >= 0) {
+        current.splice(index, 1);
+      }
+      // Clean empty stacks.
+      if (current.length === 0) {
+        _this.handlers.delete(type);
+      }
+    };
+  };
+  /**
+   * Dispatches a query to the last registered handler.
+   *
+   * @param type - query type
+   * @param data - query payload
+   * @returns query result
+   *
+   * @throws if no handler is registered
+   */
+  QueryBus.prototype.query = function (type, data) {
+    var stack = this.handlers.get(type);
+    // Always use the top of the stack (most recent registration) if handlers are available.
+    if (stack === null || stack === void 0 ? void 0 : stack.length) {
+      return stack[stack.length - 1](data);
+    }
+    throw new WirestateError(ERROR_CODE_FAILED_TO_RESOLVE_QUERY_HANDLER, "No query handler registered in container for type: '".concat(String(type), "'."));
+  };
+  /**
+   * Dispatches a query to the last registered handler, returning null if no handler exists.
+   *
+   * @param type - query type
+   * @param data - query payload
+   * @returns query result or null if no handler is registered
+   */
+  QueryBus.prototype.queryOptional = function (type, data) {
+    var stack = this.handlers.get(type);
+    if (stack === null || stack === void 0 ? void 0 : stack.length) {
+      return stack[stack.length - 1](data);
+    }
+    return null;
+  };
+  /**
+   * Checks if a handler is registered for the given type.
+   *
+   * @param type - query type
+   * @returns true if handler exists
+   */
+  QueryBus.prototype.has = function (type) {
+    var stack = this.handlers.get(type);
+    return Boolean(stack && stack.length);
+  };
+  /**
+   * Removes all registered handlers.
+   *
+   * @internal
+   */
+  QueryBus.prototype.clear = function () {
+    this.handlers.clear();
+  };
+  return QueryBus;
+}();
+
+/**
+ * Injectable scope providing access to wirestate buses and seeds.
+ * Each injecting service receives its own instance (transient scope).
+ * The scope is activated and deactivated automatically alongside its owner service.
+ */
+var WireScope = /** @class */function () {
+  function WireScope(container) {
+    this.container = container;
+    /**
+     * Whether the scope was deactivated and disposed from the container.
+     */
+    this.isDisposed = false;
+  }
+  /**
+   * Access the IoC container.
+   * Available only for activated instances of scope.
+   *
+   * @returns active container
+   *
+   * @throws WirestateError if scope is not activated or already disposed
+   */
+  WireScope.prototype.getContainer = function () {
+    if (this.container) {
+      return this.container;
+    }
+    if (this.isDisposed) {
+      throw new WirestateError(ERROR_CODE_ACCESS_AFTER_DISPOSAL, "WireScope::container accessed after deactivation. Ensure service is properly disposed.");
+    } else {
+      throw new WirestateError(ERROR_CODE_ACCESS_BEFORE_ACTIVATION, "WireScope::container accessed before activation. " + "Ensure service is bound to container and is properly resolved.");
+    }
+  };
+  /**
+   * Resolves a sibling service or injected value.
+   * Use for lazy resolution or circular dependency breaking.
+   * Available only for activated containers.
+   *
+   * @param injectionId - injection identifier
+   * @returns resolved injection, service instance, or generic value
+   *
+   * @throws WirestateError if scope is not activated
+   */
+  WireScope.prototype.resolve = function (injectionId) {
+    return this.getContainer().get(injectionId);
+  };
+  /**
+   * Resolves a sibling service or injected value.
+   * Use for lazy resolution or circular dependency breaking.
+   * Available only for activated containers.
+   *
+   * @param injectionId - injection identifier
+   * @returns resolved injection, service instance, generic value, or null if it is not bound
+   *
+   * @throws WirestateError if scope is not activated
+   */
+  WireScope.prototype.resolveOptional = function (injectionId) {
+    var container = this.getContainer();
+    return container.isBound(injectionId) ? container.get(injectionId) : null;
+  };
+  /**
+   * Broadcasts an event.
+   * Available only for activated containers.
+   *
+   * @param type - type of event to emit
+   * @param payload - optional payload to send with the event
+   * @param from - optional sender of the event
+   *
+   * @throws WirestateError if scope is not activated
+   */
+  WireScope.prototype.emitEvent = function (type, payload, from) {
+    this.getContainer().get(EventBus).emit({
+      type: type,
+      payload: payload,
+      from: from === undefined ? this : from
+    });
+  };
+  /**
+   * Dispatches a query and returns the result.
+   * Available only for activated containers.
+   *
+   * @param type - query type
+   * @param data - query data
+   * @returns query result
+   *
+   * @throws WirestateError if scope is not activated
+   */
+  WireScope.prototype.queryData = function (type, data) {
+    return this.getContainer().get(QueryBus).query(type, data);
+  };
+  /**
+   * Dispatches a query and returns the result.
+   * Available only for activated containers.
+   *
+   * @param type - query type
+   * @param data - query data
+   * @returns query result or null if handler is not registered
+   */
+  WireScope.prototype.queryOptionalData = function (type, data) {
+    return this.getContainer().get(QueryBus).queryOptional(type, data);
+  };
+  /**
+   * Dispatches a command and returns the descriptor.
+   * Available only for activated containers.
+   *
+   * @param type - command type
+   * @param data - command data
+   * @returns command descriptor
+   *
+   * @throws WirestateError if scope is not activated
+   */
+  WireScope.prototype.executeCommand = function (type, data) {
+    return this.getContainer().get(CommandBus).command(type, data);
+  };
+  /**
+   * Dispatches a command and returns the descriptor.
+   * Available only for activated containers.
+   *
+   * @param type - command type
+   * @param data - command data
+   * @returns command descriptor or null if handler is not registered
+   */
+  WireScope.prototype.executeOptionalCommand = function (type, data) {
+    return this.getContainer().get(CommandBus).commandOptional(type, data);
+  };
+  /**
+   * Reads seed for the provided injection.
+   * Returns shared seed if parameters are not provided.
+   * Available only for activated containers.
+   *
+   * @param seed - lookup key
+   * @returns seed data or null if missing
+   *
+   * @throws WirestateError if context is not activated
+   */
+  WireScope.prototype.getSeed = function (seed) {
+    return seed ? this.getContainer().get(SEEDS_TOKEN).get(seed) || null : this.getContainer().get(SEED_TOKEN);
+  };
+  WireScope = tslib.__decorate([inversify.injectable(), tslib.__metadata("design:paramtypes", [Object])], WireScope);
+  return WireScope;
+}();
+
+/**
+ * Retrieves `@OnEvent` metadata from the class hierarchy.
+ * Returns handlers ordered from base to derived class.
+ *
+ * @param instance - service instance
+ * @returns metadata list
+ * @internal
+ */
+function getEventHandlerMetadata(instance) {
+  var constructor = instance.constructor;
+  var chain = [];
+  // Traverse prototype chain up to Object/Function
+  while (typeof constructor === "function" && constructor !== Object && constructor !== Function.prototype) {
+    var own = EVENT_HANDLER_METADATA.get(constructor);
+    if (own && own.length > 0) {
+      chain.push(own);
+    }
+    constructor = Object.getPrototypeOf(constructor);
+  }
+  // Reverse to ensure parent-first execution order
+  return chain.reverse().flat();
+}
+
+/**
+ * Composes service event handlers into a single dispatcher.
+ *
+ * @param instance - service instance
+ * @returns event handler or null if no handlers are declared
+ * @internal
+ */
+function buildEventDispatcher(instance) {
+  var entries = [];
+  // Register methods decorated with @OnEvent.
+  for (var _i = 0, _a = getEventHandlerMetadata(instance); _i < _a.length; _i++) {
+    var meta = _a[_i];
+    var method = instance[meta.methodName];
+    if (typeof method === "function") {
+      entries.push({
+        types: meta.types,
+        handler: method.bind(instance)
+      });
+    }
+  }
+  if (entries.length) {
+    return function (event) {
+      // Fan out events to all matching handlers.
+      for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+        var entry = entries_1[_i];
+        if (entry.types === null || entry.types.includes(event.type)) {
+          entry.handler(event);
+        }
+      }
+    };
+  } else {
+    return null;
+  }
+}
+
+/**
+ * Retrieves `@OnQuery` metadata from the class hierarchy.
+ * Returns handlers ordered from base to derived class.
+ *
+ * @param instance - service instance
+ * @returns metadata list
+ * @internal
+ */
+function getQueryHandlerMetadata(instance) {
+  var constructor = instance.constructor;
+  var chain = [];
+  // Traverse prototype chain up to Object/Function
+  while (typeof constructor === "function" && constructor !== Object && constructor !== Function.prototype) {
+    var own = QUERY_HANDLER_METADATA.get(constructor);
+    if (own && own.length > 0) {
+      chain.push(own);
+    }
+    constructor = Object.getPrototypeOf(constructor);
+  }
+  // Reverse to ensure parent-first execution order.
+  return chain.reverse().flat();
+}
+
+/**
+ * Retrieves `@OnActivated` method names from the class hierarchy.
+ * Returns method names ordered from base to derived class.
+ *
+ * @param instance - service instance
+ * @returns list of method names
+ * @internal
+ */
+function getActivatedHandlerMetadata(instance) {
+  var constructor = instance.constructor;
+  var chain = [];
+  // Traverse prototype chain up to Object/Function.
+  while (typeof constructor === "function" && constructor !== Object && constructor !== Function.prototype) {
+    var own = ACTIVATED_HANDLER_METADATA.get(constructor);
+    if (own && own.length > 0) {
+      chain.push(own);
+    }
+    constructor = Object.getPrototypeOf(constructor);
+  }
+  // Reverse to ensure parent-first execution order.
+  return chain.reverse().flat();
+}
+
+/**
+ * Retrieves `@OnDeactivation` method names from the class hierarchy.
+ * Returns method names ordered from base to derived class.
+ *
+ * @param instance - service instance
+ * @returns list of method names
+ * @internal
+ */
+function getDeactivationHandlerMetadata(instance) {
+  var constructor = instance.constructor;
+  var chain = [];
+  // Traverse prototype chain up to Object/Function.
+  while (typeof constructor === "function" && constructor !== Object && constructor !== Function.prototype) {
+    var own = DEACTIVATION_HANDLER_METADATA.get(constructor);
+    if (own && own.length > 0) {
+      chain.push(own);
+    }
+    constructor = Object.getPrototypeOf(constructor);
+  }
+  // Reverse to ensure parent-first execution order.
+  return chain.reverse().flat();
+}
+
+/**
+ * Registers a service class in the container with activation/deactivation logic.
+ * Ensures container references, event subscriptions, command and query handlers are managed correctly.
+ *
+ * @param container - target Inversify container
+ * @param entry - service constructor
+ * @param options - options object to control binding flow
+ */
+function bindService(container, entry, options) {
+  // Inversify's fluent binding API only allows a single `.onActivation` /
+  // `.onDeactivation` call per chain, so we register them on the container
+  // itself instead — this also works correctly if a later call rebinds the
+  // same token.
+  var whenBind = container.bind(entry).to(entry).inSingletonScope();
+  whenBind.onActivation(function (context, instance) {
+    // Ensure flag is initialized on activation.
+    instance.IS_DISPOSED = false;
+    CONTAINER_REFS_BY_SERVICE.set(instance, container);
+    attachWireScopes(instance, entry);
+    // Compose all events listeners into a single bus subscription so we only
+    // pay one Set lookup per emitted event.
+    var dispatcher = buildEventDispatcher(instance);
+    if (dispatcher) {
+      attachEventsSubscription(instance, dispatcher);
+    }
+    // Register every `@OnQuery` handler on the container's QueryBus, and
+    // remember the unregister functions so we can roll them back when the
+    // service is deactivated.
+    var queryBus = container.get(QueryBus);
+    for (var _i = 0, _a = getQueryHandlerMetadata(instance); _i < _a.length; _i++) {
+      var meta = _a[_i];
+      var method = instance[meta.methodName];
+      if (typeof method !== "function") {
+        continue;
+      }
+      var unregister = queryBus.register(meta.type, method.bind(instance));
+      attachQueryUnregister(instance, unregister);
+    }
+    // Register every `@OnCommand` handler on the container's CommandBus, and
+    // remember the unregister functions so we can roll them back when the
+    // service is deactivated.
+    var commandBus = container.get(CommandBus);
+    for (var _b = 0, _c = getCommandHandlerMetadata(instance); _b < _c.length; _b++) {
+      var meta = _c[_b];
+      var method = instance[meta.methodName];
+      if (typeof method !== "function") {
+        continue;
+      }
+      var unregister = commandBus.register(meta.type, method.bind(instance));
+      attachCommandUnregister(instance, unregister);
+    }
+    if (options === null || options === void 0 ? void 0 : options.isWithIgnoreLifecycle) ; else {
+      var _loop_1 = function (methodName) {
+        var method = instance[methodName];
+        if (typeof method !== "function") {
+          return "continue";
+        }
+        var result = method.call(instance);
+        if (result && typeof result.then === "function") {
+          result.catch(function (error) {
+            console.error("[wirestate] @OnActivated rejected for:", entry.name, String(methodName), error);
+          });
+        }
+      };
+      // Call every `@OnActivated`-decorated method in base-to-derived order.
+      // Fire-and-forget any async init so we stay synchronous from the
+      // container's point of view.
+      for (var _d = 0, _e = getActivatedHandlerMetadata(instance); _d < _e.length; _d++) {
+        var methodName = _e[_d];
+        _loop_1(methodName);
+      }
+    }
+    return instance;
+  });
+  whenBind.onDeactivation(function (instance) {
+    if (options === null || options === void 0 ? void 0 : options.isWithIgnoreLifecycle) ; else {
+      // Call every `@OnDeactivation`-decorated method in base-to-derived order.
+      for (var _i = 0, _a = getDeactivationHandlerMetadata(instance); _i < _a.length; _i++) {
+        var methodName = _a[_i];
+        var method = instance[methodName];
+        if (typeof method === "function") {
+          method.call(instance);
+        }
+      }
+    }
+    // Flip the public disposal flag first so any async work already in
+    // flight (fetches awaiting in @Action methods, scheduled reactions,
+    // etc.) can short-circuit before it mutates the about-to-die instance.
+    // The cast is the only write-site for this `readonly` field.
+    instance.IS_DISPOSED = true;
+    detachWireScopes(instance);
+    detachCommandUnregister(instance);
+    detachQueryUnregister(instance);
+    detachEventSubscription(instance);
+    CONTAINER_REFS_BY_SERVICE.delete(instance);
+  });
+}
+/**
+ * Attaches a event subscription to a service.
+ *
+ * @param service - service instance
+ * @param handler - event handler
+ * @internal
+ */
+function attachEventsSubscription(service, handler) {
+  var _a;
+  var bus = (_a = CONTAINER_REFS_BY_SERVICE.get(service)) === null || _a === void 0 ? void 0 : _a.get(EventBus);
+  if (bus) {
+    EVENT_UNSUBSCRIBERS_BY_SERVICE.set(service, bus.subscribe(handler));
+  }
+}
+/**
+ * Detaches the event subscription from a service.
+ *
+ * @param service - service instance
+ * @internal
+ */
+function detachEventSubscription(service) {
+  var unsubscribe = EVENT_UNSUBSCRIBERS_BY_SERVICE.get(service);
+  if (unsubscribe) {
+    unsubscribe();
+    EVENT_UNSUBSCRIBERS_BY_SERVICE.delete(service);
+  }
+}
+/**
+ * Registers a query unregister function for a service.
+ *
+ * @param service - service instance
+ * @param unregister - query unregister function
+ * @internal
+ */
+function attachQueryUnregister(service, unregister) {
+  var list = QUERY_UNREGISTERS_BY_SERVICE.get(service);
+  if (!list) {
+    list = [];
+    QUERY_UNREGISTERS_BY_SERVICE.set(service, list);
+  }
+  list.push(unregister);
+}
+/**
+ * Executes and removes all query unregister functions for a service.
+ *
+ * @param service - service instance
+ * @internal
+ */
+function detachQueryUnregister(service) {
+  var list = QUERY_UNREGISTERS_BY_SERVICE.get(service);
+  if (!list) {
+    return;
+  }
+  for (var _i = 0, list_1 = list; _i < list_1.length; _i++) {
+    var unregister = list_1[_i];
+    unregister();
+  }
+  QUERY_UNREGISTERS_BY_SERVICE.delete(service);
+}
+/**
+ * Registers a command unregister function for a service.
+ *
+ * @param service - service instance
+ * @param unregister - command unregister function
+ * @internal
+ */
+function attachCommandUnregister(service, unregister) {
+  var list = COMMAND_UNREGISTERS_BY_SERVICE.get(service);
+  if (!list) {
+    list = [];
+    COMMAND_UNREGISTERS_BY_SERVICE.set(service, list);
+  }
+  list.push(unregister);
+}
+/**
+ * Executes and removes all command unregister functions for a service.
+ *
+ * @param service - service instance
+ * @internal
+ */
+function detachCommandUnregister(service) {
+  var list = COMMAND_UNREGISTERS_BY_SERVICE.get(service);
+  if (!list) {
+    return;
+  }
+  for (var _i = 0, list_2 = list; _i < list_2.length; _i++) {
+    var unregister = list_2[_i];
+    unregister();
+  }
+  COMMAND_UNREGISTERS_BY_SERVICE.delete(service);
+}
+/**
+ * Reads `design:paramtypes` from the service constructor to find parameters typed as WireScope.
+ * Property iteration happens only when the constructor metadata declares a WireScope
+ * parameter, avoiding false positives from manually created or subclassed scopes.
+ *
+ * todo: Simplify this part.
+ *
+ * @param service - service instance
+ * @param Service - service constructor
+ * @internal
+ */
+function attachWireScopes(service, Service) {
+  var paramTypes = Reflect.getMetadata("design:paramtypes", Service);
+  if (!(paramTypes === null || paramTypes === void 0 ? void 0 : paramTypes.some(function (type) {
+    return type === WireScope;
+  }))) {
+    return;
+  }
+  var scopes = [];
+  for (var _i = 0, _a = Object.getOwnPropertyNames(service); _i < _a.length; _i++) {
+    var key = _a[_i];
+    var value = service[key];
+    if ((value === null || value === void 0 ? void 0 : value.constructor) === WireScope) {
+      scopes.push(value);
+    }
+  }
+  if (scopes.length > 0) {
+    WIRE_SCOPES_BY_SERVICE.set(service, scopes);
+  }
+}
+/**
+ * Marks all injected WireScope instances for this service as disposed and removes
+ * the stored references.
+ *
+ * todo: Simplify this part.
+ *
+ * @param service - service instance
+ * @internal
+ */
+function detachWireScopes(service) {
+  var scopes = WIRE_SCOPES_BY_SERVICE.get(service);
+  if (!scopes) {
+    return;
+  }
+  for (var _i = 0, scopes_1 = scopes; _i < scopes_1.length; _i++) {
+    var scope = scopes_1[_i];
+    scope.isDisposed = true;
+    scope.container = null;
+  }
+  WIRE_SCOPES_BY_SERVICE.delete(service);
+}
+
+/**
+ * Binds a single service entry to the container, dispatching to the
+ * correct binding strategy based on the descriptor's `type` field.
+ *
+ * Supports:
+ * - Service classes (function entries) - bound as singleton
+ * - Constant values - bound via `bindConstant`
+ * - Dynamic values - bound via `toDynamicValue` with optional scope
+ * - Instance bindings - bound as generic singleton service
+ *
+ * @param container - target IOC container to bind into
+ * @param entry - entry descriptor to bind
+ * @param options - optional binding configuration
+ * @returns void
+ */
+function bindEntry(container, entry, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  if (typeof entry === "function") {
+    return bindService(container, entry, options);
+  }
+  if (!entry.bindingType || entry.bindingType === inversify.bindingTypeValues.ConstantValue) {
+    return bindConstant(container, entry);
+  }
+  if (entry.bindingType === inversify.bindingTypeValues.DynamicValue) {
+    return bindDynamicValue(container, entry);
+  }
+  // Default: treat as class descriptor (Instance binding).
+  return bindService(container, entry.value, options);
+}
+
+/**
+ * Returns the container token for a service entry.
+ * For plain service classes the class itself is the token;
+ * for descriptors the `id` field is used.
+ *
+ * @param entry - entry descriptor to get service identifier for
+ * @returns injectable identifier token
+ */
+function getEntryToken(entry) {
+  return typeof entry === "function" ? entry : entry.id;
+}
+
+/**
+ * Creates an IoC container with framework essentials.
+ *
+ * @param options - container configuration
+ * @returns new IoC container
+ */
+function createIocContainer(options) {
+  var _a;
+  if (options === void 0) {
+    options = {};
+  }
+  var container = new inversify.Container({
+    defaultScope: "Singleton",
+    parent: options.parent
+  });
+  container.bind(EventBus).toConstantValue(new EventBus());
+  container.bind(QueryBus).toConstantValue(new QueryBus());
+  container.bind(CommandBus).toConstantValue(new CommandBus());
+  container.bind(SEEDS_TOKEN).toConstantValue(new Map());
+  container.bind(SEED_TOKEN).toConstantValue((_a = options.seed) !== null && _a !== void 0 ? _a : {});
+  container.bind(WireScope).toResolvedValue(function () {
+    return new WireScope(container);
+  }).inTransientScope();
+  return container;
+}
+
+exports.ACTIVATED_HANDLER_METADATA = ACTIVATED_HANDLER_METADATA;
+exports.COMMAND_HANDLER_METADATA = COMMAND_HANDLER_METADATA;
+exports.CommandBus = CommandBus;
+exports.DEACTIVATION_HANDLER_METADATA = DEACTIVATION_HANDLER_METADATA;
+exports.ERROR_CODE_INVALID_ARGUMENTS = ERROR_CODE_INVALID_ARGUMENTS;
+exports.EVENT_HANDLER_METADATA = EVENT_HANDLER_METADATA;
+exports.EventBus = EventBus;
+exports.QUERY_HANDLER_METADATA = QUERY_HANDLER_METADATA;
+exports.QueryBus = QueryBus;
+exports.SEEDS_TOKEN = SEEDS_TOKEN;
+exports.SEED_TOKEN = SEED_TOKEN;
+exports.WireScope = WireScope;
+exports.WirestateError = WirestateError;
+exports.bindConstant = bindConstant;
+exports.bindEntry = bindEntry;
+exports.bindService = bindService;
+exports.createIocContainer = createIocContainer;
+exports.getEntryToken = getEntryToken;
+//# sourceMappingURL=lib.js.map