lanka 1.0.0

package/dist/locator/index.js

@@ -0,0 +1,67 @@
+import {
+  createLankaLocatorProxy,
+  lankaSharedStores,
+  lankaSingletons
+} from "../chunk-DTO27QFR.js";
+import "../chunk-ILQNYQY5.js";
+import {
+  requireActiveRuntime
+} from "../chunk-BGVDPDX4.js";
+
+// src/locator/gateway/_facades/lanka-gateways/lankaGateways.ts
+var gatewayLocator = {
+  get: (propertyName) => requireActiveRuntime().locators.gateways.get(propertyName)
+};
+var lankaGateways = createLankaLocatorProxy({
+  locator: gatewayLocator,
+  protectedProperties: ["clearCache"],
+  errorPrefix: "Cannot access gateway"
+});
+
+// src/locator/scenario/_facades/lanka-scenarios/lankaScenarios.ts
+var scenarioLocator = {
+  get: (propertyName) => requireActiveRuntime().locators.scenarios.get(propertyName)
+};
+var lankaScenarios = createLankaLocatorProxy({
+  locator: scenarioLocator,
+  errorPrefix: "Cannot access scenario"
+});
+
+// src/locator/singleton/_abstractions/lanka-singleton/ALankaSingleton.ts
+var ALankaSingleton = class _ALankaSingleton {
+  /**
+   * A runtime check, for the locator, which cannot see types.
+   *
+   * Looks at the prototype chain rather than the name: names are lost to
+   * minification, and a name check would work only until the build.
+   */
+  static is(candidate) {
+    if (typeof candidate !== "function") return false;
+    let proto = Object.getPrototypeOf(candidate);
+    while (typeof proto === "function") {
+      if (proto === _ALankaSingleton) return true;
+      proto = Object.getPrototypeOf(proto);
+    }
+    return false;
+  }
+};
+
+// src/locator/singleton/_factories/create-lanka-singleton/createLankaSingleton.ts
+var createLankaSingleton = (build) => {
+  class FunctionalSingleton extends ALankaSingleton {
+    constructor() {
+      super();
+      return build();
+    }
+  }
+  return FunctionalSingleton;
+};
+export {
+  ALankaSingleton,
+  createLankaSingleton,
+  lankaGateways,
+  lankaScenarios,
+  lankaSharedStores,
+  lankaSingletons
+};
+//# sourceMappingURL=index.js.map

package/dist/locator/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/locator/gateway/_facades/lanka-gateways/lankaGateways.ts","../../src/locator/scenario/_facades/lanka-scenarios/lankaScenarios.ts","../../src/locator/singleton/_abstractions/lanka-singleton/ALankaSingleton.ts","../../src/locator/singleton/_factories/create-lanka-singleton/createLankaSingleton.ts"],"sourcesContent":["import { requireActiveRuntime } from \"../../../../_internal/active-runtime/activeRuntime\";\nimport type { ILankaLocator } from \"../../../_interfaces/ILankaLocator\";\nimport type { TLankaGateways } from \"../../_types/TLankaGateways\";\nimport { createLankaLocatorProxy } from \"../../../_factories/create-lanka-locator-proxy/createLankaLocatorProxy\";\nimport type { ALankaGateway } from \"../../../../gateway/_abstractions/lanka-gateway/ALankaGateway\";\n\n/**\n * The locator comes from the active instance rather than being created here.\n *\n * The cache of resolved objects is state, and module-level state would let two\n * frameworks in one process resolve the same gateway. The proxy stays at module\n * level because it has hundreds of call sites; only the cache moved.\n */\nconst gatewayLocator: ILankaLocator<ALankaGateway<unknown>> = {\n\tget: (propertyName: string) => requireActiveRuntime().locators.gateways.get(propertyName),\n};\n\n/**\n * Access to every gateway at once.\n *\n * An `ALankaGateway` subclass appears here by itself. The property is camelCase,\n * the gateway name is PascalCase.\n *\n * ```ts\n * import { lankaGateways } from \"lanka\";\n *\n * const user = await lankaGateways.userGateway.getById(1);\n * const list = await lankaGateways.companyGateway.getList({ page: 1 });\n * ```\n */\nexport const lankaGateways = createLankaLocatorProxy<ALankaGateway<unknown>, TLankaGateways>({\n\tlocator: gatewayLocator,\n\tprotectedProperties: [\"clearCache\"],\n\terrorPrefix: \"Cannot access gateway\",\n});\n","import { requireActiveRuntime } from \"../../../../_internal/active-runtime/activeRuntime\";\nimport type { ILankaLocator } from \"../../../_interfaces/ILankaLocator\";\nimport { createLankaLocatorProxy } from \"../../../_factories/create-lanka-locator-proxy/createLankaLocatorProxy\";\nimport type { ILankaScenario } from \"../../../../scenario/_interfaces/ILankaScenario\";\nimport { TLankaScenarios } from \"../../_types/TLankaScenarios\";\n\n/**\n * The locator comes from the active instance rather than being created here.\n *\n * The cache of resolved objects is state, and module-level state would let two\n * frameworks in one process resolve the same scenario. The proxy stays at module\n * level because it has hundreds of call sites; only the cache moved.\n */\nconst scenarioLocator: ILankaLocator<ILankaScenario<unknown>> = {\n\tget: (propertyName: string) => requireActiveRuntime().locators.scenarios.get(propertyName),\n};\n\n/**\n * Access to every scenario at once.\n *\n * An `ALankaScenario` subclass appears here by itself. The property is camelCase,\n * the scenario name is PascalCase.\n *\n * ```ts\n * import { lankaScenarios } from \"lanka\";\n *\n * lankaScenarios.sessionUpdated.trigger({ user });\n * lankaScenarios.usersListRefresh.trigger({ reason: \"create\" });\n *\n * lankaScenarios.usersListRefresh.subscribe((data) => { ... });\n * ```\n */\nexport const lankaScenarios = createLankaLocatorProxy<ILankaScenario<unknown>, TLankaScenarios>({\n\tlocator: scenarioLocator,\n\terrorPrefix: \"Cannot access scenario\",\n});\n","/**\n * The singleton marker: \"this class is published by the application in\n * `lankaSingletons`\".\n *\n * ## Why a marker when the class is exported anyway\n *\n * The other three locators have one: a gateway extends `ALankaGateway`, a\n * scenario has a `name`, a store extends `ALankaSharedStore`. Without a marker\n * the selection is \"anything that is a function with a prototype\", so a stray\n * export in the barrel — a helper, a companion class, an accidental re-export —\n * becomes part of the public `lankaSingletons.*`, and a typo in a name is caught\n * at runtime on first use, far from where it was made.\n *\n * ## A base class rather than a field\n *\n * A marker field can be put on anything, an object included, and the type would\n * again stop telling a class from a non-class. Inheritance also gives TypeScript\n * something it can select on in a mapped type.\n *\n * The class is empty deliberately: all it carries is the statement \"I am meant\n * for the locator\".\n */\nexport abstract class ALankaSingleton {\n\t/**\n\t * A runtime check, for the locator, which cannot see types.\n\t *\n\t * Looks at the prototype chain rather than the name: names are lost to\n\t * minification, and a name check would work only until the build.\n\t */\n\tstatic is(candidate: unknown): boolean {\n\t\tif (typeof candidate !== \"function\") return false;\n\n\t\tlet proto: unknown = Object.getPrototypeOf(candidate) as unknown;\n\t\twhile (typeof proto === \"function\") {\n\t\t\tif (proto === ALankaSingleton) return true;\n\t\t\tproto = Object.getPrototypeOf(proto) as unknown;\n\t\t}\n\t\treturn false;\n\t}\n}\n","import { ALankaSingleton } from \"../../_abstractions/lanka-singleton/ALankaSingleton\";\n\n/**\n * The functional style of `ALankaSingleton`: a singleton declared by a function.\n *\n * A singleton is a role — an application writes many — and this is the same role\n * the class style declares by extending the marker. What comes back IS a subclass\n * of `ALankaSingleton`, so the locator discovers it in the consumer's barrel,\n * builds it on first use and caches it, exactly as it does a hand-written class.\n *\n * ```ts\n * export const PlaygroundClock = createLankaSingleton(() => ({\n * \tnow: () => Date.now(),\n * }));\n * ```\n *\n * The result is exported under a PascalCase name because it is a class: the\n * locator resolves `lankaSingletons.playgroundClock` by that export name, and a\n * camelCase one would read as the instance while being the constructor.\n *\n * The builder runs at first resolution, not here — a singleton declared in a\n * module body must not touch a runtime that does not exist yet. Canon:\n * `skills/parity/SKILL.md`.\n */\nexport const createLankaSingleton = <TInstance extends object>(\n\tbuild: () => TInstance,\n): new () => TInstance => {\n\tclass FunctionalSingleton extends ALankaSingleton {\n\t\tpublic constructor() {\n\t\t\tsuper();\n\n\t\t\t// A constructor answering an object is what makes the two styles one\n\t\t\t// implementation: the locator constructs a marked class either way, and\n\t\t\t// what it gets back is what the builder returned.\n\t\t\treturn build();\n\t\t}\n\t}\n\n\treturn FunctionalSingleton as unknown as new () => TInstance;\n};\n"],"mappings":";;;;;;;;;;;AAaA,IAAM,iBAAwD;AAAA,EAC7D,KAAK,CAAC,iBAAyB,qBAAqB,EAAE,SAAS,SAAS,IAAI,YAAY;AACzF;AAeO,IAAM,gBAAgB,wBAAgE;AAAA,EAC5F,SAAS;AAAA,EACT,qBAAqB,CAAC,YAAY;AAAA,EAClC,aAAa;AACd,CAAC;;;ACrBD,IAAM,kBAA0D;AAAA,EAC/D,KAAK,CAAC,iBAAyB,qBAAqB,EAAE,SAAS,UAAU,IAAI,YAAY;AAC1F;AAiBO,IAAM,iBAAiB,wBAAkE;AAAA,EAC/F,SAAS;AAAA,EACT,aAAa;AACd,CAAC;;;ACbM,IAAe,kBAAf,MAAe,iBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOrC,OAAO,GAAG,WAA6B;AACtC,QAAI,OAAO,cAAc,WAAY,QAAO;AAE5C,QAAI,QAAiB,OAAO,eAAe,SAAS;AACpD,WAAO,OAAO,UAAU,YAAY;AACnC,UAAI,UAAU,iBAAiB,QAAO;AACtC,cAAQ,OAAO,eAAe,KAAK;AAAA,IACpC;AACA,WAAO;AAAA,EACR;AACD;;;ACfO,IAAM,uBAAuB,CACnC,UACyB;AAAA,EACzB,MAAM,4BAA4B,gBAAgB;AAAA,IAC1C,cAAc;AACpB,YAAM;AAKN,aAAO,MAAM;AAAA,IACd;AAAA,EACD;AAEA,SAAO;AACR;","names":[]}

package/dist/logger/index.d.ts

@@ -0,0 +1,146 @@
+type TLankaLogMessage = string | number | boolean | object | null | undefined;
+
+type TLankaLogMessageFactory = () => TLankaLogMessage;
+
+type TLankaLoggerFn = (msg: TLankaLogMessage | TLankaLogMessageFactory, ...args: unknown[]) => void;
+
+type TLankaLoggerFlagValue = boolean | (() => boolean);
+
+type TLankaConsoleLevel = "log" | "info" | "warn" | "error" | "debug";
+
+type TLankaLoggerStyle = "badge" | "plain";
+
+interface ILankaLoggerSink {
+    emit: (entry: {
+        layer: string;
+        level: TLankaConsoleLevel;
+        style: TLankaLoggerStyle;
+        color?: string;
+        message: TLankaLogMessage;
+        args: unknown[];
+    }) => void;
+}
+
+interface ILankaLoggerConfig {
+    /**
+     * Unique printer key, used for later updates / retrieval.
+     * Example: "printGatewayLog" or "printMyFeatureLog"
+     */
+    key: string;
+    /**
+     * Short label for the log prefix.
+     * Example: "GW" / "SC" / "VM" / "MOD" / "MY"
+     */
+    layer: string;
+    /**
+     * Optional badge color (used in "badge" style).
+     */
+    color?: string;
+    /**
+     * Console level (log/info/warn/error/debug).
+     */
+    level?: TLankaConsoleLevel;
+    /**
+     * If provided, printer is enabled only when the flag is enabled.
+     */
+    flag?: string;
+    /**
+     * Hard enable/disable of the printer (has priority over `flag`).
+     */
+    enabled?: TLankaLoggerFlagValue;
+}
+
+/**
+ * Output that is not bound to the console, and is silent in production.
+ *
+ * The ambient one is `lankaLogger`, and it is what an application and the
+ * framework both write: `lankaLogger.printGatewayLog(...)`. The class is here for
+ * the reason node exposes `Console` beside `console` — a second logger with its
+ * own sinks, flags and printers is a real thing to want, and a test that builds
+ * one is not fighting a global.
+ *
+ * ```ts
+ * const audit = new LankaLogger();
+ * audit.silent();
+ * audit.addSink({ emit: (entry) => rows.push(entry) });
+ * ```
+ *
+ * Every method is a no-op in production, checked per call rather than once at
+ * import: a flag flipped at runtime must not be able to start the log.
+ */
+declare class LankaLogger {
+    private style;
+    private sinks;
+    private readonly flags;
+    private readonly printers;
+    /** The gateway layer's printer. */
+    readonly printGatewayLog: TLankaLoggerFn;
+    /** The scenario layer's printer. */
+    readonly printScenarioLog: TLankaLoggerFn;
+    /** The ViewModel layer's printer. */
+    readonly printViewModelLog: TLankaLoggerFn;
+    /** The view layer's printer. */
+    readonly printViewLog: TLankaLoggerFn;
+    /** The bootstrap sequence's printer. */
+    readonly printBootstrapLog: TLankaLoggerFn;
+    constructor();
+    /**
+     * Enables or silences the WHOLE log, overriding the environment.
+     *
+     * Equivalent to setting the `ENABLED` flag.
+     */
+    setEnabled(value: boolean): void;
+    /** Switches output between badges and plain text. */
+    setStyle(style: TLankaLoggerStyle): void;
+    /**
+     * Goes completely silent by removing the sinks; config and printers remain.
+     *
+     * Output is restored with `resetSinks()` or `addSink()`.
+     */
+    silent(): void;
+    /** Restores the single default sink: the console. */
+    resetSinks(): void;
+    addSink(sink: ILankaLoggerSink): void;
+    removeSink(sink: ILankaLoggerSink): void;
+    /**
+     * Declares a flag the printers use, or overrides an existing one.
+     *
+     * The value may be a boolean or a resolver function — for example one reading
+     * localStorage.
+     */
+    setFlag(flag: string, value: TLankaLoggerFlagValue): void;
+    /** Removes a flag override, falling back to the environment value. */
+    unsetFlag(flag: string): void;
+    isFlagEnabled(flag: string): boolean;
+    /**
+     * Registers a printer, or replaces an existing one.
+     *
+     * @returns The callable bound to this printer
+     */
+    registerPrinter(config: ILankaLoggerConfig): TLankaLoggerFn;
+    /** Updates a printer's config; a no-op when there is no such printer. */
+    updatePrinter(key: string, patch: Partial<Omit<ILankaLoggerConfig, "key">>): void;
+    /** A printer by key; a silent function when there is none. */
+    getPrinter(key: string): TLankaLoggerFn;
+    /** The keys of every registered printer. */
+    listPrinters(): string[];
+    private isEnabled;
+    private isPrinterEnabled;
+    private emit;
+    /**
+     * A printer resolved at CALL time, not at registration.
+     *
+     * `updatePrinter` has to reach a callable a screen took a reference to long
+     * before; looking the key up on every call is what makes that true.
+     */
+    private createPrinterFn;
+}
+/**
+ * The logger the framework itself writes to, and an application with it.
+ *
+ * `console` to this file's `Console`: ready before anything is configured, and
+ * the one every call site in the framework uses.
+ */
+declare const lankaLogger: LankaLogger;
+
+export { type ILankaLoggerConfig, type ILankaLoggerSink, LankaLogger, type TLankaConsoleLevel, type TLankaLogMessage, type TLankaLogMessageFactory, type TLankaLoggerFlagValue, type TLankaLoggerFn, type TLankaLoggerStyle, lankaLogger };

package/dist/logger/index.js

@@ -0,0 +1,11 @@
+import {
+  LankaLogger,
+  lankaLogger
+} from "../chunk-C2HP7CRD.js";
+import "../chunk-D27MREPB.js";
+import "../chunk-BGVDPDX4.js";
+export {
+  LankaLogger,
+  lankaLogger
+};
+//# sourceMappingURL=index.js.map

package/dist/logger/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/mock/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Builds a mock handler for a gateway method: logging, delay, dynamic module
+ * loading and extraction of the data itself.
+ *
+ * Returns `undefined` while mock mode is off, which is what lets a bundler drop
+ * all mock code from a production build.
+ *
+ * @param importFactory Dynamic import: `() => import("../mocks/user")`
+ * @param extractor Extracts and validates data from the imported module
+ * @param name Action name for the log; taken from the stack trace when omitted
+ * @param delayMs Delay before answering
+ * @returns The mock data, or `undefined` when mocks are disabled
+ */
+declare function createLankaMockHandler<T, M>(importFactory: () => Promise<M>, extractor: (module: M) => T | Promise<T>, name?: string, delayMs?: number): (() => Promise<T>) | undefined;
+
+export { createLankaMockHandler };

package/dist/mock/index.js

@@ -0,0 +1,58 @@
+import {
+  lankaLogger
+} from "../chunk-C2HP7CRD.js";
+import {
+  getLankaFlags
+} from "../chunk-D27MREPB.js";
+import "../chunk-BGVDPDX4.js";
+
+// src/_internal/sleep.ts
+var sleep = (ms = 300) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+
+// src/mock/_factories/create-lanka-mock-handler/createLankaMockHandler.ts
+function createLankaMockHandler(importFactory, extractor, name, delayMs) {
+  const flags = getLankaFlags();
+  if (flags.isProduction || !flags.isMockMode) {
+    return void 0;
+  }
+  return async () => {
+    const actionName = name ?? readActionNameFromStack() ?? "Unknown";
+    lankaLogger.printGatewayLog(`MOCK: ${actionName}`);
+    const wait = delayMs ?? 300;
+    if (wait > 0) {
+      await sleep(wait);
+    }
+    try {
+      const module = await importFactory();
+      return await extractor(module);
+    } catch (error) {
+      lankaLogger.printGatewayLog(
+        `MOCK ERROR (${actionName}): Failed to load or extract mock`,
+        error
+      );
+      throw error;
+    }
+  };
+}
+function readActionNameFromStack() {
+  try {
+    const stack = new Error().stack;
+    if (!stack) return void 0;
+    const lines = stack.split(String.fromCharCode(10));
+    for (let i = 3; i < lines.length; i++) {
+      const match = /\.(\w+)\s*\(/.exec(lines[i]);
+      const methodName = match?.[1];
+      if (methodName && !["requestJson", "request", "execute"].includes(methodName)) {
+        return methodName;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+export {
+  createLankaMockHandler
+};
+//# sourceMappingURL=index.js.map

package/dist/mock/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/_internal/sleep.ts","../../src/mock/_factories/create-lanka-mock-handler/createLankaMockHandler.ts"],"sourcesContent":["export const sleep = (ms: number = 300): Promise<void> => {\n\treturn new Promise((resolve) => setTimeout(resolve, ms));\n};\n","import { getLankaFlags } from \"../../../config/get-lanka-flags/getLankaFlags\";\nimport { sleep } from \"../../../_internal/sleep\";\nimport { lankaLogger } from \"../../../logger/lanka-logger/LankaLogger\";\n\n/**\n * Builds a mock handler for a gateway method: logging, delay, dynamic module\n * loading and extraction of the data itself.\n *\n * Returns `undefined` while mock mode is off, which is what lets a bundler drop\n * all mock code from a production build.\n *\n * @param importFactory Dynamic import: `() => import(\"../mocks/user\")`\n * @param extractor Extracts and validates data from the imported module\n * @param name Action name for the log; taken from the stack trace when omitted\n * @param delayMs Delay before answering\n * @returns The mock data, or `undefined` when mocks are disabled\n */\nexport function createLankaMockHandler<T, M>(\n\timportFactory: () => Promise<M>,\n\textractor: (module: M) => T | Promise<T>,\n\tname?: string,\n\tdelayMs?: number,\n): (() => Promise<T>) | undefined {\n\tconst flags = getLankaFlags();\n\n\tif (flags.isProduction || !flags.isMockMode) {\n\t\treturn undefined;\n\t}\n\n\treturn async (): Promise<T> => {\n\t\t// The action name is a PARAMETER. Deriving it from a stack trace works only\n\t\t// until minification: function names disappear in a built bundle, and mock\n\t\t// mode is enabled in exactly such a bundle — so the mechanism breaks where\n\t\t// it is used.\n\t\t//\n\t\t// Stack parsing remains as a fallback, for development only, where the\n\t\t// stack is still readable.\n\t\tconst actionName = name ?? readActionNameFromStack() ?? \"Unknown\";\n\n\t\tlankaLogger.printGatewayLog(`MOCK: ${actionName}`);\n\n\t\tconst wait = delayMs ?? 300;\n\t\tif (wait > 0) {\n\t\t\tawait sleep(wait);\n\t\t}\n\n\t\ttry {\n\t\t\tconst module = await importFactory();\n\t\t\treturn await extractor(module);\n\t\t} catch (error) {\n\t\t\tlankaLogger.printGatewayLog(\n\t\t\t\t`MOCK ERROR (${actionName}): Failed to load or extract mock`,\n\t\t\t\terror,\n\t\t\t);\n\t\t\tthrow error;\n\t\t}\n\t};\n}\n\n/**\n * Extracts a gateway method name from a stack trace.\n *\n * A fallback, and an unreliable one: in built code function names are minified\n * and there is nothing to read. Returns `undefined` rather than an invented\n * name.\n */\nfunction readActionNameFromStack(): string | undefined {\n\ttry {\n\t\tconst stack = new Error().stack;\n\t\tif (!stack) return undefined;\n\n\t\tconst lines = stack.split(String.fromCharCode(10));\n\t\tfor (let i = 3; i < lines.length; i++) {\n\t\t\tconst match = /\\.(\\w+)\\s*\\(/.exec(lines[i]);\n\t\t\tconst methodName = match?.[1];\n\t\t\tif (methodName && ![\"requestJson\", \"request\", \"execute\"].includes(methodName)) {\n\t\t\t\treturn methodName;\n\t\t\t}\n\t\t}\n\t} catch {\n\t\t// Stack format is not standardised; a missing name is no reason to throw.\n\t}\n\treturn undefined;\n}\n"],"mappings":";;;;;;;;;AAAO,IAAM,QAAQ,CAAC,KAAa,QAAuB;AACzD,SAAO,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,EAAE,CAAC;AACxD;;;ACeO,SAAS,uBACf,eACA,WACA,MACA,SACiC;AACjC,QAAM,QAAQ,cAAc;AAE5B,MAAI,MAAM,gBAAgB,CAAC,MAAM,YAAY;AAC5C,WAAO;AAAA,EACR;AAEA,SAAO,YAAwB;AAQ9B,UAAM,aAAa,QAAQ,wBAAwB,KAAK;AAExD,gBAAY,gBAAgB,SAAS,UAAU,EAAE;AAEjD,UAAM,OAAO,WAAW;AACxB,QAAI,OAAO,GAAG;AACb,YAAM,MAAM,IAAI;AAAA,IACjB;AAEA,QAAI;AACH,YAAM,SAAS,MAAM,cAAc;AACnC,aAAO,MAAM,UAAU,MAAM;AAAA,IAC9B,SAAS,OAAO;AACf,kBAAY;AAAA,QACX,eAAe,UAAU;AAAA,QACzB;AAAA,MACD;AACA,YAAM;AAAA,IACP;AAAA,EACD;AACD;AASA,SAAS,0BAA8C;AACtD,MAAI;AACH,UAAM,QAAQ,IAAI,MAAM,EAAE;AAC1B,QAAI,CAAC,MAAO,QAAO;AAEnB,UAAM,QAAQ,MAAM,MAAM,OAAO,aAAa,EAAE,CAAC;AACjD,aAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACtC,YAAM,QAAQ,eAAe,KAAK,MAAM,CAAC,CAAC;AAC1C,YAAM,aAAa,QAAQ,CAAC;AAC5B,UAAI,cAAc,CAAC,CAAC,eAAe,WAAW,SAAS,EAAE,SAAS,UAAU,GAAG;AAC9E,eAAO;AAAA,MACR;AAAA,IACD;AAAA,EACD,QAAQ;AAAA,EAER;AACA,SAAO;AACR;","names":[]}

package/dist/role/index.d.ts

@@ -0,0 +1,48 @@
+/** What a role's bridge hands over: the instance, and its protected surface. */
+interface ILankaRoleOpening<TInstance, TContext> {
+    instance: TInstance;
+    context: TContext;
+}
+/**
+ * Builds a role's instance and opens its protected surface.
+ *
+ * Written in the role's own module, because that is the only place the language
+ * allows: `protected` is readable from inside a class body deriving from the
+ * base and nowhere else. A generic helper cannot reach it, and a base that made
+ * it public would put its whole extension surface on every object a consumer
+ * writes.
+ */
+type TLankaRoleOpener<TConfig, TInstance, TContext> = (config: TConfig) => ILankaRoleOpening<TInstance, TContext>;
+/**
+ * The functional style of one role: call it with hooks, or with nothing.
+ *
+ * With `build` it answers what the hooks returned — the methods a gateway
+ * declares, the actions a ViewModel exposes. Without it, the instance itself,
+ * which is what a role whose whole body is data needs.
+ */
+interface ILankaRoleFactory<TConfig, TInstance, TContext> {
+    <TResult>(config: TConfig & {
+        build: (context: TContext) => TResult;
+    }): TResult;
+    (config: TConfig): TInstance;
+}
+/**
+ * Turns a role's class into its factory, over one implementation.
+ *
+ * The two styles of a role are not two implementations: the factory builds the
+ * SAME class and hands its protected surface to the caller as an object. A
+ * behaviour fix lands in both styles at once, and a divergence is not something
+ * a reviewer has to notice — it cannot be written.
+ *
+ * It is published because a consumer with a layer of their own — a repository, a
+ * command, a presenter — gets both styles for it from one line:
+ *
+ * ```ts
+ * export const createRepository = defineLankaRole(openRepository);
+ * ```
+ *
+ * Canon: `skills/parity/SKILL.md`.
+ */
+declare const defineLankaRole: <TConfig, TInstance, TContext>(open: TLankaRoleOpener<TConfig, TInstance, TContext>) => ILankaRoleFactory<TConfig, TInstance, TContext>;
+
+export { type ILankaRoleFactory, type ILankaRoleOpening, type TLankaRoleOpener, defineLankaRole };

package/dist/role/index.js

@@ -0,0 +1,7 @@
+import {
+  defineLankaRole
+} from "../chunk-MDZ42XRH.js";
+export {
+  defineLankaRole
+};
+//# sourceMappingURL=index.js.map

package/dist/role/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/scenario/index.d.ts

@@ -0,0 +1,204 @@
+import { a as ILankaScenario, T as TLankaReplayRequest, b as ILankaEventMetadata, c as TLankaEventBusMiddleware, d as ILankaEventLog, I as ILankaScenarioVM } from '../ILankaScenarioVM-DuCyPoyT.js';
+export { e as TLankaEventBusDecision } from '../ILankaScenarioVM-DuCyPoyT.js';
+export { I as ILankaScenarioMetadata } from '../ILankaScenarioMetadata-Bu-yggTZ.js';
+
+/**
+ * The base of a scenario — a named unit of coordination over the event bus.
+ *
+ * A subclass declares `name`, `eventType` and `dataTypeName`, calls `trigger()`
+ * when the event happens, and ViewModels subscribe to it and unsubscribe.
+ *
+ * Scenarios register THEMSELVES unless the subclass sets the static
+ * `skipAutoRegistration`.
+ *
+ * ```ts
+ * export class SessionUpdated extends ALankaScenario<TSession> {
+ *   readonly name = "SessionUpdated";
+ *   readonly eventType = "session.updated";
+ *   readonly dataTypeName = "TSession";
+ * }
+ * ```
+ */
+declare abstract class ALankaScenario<TData = void> implements ILankaScenario<TData> {
+    abstract readonly name: string;
+    abstract readonly eventType: string;
+    abstract readonly dataTypeName: string;
+    /** A subclass sets this to opt out of self-registration. */
+    static skipAutoRegistration?: boolean;
+    /**
+     * 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.
+     */
+    private static autoRegisteredScenarios;
+    /** Registers the scenario itself unless the subclass opted out. */
+    constructor();
+    /**
+     * Every scenario that registered itself.
+     *
+     * @internal
+     */
+    static getAutoRegisteredScenarios(): ALankaScenario<unknown>[];
+    /**
+     * Clears the auto-registration pool. Required by tests.
+     * @internal
+     */
+    static clearAutoRegisteredScenarios(): void;
+    /**
+     * Registers the scenario by hand.
+     *
+     * @returns `false` when it was already registered
+     */
+    register(): boolean;
+    /**
+     * Removes the scenario from the registry.
+     *
+     * @returns `false` when it was not there
+     */
+    unregister(): boolean;
+    trigger(data?: TData): void;
+    /**
+     * 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: (data?: TData) => void, options?: {
+        priority?: number;
+        replay?: TLankaReplayRequest;
+        usedBy?: string;
+    }): () => void;
+}
+
+/** What a scenario is: three names and nothing else. */
+interface ILankaScenarioConfig {
+    /** The scenario's name, and the key it is found by. */
+    name: string;
+    /** The event type on the bus. */
+    eventType: string;
+    /** The event data's type name — for the bus metadata. */
+    dataTypeName: string;
+    /** Opts out of self-registration, as `skipAutoRegistration` does on a class. */
+    skipAutoRegistration?: boolean;
+}
+/**
+ * A scenario, without writing a class whose body is data.
+ *
+ * The class style is right where a scenario has behaviour — an `initialize` that
+ * warms something, a `cleanup` that lets go. Most have neither: in the two
+ * applications this framework grew out of, every scenario is a class holding
+ * three `readonly` fields and nothing else.
+ *
+ * One implementation: this builds a subclass of `ALankaScenario`, so
+ * self-registration, `trigger` and `subscribe` are the same code either way.
+ */
+declare const createLankaScenario: <TData = void>(config: ILankaScenarioConfig) => ILankaScenario<TData>;
+
+declare const lankaEventBus: Readonly<{
+    enableLogs: () => void;
+    disableLogs: () => void;
+    registerEvent: (eventType: string, metadata: ILankaEventMetadata) => void;
+    getRegisteredEvents: () => {
+        eventType: string;
+        metadata: ILankaEventMetadata;
+    }[];
+    getEventInfo: (eventType: string) => ILankaEventMetadata | null;
+    getSubscriptions: (eventType: string) => number;
+    subscribe: <T>(eventType: string, callback: (data: T) => void, options?: {
+        priority?: number;
+        replay?: TLankaReplayRequest;
+        usedBy?: string;
+    }) => (() => void);
+    unsubscribe: <T>(eventType: string, callback: (data: T) => void) => void;
+    dispatch: <T>(eventType: string, data?: T, usedBy?: string) => void;
+    addMiddleware: <T>(middleware: TLankaEventBusMiddleware<T>) => void;
+    removeMiddleware: <T>(middleware: TLankaEventBusMiddleware<T>) => void;
+    getEventLogs: (eventType?: string, limit?: number) => ILankaEventLog[];
+    clearEvent: (eventType: string) => void;
+    clearAllEvents: () => void;
+    reset: () => void;
+}>;
+
+/**
+ * Bootstrapping the scenario layer, for callers with no instance in hand.
+ *
+ * An ordinary class with an ordinary instance: the declared-ViewModel list below
+ * is deliberately shared across instances — every test builds a new framework and
+ * module-level ViewModels are declared once — so the single instance IS the
+ * shared list, and a second one would be a second list nobody adopts.
+ */
+declare class LankaScenarioBootstrap {
+    /**
+     * 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.
+     */
+    private get state();
+    isScenarioLayerBootstrapped(): boolean;
+    private forceInstantiateAllScenarios;
+    private registerScenarioEvents;
+    private initializeAlreadyCreatedViewModels;
+    /**
+     * 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(): void;
+    /**
+     * 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.
+     */
+    private readonly declaredViewModels;
+    /** Registers everything declared into a NEW instance. Called by `createLanka`. */
+    adoptDeclaredViewModels(): void;
+    registerViewModel(viewModel: ILankaScenarioVM, name?: string): void;
+    private attachViewModel;
+    /**
+     * 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.
+     */
+    reset(): void;
+}
+/** The one every caller wants. */
+declare const lankaScenarioBootstrap: LankaScenarioBootstrap;
+
+export { ALankaScenario, ILankaEventLog, ILankaEventMetadata, ILankaScenario, type ILankaScenarioConfig, ILankaScenarioVM, TLankaEventBusMiddleware, TLankaReplayRequest, createLankaScenario, lankaEventBus, lankaScenarioBootstrap };

package/dist/scenario/index.js

@@ -0,0 +1,28 @@
+import {
+  lankaScenarioBootstrap
+} from "../chunk-Q3SOVBIJ.js";
+import {
+  ALankaScenario,
+  lankaEventBus
+} from "../chunk-EWVDJYCC.js";
+import "../chunk-C2HP7CRD.js";
+import "../chunk-D27MREPB.js";
+import "../chunk-BGVDPDX4.js";
+
+// src/scenario/_factories/create-lanka-scenario/createLankaScenario.ts
+var createLankaScenario = (config) => {
+  class FunctionalScenario extends ALankaScenario {
+    static skipAutoRegistration = config.skipAutoRegistration ?? false;
+    name = config.name;
+    eventType = config.eventType;
+    dataTypeName = config.dataTypeName;
+  }
+  return new FunctionalScenario();
+};
+export {
+  ALankaScenario,
+  createLankaScenario,
+  lankaEventBus,
+  lankaScenarioBootstrap
+};
+//# sourceMappingURL=index.js.map

package/dist/scenario/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/scenario/_factories/create-lanka-scenario/createLankaScenario.ts"],"sourcesContent":["import { ALankaScenario } from \"../../_abstractions/lanka-scenario/ALankaScenario\";\nimport type { ILankaScenario } from \"../../_interfaces/ILankaScenario\";\n\n/** What a scenario is: three names and nothing else. */\nexport interface ILankaScenarioConfig {\n\t/** The scenario's name, and the key it is found by. */\n\tname: string;\n\t/** The event type on the bus. */\n\teventType: string;\n\t/** The event data's type name — for the bus metadata. */\n\tdataTypeName: string;\n\t/** Opts out of self-registration, as `skipAutoRegistration` does on a class. */\n\tskipAutoRegistration?: boolean;\n}\n\n/**\n * A scenario, without writing a class whose body is data.\n *\n * The class style is right where a scenario has behaviour — an `initialize` that\n * warms something, a `cleanup` that lets go. Most have neither: in the two\n * applications this framework grew out of, every scenario is a class holding\n * three `readonly` fields and nothing else.\n *\n * One implementation: this builds a subclass of `ALankaScenario`, so\n * self-registration, `trigger` and `subscribe` are the same code either way.\n */\nexport const createLankaScenario = <TData = void>(\n\tconfig: ILankaScenarioConfig,\n): ILankaScenario<TData> => {\n\tclass FunctionalScenario extends ALankaScenario<TData> {\n\t\tpublic static override skipAutoRegistration = config.skipAutoRegistration ?? false;\n\n\t\tpublic readonly name = config.name;\n\t\tpublic readonly eventType = config.eventType;\n\t\tpublic readonly dataTypeName = config.dataTypeName;\n\t}\n\n\treturn new FunctionalScenario();\n};\n"],"mappings":";;;;;;;;;;;;AA0BO,IAAM,sBAAsB,CAClC,WAC2B;AAAA,EAC3B,MAAM,2BAA2B,eAAsB;AAAA,IACtD,OAAuB,uBAAuB,OAAO,wBAAwB;AAAA,IAE7D,OAAO,OAAO;AAAA,IACd,YAAY,OAAO;AAAA,IACnB,eAAe,OAAO;AAAA,EACvC;AAEA,SAAO,IAAI,mBAAmB;AAC/B;","names":[]}

package/dist/validation/index.d.ts

@@ -0,0 +1,18 @@
+export { I as ILankaValidator, T as TLankaSchema, a as TLankaValidationResult, l as lankaStandardValidator } from '../lankaStandardValidator-CL-r-zEV.js';
+import { I as ILankaApiError } from '../ILankaApiError-zI_2bNs0.js';
+import '@standard-schema/spec';
+
+/**
+ * What a schema refused, as an error a screen can catch by type.
+ *
+ * The one case where a class is the answer by itself: `instanceof` needs a
+ * prototype. It carries the field errors a form renders, so a caller branches on
+ * the type rather than parsing a message.
+ */
+declare class LankaValidationError extends Error implements ILankaApiError {
+    status: number;
+    errors: string[];
+    constructor(message: string, errors?: string[]);
+}
+
+export { LankaValidationError };