lanka 1.3.0 → 2.0.0

package/dist/{activeRuntime-BYd2D6Lx.d.ts → activeRuntime-BO-qY0yY.d.ts}

@@ -1,9 +1,9 @@
 import { L as LankaEventBusInstance, I as ILankaScenarioVM } from './ILankaScenarioVM-DpKFL3iE.js';
-import { c as LankaScenariosRegistry, b as LankaScenarioVMRegistry, L as LankaGatewayLocator, a as LankaScenarioLocator } from './LankaScenarioLocator-CAENLhDO.js';
+import { L as LankaScenariosRegistry, a as LankaScenarioVMRegistry, b as LankaGatewayLocator, c as LankaScenarioLocator } from './LankaScenarioLocator-Dki2Es3O.js';
 import { b as ILankaRuntimeConfig } from './ILankaRuntimeConfig-Vl436GWK.js';
 import { I as ILankaInFlightCounter } from './lankaHttpInFlight-Bk1eIuSx.js';
 import { T as TLankaRequestMiddleware } from './lankaRequestMiddleware-DAC5kCb7.js';
-import { b as LankaSingletonLocator, L as LankaSharedStoreLocator } from './LankaSharedStoreLocator-zS2kLu-S.js';
+import { L as LankaSingletonLocator, a as LankaSharedStoreLocator } from './LankaSharedStoreLocator-jsz_gnUm.js';
 
 /**
  * The pointer to the framework instance that ambient facades resolve to.
@@ -67,6 +67,26 @@ interface ILankaRuntime {
  * is the bug: the last request to start would answer for all of them.
  */
 type TLankaRuntimeResolver = () => ILankaRuntime | null;
+/**
+ * How "which SCOPE is this" is answered, which is a different question.
+ *
+ * `TLankaRuntimeResolver` answers which framework INSTANCE serves a call, and on
+ * a server that is one per request. This answers which unit of work the call
+ * belongs to, and the two are not interchangeable: `runInLankaServerScope`
+ * creates its instance INSIDE the scope, and `createLanka` activates every
+ * instance it builds — so the process pointer and the scope's runtime are the
+ * same object during a request, and nothing downstream can tell "inside a
+ * scope" from "after one ended".
+ *
+ * That distinction is what a per-scope lifetime needs. Without it a call made
+ * outside every request resolves against the LAST request's runtime and is
+ * handed the last stranger's state, which is the failure a scope exists to
+ * abolish.
+ *
+ * Core ships no resolver here either, and knows only that the question exists.
+ */
+type TLankaScopeResolver = () => object | null;
+declare function setActiveLankaRuntime(runtime: ILankaRuntime | null): void;
 /**
  * Replaces the strategy, or restores the default one with `null`.
  *
@@ -80,5 +100,32 @@ type TLankaRuntimeResolver = () => ILankaRuntime | null;
  * one answer.
  */
 declare function setLankaRuntimeResolver(resolver: TLankaRuntimeResolver | null): void;
+/**
+ * The PROCESS's own instance, read without asking the strategy.
+ *
+ * `getActiveRuntime` consults the installed resolver and is the answer for
+ * almost everything. This is the one question it cannot answer: what a call
+ * would have resolved to if nobody had installed a resolver at all.
+ *
+ * It exists for a resolver that wants to DEFER. A server's resolver answers from
+ * its request scope, and a process that also holds an ambient instance — a
+ * worker with a cache, a dev server between reloads, a suite between cases —
+ * has a right answer outside every scope that the resolver cannot see. Without
+ * this, the first request in such a process makes every later ambient call fail
+ * for the life of it.
+ *
+ * Not a fallback inside `getActiveRuntime`, deliberately: a resolver that wants
+ * to defer says so, and one that wants a call outside its scope to fail loudly
+ * goes on failing loudly. The choice belongs to whoever knows what a scope is.
+ */
+declare function getLankaProcessRuntime(): ILankaRuntime | null;
+/**
+ * Installs the strategy that says which unit of work a call belongs to.
+ *
+ * Installed by whoever knows what a scope IS — `@lankajs/host` wraps a request
+ * in `AsyncLocalStorage` and answers from its store. A browser installs none,
+ * and that is the right answer there: a tab is one scope for its whole life.
+ */
+declare function setLankaScopeResolver(resolver: TLankaScopeResolver | null): void;
 
-export { type ILankaRuntime as I, type TLankaRuntimeResolver as T, setLankaRuntimeResolver as s };
+export { type ILankaRuntime as I, type TLankaRuntimeResolver as T, type TLankaScopeResolver as a, setLankaRuntimeResolver as b, setLankaScopeResolver as c, getLankaProcessRuntime as g, setActiveLankaRuntime as s };

package/dist/bootstrap/index.d.ts

@@ -1,16 +1,16 @@
-import { c as ILankaPlugin, e as ILankaServiceConfig, I as ILankaBootstrapConfig, a as ILankaInstance } from '../createLanka-NrlvN-WQ.js';
-export { b as ILankaInstanceConfig, d as ILankaScenarioBootstrapConfig, f as createLanka } from '../createLanka-NrlvN-WQ.js';
+import { c as ILankaPlugin, e as ILankaServiceConfig, I as ILankaBootstrapConfig, a as ILankaInstance } from '../createLanka-x4oSMs7P.js';
+export { b as ILankaInstanceConfig, d as ILankaScenarioBootstrapConfig, f as createLanka } from '../createLanka-x4oSMs7P.js';
 import { I as ILankaFlags, a as ILankaHost } from '../ILankaRuntimeConfig-Vl436GWK.js';
-export { I as ILankaScope } from '../createLankaScope-BiFxNQgl.js';
-import '../activeRuntime-BYd2D6Lx.js';
+export { I as ILankaScope } from '../createLankaScope-DomNbEvb.js';
+import '../activeRuntime-BO-qY0yY.js';
 import '../ILankaScenarioVM-DpKFL3iE.js';
-import '../LankaScenarioLocator-CAENLhDO.js';
+import '../LankaScenarioLocator-Dki2Es3O.js';
 import '../ILankaScenarioMetadata-Dj4GCqmX.js';
 import '../ALankaGateway-BrVPaZN5.js';
 import '../lankaStandardValidator-BUFnysK0.js';
 import '@standard-schema/spec';
 import '../ILankaFieldError-D5931-vT.js';
-import '../LankaSharedStoreLocator-zS2kLu-S.js';
+import '../LankaSharedStoreLocator-jsz_gnUm.js';
 import '../ALankaSharedStore-B7uepuuk.js';
 import 'zustand/vanilla';
 import '../lankaHttpInFlight-Bk1eIuSx.js';

package/dist/bootstrap/index.js

@@ -3,16 +3,15 @@ import {
   createLanka,
   resetActiveLanka,
   startLanka
-} from "../chunk-UBGXDTXC.js";
-import "../chunk-B7EYIAW7.js";
-import "../chunk-5MAQVBI2.js";
-import "../chunk-O5ROO7QF.js";
+} from "../chunk-SZVNPK24.js";
+import "../chunk-UMPSR4US.js";
+import "../chunk-EYDMBI5T.js";
 import "../chunk-XESL274R.js";
-import "../chunk-UJEC7H6K.js";
+import "../chunk-BHQ2SQ7P.js";
 import "../chunk-UE2C76OR.js";
-import "../chunk-C2HP7CRD.js";
-import "../chunk-D27MREPB.js";
-import "../chunk-BGVDPDX4.js";
+import "../chunk-FII3PW2G.js";
+import "../chunk-7DQUF2QR.js";
+import "../chunk-XGMXT4XZ.js";
 export {
   ALankaPlugin,
   createLanka,

package/dist/{chunk-D27MREPB.js → chunk-7DQUF2QR.js}

@@ -1,6 +1,6 @@
 import {
   getActiveRuntime
-} from "./chunk-BGVDPDX4.js";
+} from "./chunk-XGMXT4XZ.js";
 
 // src/config/get-lanka-flags/getLankaFlags.ts
 function getLankaFlags() {
@@ -10,4 +10,4 @@ function getLankaFlags() {
 export {
   getLankaFlags
 };
-//# sourceMappingURL=chunk-D27MREPB.js.map
+//# sourceMappingURL=chunk-7DQUF2QR.js.map

package/dist/{chunk-UJEC7H6K.js → chunk-BHQ2SQ7P.js}

@@ -1,6 +1,6 @@
 import {
   requireActiveRuntime
-} from "./chunk-BGVDPDX4.js";
+} from "./chunk-XGMXT4XZ.js";
 
 // src/gateway/inflight/lankaHttpInFlight.ts
 function createInFlightCounter() {
@@ -36,4 +36,4 @@ export {
   createInFlightCounter,
   lankaHttpInFlight
 };
-//# sourceMappingURL=chunk-UJEC7H6K.js.map
+//# sourceMappingURL=chunk-BHQ2SQ7P.js.map

package/dist/chunk-EYDMBI5T.js

@@ -0,0 +1,550 @@
+import {
+  lankaLogger
+} from "./chunk-FII3PW2G.js";
+import {
+  getActiveRuntime,
+  requireActiveRuntime
+} from "./chunk-XGMXT4XZ.js";
+
+// src/scenario/event-bus/_facades/lanka-event-bus/lankaEventBus.ts
+var bus = () => requireActiveRuntime().eventBus;
+var lankaEventBus = Object.freeze({
+  enableLogs: () => {
+    bus().enableLogs();
+  },
+  disableLogs: () => {
+    bus().disableLogs();
+  },
+  registerEvent: (eventType, metadata) => {
+    bus().registerEvent(eventType, metadata);
+  },
+  getRegisteredEvents: () => bus().getRegisteredEvents(),
+  getEventInfo: (eventType) => bus().getEventInfo(eventType),
+  getSubscriptions: (eventType) => bus().getSubscriptions(eventType),
+  subscribe: (eventType, callback, options) => bus().subscribe(eventType, callback, options),
+  unsubscribe: (eventType, callback) => {
+    bus().unsubscribe(eventType, callback);
+  },
+  dispatch: (eventType, data, usedBy) => {
+    bus().dispatch(eventType, data, usedBy);
+  },
+  addMiddleware: (middleware) => {
+    bus().addMiddleware(middleware);
+  },
+  removeMiddleware: (middleware) => {
+    bus().removeMiddleware(middleware);
+  },
+  addObserver: (observer) => {
+    bus().addObserver(observer);
+  },
+  removeObserver: (observer) => {
+    bus().removeObserver(observer);
+  },
+  getEventLogs: (eventType, limit = 100) => bus().getEventLogs(eventType, limit),
+  clearEvent: (eventType) => {
+    bus().clearEvent(eventType);
+  },
+  clearAllEvents: () => {
+    bus().clearAllEvents();
+  },
+  reset: () => {
+    bus().reset();
+  }
+});
+
+// src/scenario/_registries/lanka-scenario-vm-registry/LankaScenarioVMRegistry.ts
+var LankaScenarioVMRegistry = class {
+  registeredViewModels = /* @__PURE__ */ new Set();
+  /**
+   * Public: the registry belongs to a framework instance rather than to the
+   * module.
+   */
+  constructor() {
+  }
+  /**
+   * The active instance's registry, for callers that cannot hold one — the
+   * static `LankaScenarioBootstrap`. Instance holders read `lanka.viewModels`.
+   */
+  static getInstance() {
+    return requireActiveRuntime().viewModels;
+  }
+  /** Whether this ViewModel is already registered. */
+  isRegistered(viewModel) {
+    return this.registeredViewModels.has(viewModel);
+  }
+  /**
+   * Registers a ViewModel.
+   *
+   * @returns `false` when it was already registered
+   */
+  register(viewModel) {
+    if (this.registeredViewModels.has(viewModel)) {
+      return false;
+    }
+    this.registeredViewModels.add(viewModel);
+    return true;
+  }
+  /** Removes a ViewModel from the registry. */
+  unregister(viewModel) {
+    this.registeredViewModels.delete(viewModel);
+  }
+  /** Every registered ViewModel. */
+  getAllViewModels() {
+    return Array.from(this.registeredViewModels);
+  }
+  /**
+   * Clears every registered ViewModel. Required by tests.
+   */
+  clear() {
+    this.registeredViewModels.clear();
+  }
+  /**
+   * Unsubscribes every registered ViewModel from its scenarios and clears the
+   * registry.
+   *
+   * Without it tests are not isolated: a subscription leaks from test to test.
+   */
+  resetAll() {
+    this.registeredViewModels.forEach((vm) => {
+      try {
+        vm.resetScenario();
+      } catch {
+      }
+    });
+    this.clear();
+  }
+};
+
+// src/scenario/_registries/lanka-scenarios-registry/LankaScenariosRegistry.ts
+var release = (scenario) => {
+  if (!scenario.cleanup) return;
+  try {
+    scenario.cleanup();
+  } catch (error) {
+    lankaLogger.printScenarioLog(`Error cleaning up scenario "${scenario.name}":`, error);
+  }
+};
+var LankaScenariosRegistry = class {
+  registeredScenarios = /* @__PURE__ */ new Map();
+  scenarioMetadata = /* @__PURE__ */ new Map();
+  /**
+   * Public: the registry belongs to a framework instance rather than to the
+   * module.
+   */
+  constructor() {
+  }
+  /**
+   * The active instance's registry, for callers that cannot hold one:
+   * `ALankaScenario` (a base class the consumer extends) and the static
+   * `LankaScenarioBootstrap`. Instance holders read `lanka.scenarios`.
+   */
+  static getInstance() {
+    return requireActiveRuntime().scenarios;
+  }
+  /**
+   * Registers a scenario by hand.
+   *
+   * @param scenario What to register
+   * @returns `false` when it was already registered
+   */
+  register(scenario) {
+    if (this.registeredScenarios.has(scenario.name)) {
+      return false;
+    }
+    this.registeredScenarios.set(scenario.name, scenario);
+    this.scenarioMetadata.set(scenario.name, {
+      scenario,
+      name: scenario.name,
+      eventType: scenario.eventType,
+      dataTypeName: scenario.dataTypeName,
+      isRegistered: true
+    });
+    return true;
+  }
+  /**
+   * Removes a scenario, calling its `cleanup` if it declared one.
+   *
+   * @param scenarioName Name of the scenario to unregister
+   * @returns true if unregistered successfully, false if not found
+   */
+  unregister(scenarioName) {
+    const scenario = this.registeredScenarios.get(scenarioName);
+    if (!scenario) {
+      return false;
+    }
+    const metadata = this.scenarioMetadata.get(scenarioName);
+    if (metadata) {
+      metadata.isRegistered = false;
+    }
+    this.registeredScenarios.delete(scenarioName);
+    release(scenario);
+    return true;
+  }
+  /**
+   * Get metadata for a specific scenario
+   * @param scenarioName Name of the scenario
+   * @returns Scenario metadata or undefined if not found
+   */
+  getMetadata(scenarioName) {
+    return this.scenarioMetadata.get(scenarioName);
+  }
+  /** Every registered scenario. */
+  getAllScenarios() {
+    return Array.from(this.registeredScenarios.values());
+  }
+  /** Metadata of every scenario. */
+  getAllMetadata() {
+    return Array.from(this.scenarioMetadata.values());
+  }
+  /** Whether a scenario with this name is registered. */
+  isRegistered(scenarioName) {
+    return this.registeredScenarios.has(scenarioName);
+  }
+  /**
+   * Collects every scenario that registered itself at construction.
+   */
+  collectAutoRegisteredScenarios() {
+    const autoRegistered = ALankaScenario.getAutoRegisteredScenarios();
+    autoRegistered.forEach((scenario) => {
+      if (!this.registeredScenarios.has(scenario.name)) {
+        this.register(scenario);
+      }
+    });
+  }
+  /**
+   * A scenario by name.
+   *
+   * @returns `undefined` when there is none
+   */
+  getScenarioByName(scenarioName) {
+    return this.registeredScenarios.get(scenarioName);
+  }
+  /** Every registered ViewModel. */
+  getAllViewModels() {
+    return LankaScenarioVMRegistry.getInstance().getAllViewModels();
+  }
+  /**
+   * Removes every scenario, calling each one's `cleanup`.
+   *
+   * What `dispose()` and the between-tests reset go through: `initialize` ran
+   * for every scenario at bootstrap, and this is the one moment its mirror
+   * image can run for all of them.
+   */
+  clear() {
+    const scenarios = [...this.registeredScenarios.values()];
+    this.registeredScenarios.clear();
+    this.scenarioMetadata.clear();
+    for (const scenario of scenarios) release(scenario);
+  }
+};
+
+// src/scenario/_abstractions/lanka-scenario/ALankaScenario.ts
+var ALankaScenario = class _ALankaScenario {
+  /** A subclass sets this to opt out of self-registration. */
+  static skipAutoRegistration;
+  /**
+   * The self-registration pool.
+   *
+   * Class-level deliberately: a registry of DEFINITIONS, not runtime state. The
+   * classes come from one barrel and both framework instances must see the same
+   * list — splitting it would be divergence, not isolation.
+   */
+  static autoRegisteredScenarios = /* @__PURE__ */ new Set();
+  /** Registers the scenario itself unless the subclass opted out. */
+  constructor() {
+    const constructor = this.constructor;
+    if (!constructor.skipAutoRegistration) {
+      _ALankaScenario.autoRegisteredScenarios.add(this);
+    }
+  }
+  /**
+   * Every scenario that registered itself.
+   *
+   * @internal
+   */
+  static getAutoRegisteredScenarios() {
+    return Array.from(_ALankaScenario.autoRegisteredScenarios);
+  }
+  /**
+   * Clears the auto-registration pool. Required by tests.
+   * @internal
+   */
+  static clearAutoRegisteredScenarios() {
+    _ALankaScenario.autoRegisteredScenarios.clear();
+  }
+  /**
+   * Registers the scenario by hand.
+   *
+   * @returns `false` when it was already registered
+   */
+  register() {
+    return LankaScenariosRegistry.getInstance().register(this);
+  }
+  /**
+   * Removes the scenario from the registry.
+   *
+   * @returns `false` when it was not there
+   */
+  unregister() {
+    return LankaScenariosRegistry.getInstance().unregister(this.name);
+  }
+  trigger(data) {
+    lankaLogger.printScenarioLog("TRIGGER Scenario", this.name, data);
+    lankaEventBus.dispatch(this.eventType, data, this.name);
+  }
+  /**
+   * Subscribes a handler and returns an unsubscribe function.
+   *
+   * Without the return, unsubscribing is possible only by callback identity, and
+   * every ViewModel factory has to keep a map of references for it.
+   */
+  subscribe(callback, options) {
+    lankaLogger.printScenarioLog("SUBSCRIBE Scenario", this.name, this.dataTypeName);
+    return lankaEventBus.subscribe(this.eventType, callback, {
+      ...options,
+      usedBy: options?.usedBy ?? this.name
+    });
+  }
+};
+
+// src/scenario/lanka-scenario-bootstrap/LankaScenarioBootstrap.ts
+import * as ScenariosModule from "@lanka_di/Scenarios";
+var LankaScenarioBootstrap = class {
+  /**
+   * The bootstrapped flag and the set of initialised VMs live on the INSTANCE.
+   *
+   * As static fields, a second framework in the same process would exit
+   * `bootstrap()` on someone else's flag — never starting at all, with no symptom
+   * except that no scenario works.
+   */
+  get state() {
+    return requireActiveRuntime().scenarioState;
+  }
+  isScenarioLayerBootstrapped() {
+    return this.state.bootstrapped;
+  }
+  forceInstantiateAllScenarios() {
+    const pooled = new Set(
+      ALankaScenario.getAutoRegisteredScenarios().map((scenario) => scenario.constructor)
+    );
+    for (const exported of Object.values(ScenariosModule)) {
+      if (typeof exported !== "function") continue;
+      if (pooled.has(exported)) continue;
+      try {
+        new exported();
+      } catch {
+      }
+    }
+  }
+  registerScenarioEvents(scenarios) {
+    const registeredEventTypes = /* @__PURE__ */ new Set();
+    scenarios.forEach((scenario) => {
+      if (!registeredEventTypes.has(scenario.eventType)) {
+        registeredEventTypes.add(scenario.eventType);
+        lankaLogger.printScenarioLog("REGISTER SCENARIO EVENT", scenario.name);
+        lankaEventBus.registerEvent(scenario.eventType, {
+          dataType: scenario.dataTypeName,
+          description: `Scenario: ${scenario.name}`,
+          usedBy: [scenario.name],
+          priority: 0
+        });
+      }
+      if (scenario.initialize) {
+        lankaLogger.printScenarioLog("INITIALIZE SCENARIO", scenario.name);
+        scenario.initialize();
+      }
+    });
+  }
+  initializeAlreadyCreatedViewModels() {
+    const viewModels = LankaScenarioVMRegistry.getInstance().getAllViewModels();
+    viewModels.forEach((vm) => {
+      if (!this.state.initialized.has(vm)) {
+        this.state.initialized.add(vm);
+        vm.initializeScenario();
+      }
+    });
+  }
+  /**
+   * Brings up the scenario layer.
+   *
+   * Constructs the scenario classes so they can be collected, declares their
+   * events on the bus, calls `initialize()` where present, and initialises
+   * ViewModels that already exist — which happens in tests and under unusual
+   * import order.
+   *
+   * Idempotent.
+   */
+  bootstrap() {
+    if (this.state.bootstrapped) return;
+    lankaLogger.printScenarioLog("BOOTSTRAP SCENARIOS START");
+    this.forceInstantiateAllScenarios();
+    const registry = LankaScenariosRegistry.getInstance();
+    registry.collectAutoRegisteredScenarios();
+    const scenarios = registry.getAllScenarios();
+    this.registerScenarioEvents(scenarios);
+    this.state.bootstrapped = true;
+    this.adoptDeclaredViewModels();
+    this.initializeAlreadyCreatedViewModels();
+    lankaLogger.printScenarioLog("BOOTSTRAP SCENARIOS FINISH");
+  }
+  /**
+   * Called by a ViewModel factory when the ViewModel declares scenario handlers.
+   *
+   * Registers the ViewModel and, if the layer is already up, initialises it
+   * immediately. Duplicate registration and duplicate initialisation are
+   * impossible.
+   *
+   * @param viewModel What to register
+   * @param name Name for the log
+   */
+  /**
+   * ViewModels DECLARED in this process.
+   *
+   * Module-level deliberately, the same case as the scenario pool: a registry of
+   * DEFINITIONS, not runtime state. Splitting it between instances would be
+   * divergence, not isolation — the classes come from the same modules and both
+   * instances must see one list.
+   *
+   * Two reasons it exists:
+   *
+   * 1. Declaring a ViewModel is a declaration, not work. A screen file creates it
+   *    at module level, and import order decides whether that happens before or
+   *    after `createLanka()`. Requiring a live instance at declaration time
+   *    requires an import order the consumer does not control.
+   * 2. Instances come one after another: every test creates its own. The list is
+   *    NOT drained by the first — otherwise the second instance would know no
+   *    module-level ViewModel and its `dispose()` would not remove their
+   *    subscriptions, so a test would receive events the previous one subscribed
+   *    to.
+   */
+  declaredViewModels = [];
+  /**
+   * Registers everything declared into a NEW instance.
+   *
+   * Called twice, and the second call is the one that makes this work on a
+   * server: `createLanka` calls it, and so does `bootstrap()`.
+   *
+   * The reason is an order nobody can change. Where "which instance is active"
+   * is answered by a RESOLVER — one instance per request, the shape
+   * `@lankajs/host` installs — an instance becomes findable only once the CALLER
+   * has put it in its store, and a caller can only do that after `createLanka`
+   * has returned. So during creation the answer is honestly "none", and asking
+   * for it threw: every server render of an application with a module-level
+   * ViewModel failed inside the call that was creating the scope, with a message
+   * about running outside one.
+   *
+   * Skipping is safe precisely because bootstrap adopts again. It is idempotent
+   * at the other end too: `attachViewModel` returns early for a ViewModel the
+   * registry already holds.
+   */
+  adoptDeclaredViewModels() {
+    if (!getActiveRuntime()) return;
+    for (const { viewModel, name } of [...this.declaredViewModels]) {
+      this.attachViewModel(viewModel, name);
+    }
+  }
+  /**
+   * Whether the ViewModel being built belongs to ONE scope.
+   *
+   * A module-level ViewModel is declared once and adopted by every instance
+   * ever created, which is what `declaredViewModels` is for and why it is never
+   * drained. A SCOPED one is the opposite: it belongs to the request that built
+   * it and to nothing after.
+   *
+   * Declaring one would be the defect this flag exists to prevent, and it is
+   * worth spelling out because nothing would look wrong. The array grows by an
+   * entry per request for the life of the process, and request N+1 ADOPTS
+   * request N's ViewModel — subscribing it to N+1's scenarios, so a dispatch
+   * runs N's handlers against N's gateways and writes into N's store. Every
+   * suite stays green and the leak is one user seeing another's board.
+   */
+  isBuildingScoped = false;
+  /**
+   * Runs `build` with its declarations kept OUT of the process-wide list.
+   *
+   * Called by `resolveLankaVM` and by nothing else. A narrow seam rather than a
+   * parameter on every factory: the nine ways to build a ViewModel would each
+   * have to carry a flag through to `registerViewModel`, and eight of them have
+   * no business knowing what a scope is.
+   */
+  buildScoped(build) {
+    const before = this.isBuildingScoped;
+    this.isBuildingScoped = true;
+    try {
+      return build();
+    } finally {
+      this.isBuildingScoped = before;
+    }
+  }
+  registerViewModel(viewModel, name) {
+    if (!this.isBuildingScoped) {
+      const isKnown = this.declaredViewModels.some(
+        (declared) => declared.viewModel === viewModel
+      );
+      if (!isKnown) this.declaredViewModels.push({ viewModel, name });
+    }
+    if (!getActiveRuntime()) return;
+    this.attachViewModel(viewModel, name);
+  }
+  attachViewModel(viewModel, name) {
+    const registry = LankaScenarioVMRegistry.getInstance();
+    if (registry.isRegistered(viewModel)) {
+      if (name) {
+        lankaLogger.printViewModelLog("VM Already Registered (skipped)", name);
+      }
+      return;
+    }
+    registry.register(viewModel);
+    if (name) {
+      lankaLogger.printViewModelLog("Register Scenario VM", name);
+    }
+    if (this.state.bootstrapped) {
+      if (!this.state.initialized.has(viewModel)) {
+        this.state.initialized.add(viewModel);
+        viewModel.initializeScenario();
+      }
+    }
+  }
+  /**
+   * Resets the whole scenario layer. Without it tests are not isolated.
+   *
+   * Clears the self-registration list, the scenario registry with its metadata,
+   * the ViewModel registry together with all their subscriptions, and the bus —
+   * events and
+   * middleware.
+   *
+   * What it does NOT clear by default is which ViewModels were DECLARED, and
+   * that default is load-bearing: a module-level ViewModel is built once per
+   * process, so the declaration is the only thing that lets a second instance
+   * find it. Drop it and its handlers bind to nothing, silently, for the rest of
+   * the process — see `declaredViewModels`.
+   *
+   * `withDeclarations` is for the case that default gets wrong: a suite that
+   * builds ViewModels inside test BODIES. Those are declared like any other and
+   * nothing un-declares them, so the next bootstrap re-adopts every one ever
+   * built and a finished test's handlers run again — against the gateway that
+   * test built, which is somebody else's double. Forgetting is not a tombstone:
+   * a ViewModel declared again afterwards is adopted again.
+   *
+   * @param config `withDeclarations` also forgets which ViewModels exist
+   */
+  reset(config = {}) {
+    ALankaScenario.clearAutoRegisteredScenarios();
+    LankaScenariosRegistry.getInstance().clear();
+    LankaScenarioVMRegistry.getInstance().resetAll();
+    lankaEventBus.clearAllEvents();
+    this.state.bootstrapped = false;
+    this.state.initialized = /* @__PURE__ */ new WeakSet();
+    if (config.withDeclarations) this.declaredViewModels.length = 0;
+  }
+};
+var lankaScenarioBootstrap = new LankaScenarioBootstrap();
+
+export {
+  lankaEventBus,
+  ALankaScenario,
+  LankaScenarioVMRegistry,
+  LankaScenariosRegistry,
+  lankaScenarioBootstrap
+};
+//# sourceMappingURL=chunk-EYDMBI5T.js.map