lanka 1.0.0

package/dist/chunk-RYFZCAQ3.js

@@ -0,0 +1,637 @@
+import {
+  lankaScenarioBootstrap
+} from "./chunk-Q3SOVBIJ.js";
+import {
+  LankaGatewayLocator,
+  LankaScenarioLocator,
+  createLankaScope
+} from "./chunk-FIR4XTBL.js";
+import {
+  LankaScenarioVMRegistry,
+  LankaScenariosRegistry
+} from "./chunk-EWVDJYCC.js";
+import {
+  createLankaHost
+} from "./chunk-XESL274R.js";
+import {
+  createInFlightCounter
+} from "./chunk-UJEC7H6K.js";
+import {
+  LankaSharedStoreLocator,
+  LankaSingletonLocator
+} from "./chunk-ILQNYQY5.js";
+import {
+  lankaLogger
+} from "./chunk-C2HP7CRD.js";
+import {
+  getActiveRuntime,
+  setActiveRuntime
+} from "./chunk-BGVDPDX4.js";
+
+// src/scenario/event-bus/lanka-event-bus-instance/LankaEventBusInstance.ts
+function resolveReplayCount(request) {
+  if (request === void 0 || request === false) return 0;
+  if (request === true || request === "last") return 1;
+  return Math.max(0, Math.trunc(request));
+}
+function maxReplayDepth(subs) {
+  let depth = 0;
+  for (const entry of subs) if (entry.replayCount > depth) depth = entry.replayCount;
+  return depth;
+}
+var LankaEventBusInstance = class {
+  /** Event registry and per-event state — private to each instance. */
+  registry = /* @__PURE__ */ new Map();
+  /** Middleware registered on this instance. */
+  middlewares = [];
+  /** Default maximum number of logs kept per event type. */
+  defaultMaxLogs = 100;
+  /** Internal timers for replay batching (avoid multiple replays in the same tick). */
+  pendingReplayTimers = /* @__PURE__ */ new Map();
+  /** Whether event logging is enabled. */
+  isEnableLogs = false;
+  // -------------------------------------------------------------------------
+  // Configuration
+  // -------------------------------------------------------------------------
+  /** Configures the bus, e.g. logging. Called once at application start. */
+  enableLogs() {
+    this.isEnableLogs = true;
+  }
+  disableLogs() {
+    this.isEnableLogs = false;
+  }
+  // -------------------------------------------------------------------------
+  // Internal
+  // -------------------------------------------------------------------------
+  /**
+   * Ensures the event is registered, registering it if not.
+   *
+   * @param eventType Event type
+   * @param usedBy Who uses it — for the inspector and for finding an owner
+   */
+  ensureEvent(eventType, usedBy) {
+    let state = this.registry.get(eventType);
+    if (!state) {
+      const meta = {
+        dataType: "any",
+        description: `Auto-registered event: ${eventType}`,
+        usedBy: usedBy ? [usedBy] : [],
+        priority: 0,
+        maxLogs: this.defaultMaxLogs
+      };
+      state = {
+        meta,
+        logs: [],
+        buffer: [],
+        subs: []
+      };
+      this.registry.set(eventType, state);
+    } else if (usedBy) {
+      const meta = state.meta;
+      meta.usedBy = [.../* @__PURE__ */ new Set([...meta.usedBy ?? [], usedBy])];
+    }
+    return state;
+  }
+  // -------------------------------------------------------------------------
+  // Public surface
+  // -------------------------------------------------------------------------
+  /**
+   * Declares an event explicitly, together with its metadata.
+   *
+   * @param eventType Event type
+   * @param metadata What is known about the event and what it is allowed
+   */
+  registerEvent(eventType, metadata) {
+    const existing = this.registry.get(eventType);
+    const meta = {
+      dataType: metadata.dataType ?? existing?.meta.dataType ?? "any",
+      description: metadata.description ?? existing?.meta.description ?? `Registered event: ${eventType}`,
+      // `usedBy` lists everyone using the event and exists precisely to be
+      // complete. Replacing it would erase half.
+      usedBy: [.../* @__PURE__ */ new Set([...existing?.meta.usedBy ?? [], ...metadata.usedBy ?? []])],
+      schema: metadata.schema ?? existing?.meta.schema,
+      priority: metadata.priority ?? existing?.meta.priority ?? 0,
+      maxLogs: metadata.maxLogs ?? existing?.meta.maxLogs ?? this.defaultMaxLogs,
+      replay: metadata.replay ?? existing?.meta.replay
+    };
+    if (existing) {
+      existing.meta = meta;
+      return;
+    }
+    this.registry.set(eventType, { meta, logs: [], buffer: [], subs: [] });
+  }
+  /** Every registered event with its metadata. */
+  getRegisteredEvents() {
+    return Array.from(this.registry.entries()).map(([eventType, state]) => ({
+      eventType,
+      metadata: state.meta
+    })).sort((a, b) => a.eventType.localeCompare(b.eventType));
+  }
+  /** Metadata of one event type. */
+  getEventInfo(eventType) {
+    return this.registry.get(eventType)?.meta ?? null;
+  }
+  /** How many live subscriptions this event has. */
+  /**
+   * How many values sit in the event's buffer.
+   *
+   * Exists for the test: "the buffer stays empty until someone asks for replay"
+   * is a claim about MEMORY, and nothing but asking can check it.
+   */
+  getBufferedCount(eventType) {
+    return this.registry.get(eventType)?.buffer.length ?? 0;
+  }
+  getSubscriptions(eventType) {
+    return this.registry.get(eventType)?.subs.length ?? 0;
+  }
+  /**
+   * Subscribes a handler to an event type.
+   *
+   * @param eventType Event type
+   * @param callback What to run on dispatch
+   * @param options Subscription options:
+   *  - `priority` — execution order, higher runs earlier;
+   *  - `replay` — receive what was dispatched before subscribing;
+   *  - `usedBy` — who subscribed, for the inspector.
+   */
+  subscribe(eventType, callback, options) {
+    const state = this.ensureEvent(eventType, options?.usedBy);
+    const prio = options?.priority ?? state.meta.priority ?? 0;
+    const entry = {
+      callback,
+      priority: prio,
+      replayCount: resolveReplayCount(options?.replay)
+    };
+    const subs = state.subs;
+    let low = 0, high = subs.length;
+    while (low < high) {
+      const mid = low + high >>> 1;
+      if (subs[mid].priority < prio) high = mid;
+      else low = mid + 1;
+    }
+    subs.splice(low, 0, entry);
+    if (options?.replay) this.scheduleBatchedReplay(eventType, state);
+    return () => {
+      const at = state.subs.indexOf(entry);
+      if (at !== -1) state.subs.splice(at, 1);
+    };
+  }
+  /**
+   * Removes a handler from an event type.
+   *
+   * @param eventType Event type
+   * @param callback A previously subscribed handler
+   */
+  unsubscribe(eventType, callback) {
+    const state = this.registry.get(eventType);
+    if (!state) return;
+    const subs = state.subs;
+    for (let i = 0; i < subs.length; i++) {
+      if (subs[i].callback === callback) {
+        subs.splice(i, 1);
+        break;
+      }
+    }
+  }
+  /**
+   * Dispatches an event: the middleware chain first, then subscribers.
+   *
+   * @param eventType Event type
+   * @param data Payload
+   * @param usedBy Who dispatched — recorded in the metadata
+   */
+  dispatch(eventType, data, usedBy) {
+    const state = this.ensureEvent(eventType, usedBy);
+    const { meta, subs, buffer } = state;
+    if (meta.schema && data !== void 0 && !meta.schema(data)) {
+      lankaLogger.printScenarioLog(`Invalid data for event "${eventType}":`, data);
+      return;
+    }
+    this.logEvent(state, eventType, data);
+    const depth = Math.max(resolveReplayCount(meta.replay), maxReplayDepth(subs));
+    if (depth > 0) {
+      buffer.push(data);
+      while (buffer.length > depth) buffer.shift();
+    } else if (buffer.length > 0) {
+      buffer.length = 0;
+    }
+    const deliver = () => {
+      for (const entry of [...subs]) {
+        try {
+          entry.callback(data);
+        } catch (err) {
+          lankaLogger.printScenarioLog(`Error dispatching event "${eventType}":`, err);
+        }
+      }
+    };
+    for (const middleware of [...this.middlewares]) {
+      let decision;
+      try {
+        decision = middleware(eventType, data);
+      } catch (err) {
+        decision = { stop: err instanceof Error ? err.message : String(err) };
+      }
+      if (decision !== "pass") {
+        this.markStopped(state, decision.stop);
+        lankaLogger.printScenarioLog(
+          `Event "${eventType}" stopped by middleware:`,
+          decision.stop
+        );
+        return;
+      }
+    }
+    deliver();
+  }
+  /** Adds middleware to the shared chain. */
+  addMiddleware(mw) {
+    this.middlewares.push(mw);
+  }
+  /** Removes previously added middleware. */
+  removeMiddleware(mw) {
+    const i = this.middlewares.indexOf(mw);
+    if (i !== -1) this.middlewares.splice(i, 1);
+  }
+  /**
+   * Log of dispatched events.
+   *
+   * @param eventType Limit to one type
+   * @param limit How many recent records to return
+   */
+  getEventLogs(eventType, limit = 100) {
+    if (eventType) {
+      return this.registry.get(eventType)?.logs.slice(-limit) ?? [];
+    }
+    const all = [];
+    for (const { logs } of this.registry.values()) all.push(...logs);
+    return all.slice(-limit);
+  }
+  /** Removes an event together with its subscriptions, log and buffer. */
+  clearEvent(eventType) {
+    this.registry.delete(eventType);
+    const t = this.pendingReplayTimers.get(eventType);
+    if (t) {
+      clearTimeout(t);
+      this.pendingReplayTimers.delete(eventType);
+    }
+  }
+  /** Removes every event and any scheduled replays. */
+  clearAllEvents() {
+    this.registry.clear();
+    for (const t of this.pendingReplayTimers.values()) clearTimeout(t);
+    this.pendingReplayTimers.clear();
+  }
+  /** Full bus reset: events and middleware. */
+  reset() {
+    this.clearAllEvents();
+    this.middlewares = [];
+    this.isEnableLogs = false;
+  }
+  // -------------------------------------------------------------------------
+  // Internal helpers
+  // -------------------------------------------------------------------------
+  /**
+   * Marks the last log record with the reason it was stopped.
+   *
+   * Writes where `logEvent` just put the event: a stop is not a separate
+   * occurrence but this one's outcome.
+   */
+  markStopped(state, reason) {
+    const last = state.logs.at(-1);
+    if (last) last.stoppedBy = reason;
+  }
+  /** Add an event log entry for debugging/auditing. */
+  logEvent(state, eventType, data) {
+    if (this.isEnableLogs) {
+      const cap = state.meta.maxLogs ?? this.defaultMaxLogs;
+      const logs = state.logs;
+      const log = {
+        eventType,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data
+      };
+      log.stackTrace = new Error().stack;
+      logs.push(log);
+      if (logs.length > cap) logs.shift();
+    }
+  }
+  /**
+   * Schedules replay for late subscribers that asked for it.
+   *
+   * Replays are batched into one tick: otherwise ten subscriptions to one event
+   * would make ten separate passes over the same buffer.
+   */
+  scheduleBatchedReplay(eventType, state) {
+    if (this.pendingReplayTimers.has(eventType)) return;
+    const timer = setTimeout(() => {
+      this.pendingReplayTimers.delete(eventType);
+      const { buffer, subs } = state;
+      if (!buffer.length) return;
+      const needReplay = subs.filter((s) => s.replayCount > 0);
+      if (!needReplay.length) return;
+      for (const entry of needReplay) {
+        for (const payload of buffer.slice(-entry.replayCount)) {
+          try {
+            entry.callback(payload);
+          } catch (err) {
+            lankaLogger.printScenarioLog(
+              `Error dispatching event "${eventType}" (replay):`,
+              err
+            );
+          }
+        }
+      }
+      for (const entry of needReplay) entry.replayCount = 0;
+    }, 0);
+    this.pendingReplayTimers.set(eventType, timer);
+  }
+};
+
+// src/bootstrap/_internal/create-lanka-plugin-registry/createLankaPluginRegistry.ts
+var createLankaPluginRegistry = (instance) => {
+  const removers = /* @__PURE__ */ new Map();
+  return {
+    use(plugin) {
+      if (removers.has(plugin.name)) {
+        throw new Error(
+          `Plugin "${plugin.name}" is already registered on this lanka instance. Registering twice almost always means two copies of one policy.`
+        );
+      }
+      const uninstall = plugin.install(instance);
+      const remove = () => {
+        if (!removers.has(plugin.name)) return;
+        removers.delete(plugin.name);
+        uninstall?.();
+      };
+      removers.set(plugin.name, remove);
+      return remove;
+    },
+    removeAll() {
+      for (const remove of [...removers.values()]) remove();
+      removers.clear();
+    }
+  };
+};
+
+// src/bootstrap/_factories/create-lanka/createLanka.ts
+function mergeLankaConfig(previous, patch) {
+  return {
+    // `host` is read field by field: `setConfig({ host: undefined })` through a
+    // spread would leave the instance with no host, and every request URL would
+    // then carry the string "undefined". Flags stay a spread — there both
+    // absent and undefined mean "not set", so nothing can be lost.
+    host: patch.host ?? previous.host,
+    flags: { ...previous.flags, ...patch.flags }
+  };
+}
+function createLanka(config) {
+  let runtimeConfig = mergeLankaConfig(
+    {},
+    { host: config.host, flags: config.flags }
+  );
+  let bootstrapped = false;
+  const eventBus = new LankaEventBusInstance();
+  const scenarios = new LankaScenariosRegistry();
+  const viewModels = new LankaScenarioVMRegistry();
+  const inFlight = createInFlightCounter();
+  const scenarioState = {
+    bootstrapped: false,
+    initialized: /* @__PURE__ */ new WeakSet()
+  };
+  const scopes = /* @__PURE__ */ new Set();
+  const requestMiddleware = [];
+  let requestTimeoutMs;
+  const locators = {
+    gateways: new LankaGatewayLocator(),
+    scenarios: new LankaScenarioLocator(),
+    singletons: new LankaSingletonLocator(),
+    sharedStores: new LankaSharedStoreLocator()
+  };
+  const instance = {
+    eventBus,
+    scenarios,
+    viewModels,
+    inFlight,
+    locators,
+    scenarioState,
+    requestMiddleware,
+    get requestTimeoutMs() {
+      return requestTimeoutMs;
+    },
+    useRequestMiddleware(middleware) {
+      requestMiddleware.push(middleware);
+      return () => {
+        const at = requestMiddleware.indexOf(middleware);
+        if (at !== -1) requestMiddleware.splice(at, 1);
+      };
+    },
+    setRequestTimeout(timeoutMs) {
+      requestTimeoutMs = timeoutMs;
+    },
+    resolve(propertyName) {
+      return locators.singletons.get(propertyName);
+    },
+    use(plugin) {
+      return plugins.use(plugin);
+    },
+    createScope() {
+      const scope = createLankaScope(locators.singletons);
+      scopes.add(scope);
+      return scope;
+    },
+    get config() {
+      return runtimeConfig;
+    },
+    setConfig(patch) {
+      runtimeConfig = mergeLankaConfig(runtimeConfig, patch);
+    },
+    getFlags() {
+      return runtimeConfig.flags ?? {};
+    },
+    isBootstrapped() {
+      return bootstrapped;
+    },
+    activate() {
+      setActiveRuntime(instance);
+    },
+    dispose() {
+      teardown();
+      requestMiddleware.length = 0;
+      requestTimeoutMs = void 0;
+      bootstrapped = false;
+    },
+    async bootstrap(bootstrapConfig = {}) {
+      if (bootstrapped) {
+        lankaLogger.printBootstrapLog("LANKA ALREADY BOOTSTRAPPED");
+        return;
+      }
+      instance.activate();
+      lankaLogger.printBootstrapLog("LANKA BOOTSTRAP START");
+      const plan = createExecutionPlan(bootstrapConfig);
+      await runSequential(plan.syncTasks, "SYNC TASKS");
+      await runParallel(plan.asyncTasks, "ASYNC TASKS");
+      await runSequential(plan.postAsyncTasks, "POST-ASYNC TASKS (lankaScenarios)");
+      bootstrapped = true;
+      lankaLogger.printBootstrapLog("LANKA BOOTSTRAP FINISH");
+    }
+  };
+  function teardown() {
+    for (const scope of scopes) scope.dispose();
+    scopes.clear();
+    plugins.removeAll();
+    viewModels.resetAll();
+    scenarios.clear();
+    eventBus.reset();
+    locators.gateways.clearCache();
+    locators.scenarios.clearCache();
+    locators.singletons.clearCache();
+    locators.sharedStores.clearCache();
+    scenarioState.bootstrapped = false;
+    scenarioState.initialized = /* @__PURE__ */ new WeakSet();
+    if (getActiveRuntime() === instance) setActiveRuntime(null);
+  }
+  const plugins = createLankaPluginRegistry(instance);
+  instance.activate();
+  lankaScenarioBootstrap.adoptDeclaredViewModels();
+  return instance;
+}
+function createExecutionPlan(config) {
+  const syncTasks = [];
+  const asyncTasks = [];
+  const postAsyncTasks = [];
+  config.services?.forEach((service, index) => {
+    const task = {
+      name: service.name || `Service-${index + 1}`,
+      priority: service.priority ?? 0,
+      optional: service.optional ?? false,
+      timeoutMs: service.timeoutMs,
+      execute: service.init
+    };
+    if (service.sync) syncTasks.push(task);
+    else asyncTasks.push(task);
+  });
+  const scenarioSync = config.scenarios?.sync ?? true;
+  const scenarioTask = {
+    name: "LankaScenarioBootstrap",
+    priority: config.scenarios?.priority ?? 0,
+    // The scenario layer is required: without it nothing subscribed to it
+    // works, and continuing silently would start an app where half the screens
+    // never update.
+    optional: false,
+    execute: () => {
+      lankaScenarioBootstrap.bootstrap();
+    }
+  };
+  if (scenarioSync) syncTasks.push(scenarioTask);
+  else postAsyncTasks.push(scenarioTask);
+  syncTasks.sort((a, b) => b.priority - a.priority);
+  return { syncTasks, asyncTasks, postAsyncTasks };
+}
+async function runWithDeadline(task) {
+  if (task.timeoutMs === void 0) {
+    await task.execute();
+    return;
+  }
+  let timer;
+  try {
+    await Promise.race([
+      Promise.resolve(task.execute()),
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(
+          () => reject(
+            new Error(
+              `Service "${task.name}" did not finish within ${String(task.timeoutMs)}ms`
+            )
+          ),
+          task.timeoutMs
+        );
+      })
+    ]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+function handleTaskFailure(task, phaseName, error) {
+  lankaLogger.printBootstrapLog(`[${phaseName}] ERROR IN ${task.name}`, formatError(error));
+  if (!task.optional) throw error;
+  lankaLogger.printBootstrapLog(`[${phaseName}] SKIPPED (optional): ${task.name}`);
+}
+async function runSequential(tasks, phaseName) {
+  if (tasks.length === 0) return;
+  for (const task of tasks) {
+    try {
+      lankaLogger.printBootstrapLog(
+        `[${phaseName}] EXECUTING: ${task.name} (Priority: ${String(task.priority)})`
+      );
+      await runWithDeadline(task);
+    } catch (error) {
+      handleTaskFailure(task, phaseName, error);
+    }
+  }
+}
+async function runParallel(tasks, phaseName) {
+  if (tasks.length === 0) return;
+  lankaLogger.printBootstrapLog(
+    `[${phaseName}] EXECUTING ${String(tasks.length)} TASKS IN PARALLEL`
+  );
+  const outcomes = await Promise.allSettled(
+    tasks.map(async (task) => {
+      lankaLogger.printBootstrapLog(`[${phaseName}] EXECUTING: ${task.name}`);
+      await runWithDeadline(task);
+    })
+  );
+  for (const [index, outcome] of outcomes.entries()) {
+    if (outcome.status === "rejected") {
+      handleTaskFailure(tasks[index], phaseName, outcome.reason);
+    }
+  }
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/bootstrap/start-lanka/startLanka.ts
+var hostOf = (config) => config.host ?? createLankaHost({ apiBaseUrl: config.apiBaseUrl, ...config.messages });
+var startLanka = async (config = {}) => {
+  const lanka = createLanka({ host: hostOf(config), flags: config.flags });
+  for (const plugin of config.plugins ?? []) lanka.use(plugin);
+  await lanka.bootstrap({ services: config.services, scenarios: config.scenarios });
+  return lanka;
+};
+
+// src/bootstrap/reset-active-lanka/resetActiveLanka.ts
+function resetActiveLanka() {
+  const active = getActiveRuntime();
+  if (!active) return;
+  active.viewModels.resetAll();
+  active.scenarios.clear();
+  active.eventBus.clearAllEvents();
+  active.scenarioState.bootstrapped = false;
+  active.scenarioState.initialized = /* @__PURE__ */ new WeakSet();
+}
+
+// src/bootstrap/_abstractions/lanka-plugin/ALankaPlugin.ts
+var ALankaPlugin = class {
+  /**
+   * Removes what `onInstall` put in place.
+   *
+   * A default that does nothing rather than an abstract member: an abstract one
+   * would break every existing subclass the day it was added, and most plugins
+   * genuinely have nothing to undo.
+   */
+  onUninstall() {
+  }
+  install(lanka) {
+    this.onInstall(lanka);
+    return () => {
+      this.onUninstall();
+    };
+  }
+};
+
+export {
+  createLanka,
+  startLanka,
+  resetActiveLanka,
+  ALankaPlugin
+};
+//# sourceMappingURL=chunk-RYFZCAQ3.js.map