lanka 1.0.0

package/dist/ILankaScenarioVM-DuCyPoyT.d.ts

@@ -0,0 +1,260 @@
+/**
+ * Metadata describing an event type.
+ */
+interface ILankaEventMetadata {
+    /** Expected data type name (informational only). */
+    dataType?: string;
+    /** Human-readable description of the event. */
+    description?: string;
+    /** List of modules/components using this event. */
+    usedBy?: string[];
+    /** Optional validation schema for event data. */
+    schema?: (data: unknown) => boolean;
+    /** Default subscription priority (higher = earlier execution). */
+    priority?: number;
+    /** Maximum number of logs to keep for this event. */
+    maxLogs?: number;
+    /**
+     * How many recent values are kept for late subscribers.
+     *
+     * Declared on the EVENT, not merely requested by a subscriber: an event may
+     * fire before anyone subscribes, and only the event's own declaration can
+     * have caused the value to be retained by then.
+     *
+     * Default is to keep nothing — a buffer that is on by default retains
+     * payloads no one asked for.
+     */
+    replay?: boolean | "last" | number;
+}
+
+/**
+ * Represents a single log entry for a dispatched event.
+ */
+interface ILankaEventLog {
+    /** The event type name. */
+    eventType: string;
+    /** ISO timestamp of when the event was dispatched. */
+    timestamp: string;
+    /** The payload data of the event. */
+    data: unknown;
+    /** Optional captured stack trace (if enabled). */
+    stackTrace?: string;
+    /**
+     * Why a middleware stopped delivery.
+     *
+     * Present only on stopped events; it exists so that a stop is never silent.
+     */
+    stoppedBy?: string;
+}
+
+/**
+ * A middleware's decision about an event.
+ *
+ * `"pass"` lets it through. `{ stop }` halts it, naming the reason.
+ */
+type TLankaEventBusDecision = "pass" | {
+    stop: string;
+};
+/**
+ * A bus event interceptor.
+ *
+ * ## Why the decision is RETURNED rather than expressed by calling `next()`
+ *
+ * A `(eventType, data, next) => void` shape rests on a convention: call `next`
+ * and the event continues, do not and it stops. The second happens SILENTLY — no
+ * subscriber runs and nothing is logged or counted, so a mechanism that exists
+ * for observability becomes its own blind spot.
+ *
+ * A returned decision cannot be forgotten: the type demands it, and a stop
+ * carries a reason into the bus log.
+ *
+ * ## How this differs from REQUEST middleware
+ *
+ * There the `(ctx, next) => …` shape stays, and not by oversight: request
+ * middleware must be able to RETRY, which can only be expressed by calling
+ * `next` twice. And not calling it there means returning a value instead of a
+ * request, which the caller sees. Here, not calling it meant the event vanished.
+ */
+type TLankaEventBusMiddleware<T> = (eventType: string, data: T) => TLankaEventBusDecision;
+
+/**
+ * How many recent values to replay to a new subscriber.
+ *
+ * `true` is kept and means "the last one".
+ */
+type TLankaReplayRequest = boolean | "last" | number;
+declare class LankaEventBusInstance {
+    /** Event registry and per-event state — private to each instance. */
+    private registry;
+    /** Middleware registered on this instance. */
+    private middlewares;
+    /** Default maximum number of logs kept per event type. */
+    private defaultMaxLogs;
+    /** Internal timers for replay batching (avoid multiple replays in the same tick). */
+    private pendingReplayTimers;
+    /** Whether event logging is enabled. */
+    private isEnableLogs;
+    /** Configures the bus, e.g. logging. Called once at application start. */
+    enableLogs(): void;
+    disableLogs(): void;
+    /**
+     * 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
+     */
+    private ensureEvent;
+    /**
+     * 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: string, metadata: ILankaEventMetadata): void;
+    /** Every registered event with its metadata. */
+    getRegisteredEvents(): {
+        eventType: string;
+        metadata: ILankaEventMetadata;
+    }[];
+    /** Metadata of one event type. */
+    getEventInfo(eventType: string): ILankaEventMetadata | 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: string): number;
+    getSubscriptions(eventType: string): number;
+    /**
+     * 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<T>(eventType: string, callback: (data: T) => void, options?: {
+        priority?: number;
+        replay?: TLankaReplayRequest;
+        usedBy?: string;
+    }): () => void;
+    /**
+     * Removes a handler from an event type.
+     *
+     * @param eventType Event type
+     * @param callback A previously subscribed handler
+     */
+    unsubscribe<T>(eventType: string, callback: (data: T) => void): void;
+    /**
+     * 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<T>(eventType: string, data?: T, usedBy?: string): void;
+    /** Adds middleware to the shared chain. */
+    addMiddleware<T>(mw: TLankaEventBusMiddleware<T>): void;
+    /** Removes previously added middleware. */
+    removeMiddleware<T>(mw: TLankaEventBusMiddleware<T>): void;
+    /**
+     * Log of dispatched events.
+     *
+     * @param eventType Limit to one type
+     * @param limit How many recent records to return
+     */
+    getEventLogs(eventType?: string, limit?: number): ILankaEventLog[];
+    /** Removes an event together with its subscriptions, log and buffer. */
+    clearEvent(eventType: string): void;
+    /** Removes every event and any scheduled replays. */
+    clearAllEvents(): void;
+    /** Full bus reset: events and middleware. */
+    reset(): void;
+    /**
+     * 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.
+     */
+    private markStopped;
+    /** Add an event log entry for debugging/auditing. */
+    private logEvent;
+    /**
+     * 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.
+     */
+    private scheduleBatchedReplay;
+}
+
+/**
+ * A scenario: a named unit of coordination over the event bus.
+ *
+ * This is how ViewModels talk to each other without knowing about each other.
+ *
+ * @template TData The data that travels with the event
+ */
+interface ILankaScenario<TData = void> {
+    /** The scenario's name, and the key it is found by. */
+    readonly name: string;
+    /** The event type on the bus. */
+    readonly eventType: string;
+    /** The event data's type name — for the bus metadata. */
+    readonly dataTypeName: string;
+    /**
+     * Announces that the scenario happened.
+     *
+     * @param data What travels with the event
+     */
+    trigger(data?: TData): void;
+    /**
+     * Subscribes a handler and returns an unsubscribe function.
+     *
+     * The return is the only way to remove EXACTLY this subscription: by callback,
+     * two subscriptions of one function are indistinguishable.
+     */
+    subscribe(callback: (data?: TData) => void, options?: {
+        priority?: number;
+        replay?: TLankaReplayRequest;
+        usedBy?: string;
+    }): () => void;
+    /** Called when the scenario is registered, if declared. */
+    initialize?(): void;
+    /** Called when the scenario is removed from the registry, if declared. */
+    cleanup?(): void;
+}
+
+/**
+ * A ViewModel that participates in scenarios.
+ *
+ * Not every ViewModel does: one with no `scenarioHandlers` never subscribes to
+ * anything and is never registered. This is the pair of methods
+ * `LankaScenarioBootstrap` calls on those that do, which is why the name says
+ * scenario rather than ViewModel.
+ *
+ * Both are idempotent by contract: bootstrap may run after a ViewModel has
+ * already initialised itself, and a reset may arrive for one that never did.
+ */
+interface ILankaScenarioVM {
+    /**
+     * Subscribes this ViewModel's scenario handlers.
+     *
+     * Called once the scenario registry is populated — a ViewModel declared at
+     * module level exists before any scenario does.
+     */
+    initializeScenario(): void;
+    /**
+     * Releases every subscription, leaving the ViewModel ready to initialise again.
+     *
+     * Called when the framework instance is disposed, and by `resetLanka()`
+     * between tests.
+     */
+    resetScenario(): void;
+}
+
+export { type ILankaScenarioVM as I, LankaEventBusInstance as L, type TLankaReplayRequest as T, type ILankaScenario as a, type ILankaEventMetadata as b, type TLankaEventBusMiddleware as c, type ILankaEventLog as d, type TLankaEventBusDecision as e };

package/dist/LankaError-B1HtuIkw.d.ts

@@ -0,0 +1,86 @@
+import { I as ILankaApiError } from './ILankaApiError-zI_2bNs0.js';
+
+/**
+ * How a request ended.
+ *
+ * Six kinds rather than one, for one reason: each demands something DIFFERENT of
+ * the interface. A distinction that implies no different behaviour is
+ * superfluous, which is why there is no seventh.
+ */
+type TLankaErrorKind = 
+/** Never reached the server: dropped link, DNS failure, no network. Offer a retry. */
+"network"
+/** Reached it; the response never came. Also a retry, but a different message. */
+ | "timeout"
+/** Cancelled by the caller. Nothing to show: the user left. */
+ | "aborted"
+/** The server answered with an error status; what to show depends on it. */
+ | "http"
+/** A response arrived in the wrong shape. A break, not the user's fault. */
+ | "schema"
+/** The server refused deliberately and named the reason. Show what it said. */
+ | "domain";
+interface ILankaErrorInit {
+    kind: TLankaErrorKind;
+    message: string;
+    /** HTTP status, when there was one. */
+    status?: number;
+    /** The domain failure code — what the application branches on. */
+    code?: string;
+    /** Details: server messages, or paths to the fields that failed validation. */
+    issues?: readonly string[];
+    /**
+     * The parsed ERROR response body, when there was one and it was JSON.
+     *
+     * Travels with the error because a `Response` is read once: without this field
+     * a plugin extracting the domain failure code would read an already-drained
+     * stream and get nothing. Core does not look into the body; it carries it.
+     */
+    body?: unknown;
+    /** The original error, when this one wraps it. */
+    cause?: unknown;
+}
+/**
+ * One failure type for every layer of the framework.
+ *
+ * Without a tagged kind, an app cannot tell a network failure from a timeout,
+ * from a broken schema, from a deliberate domain refusal — so it builds its own
+ * error contract ON TOP of the framework, and builds it once per application.
+ *
+ * Implements `ILankaApiError`: `status` and `errors` are present, so code reading
+ * them the old way keeps working.
+ *
+ * What is NOT here: parsing a particular response body format. Which JSON a
+ * backend sends is policy, and policy lives in `@lankajs/plugin-http`. Core knows
+ * only that it has a failure and must name its kind.
+ */
+declare class LankaError extends Error implements ILankaApiError {
+    readonly kind: TLankaErrorKind;
+    readonly status?: number;
+    readonly code?: string;
+    readonly issues?: readonly string[];
+    /** The parsed error response body; core carries it without reading it. */
+    readonly body?: unknown;
+    constructor(init: ILankaErrorInit);
+    /** The `ILankaApiError` field. The details are the message list. */
+    get errors(): string[] | undefined;
+    /**
+     * Whether to show this to the user.
+     *
+     * A cancelled request is the one failure that must NOT be reported: its cause
+     * is that the user left before the response, and a toast would catch them on
+     * another screen.
+     */
+    get isSilent(): boolean;
+    /**
+     * Recognises our error among others.
+     *
+     * Checks the name rather than `instanceof` alone: a consumer may end up with
+     * two copies of the package — adjacent majors in the dependency tree — and
+     * then `instanceof` answers `false` for an error that is ours by every other
+     * sign.
+     */
+    static is(value: unknown): value is LankaError;
+}
+
+export { type ILankaErrorInit as I, LankaError as L, type TLankaErrorKind as T };

package/dist/LankaScenarioLocator-BGQHwf3n.d.ts

@@ -0,0 +1,144 @@
+import { a as ILankaScenario, I as ILankaScenarioVM } from './ILankaScenarioVM-DuCyPoyT.js';
+import { I as ILankaScenarioMetadata } from './ILankaScenarioMetadata-Bu-yggTZ.js';
+import { A as ALankaGateway } from './ALankaGateway-ExlRGT3D.js';
+import { A as ALankaLocator } from './LankaSharedStoreLocator-MvCpav5F.js';
+
+/**
+ * The scenario registry: both those that registered themselves and those
+ * registered by hand.
+ *
+ * `ALankaScenario` subclasses arrive here automatically unless they opted out.
+ */
+declare class LankaScenariosRegistry {
+    private registeredScenarios;
+    private scenarioMetadata;
+    /**
+     * 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(): LankaScenariosRegistry;
+    /**
+     * Registers a scenario by hand.
+     *
+     * @param scenario What to register
+     * @returns `false` when it was already registered
+     */
+    register(scenario: ILankaScenario<unknown>): boolean;
+    /**
+     * Unregister a scenario
+     * @param scenarioName Name of the scenario to unregister
+     * @returns true if unregistered successfully, false if not found
+     */
+    unregister(scenarioName: string): boolean;
+    /**
+     * Get metadata for a specific scenario
+     * @param scenarioName Name of the scenario
+     * @returns Scenario metadata or undefined if not found
+     */
+    getMetadata(scenarioName: string): ILankaScenarioMetadata | undefined;
+    /** Every registered scenario. */
+    getAllScenarios(): ILankaScenario<unknown>[];
+    /** Metadata of every scenario. */
+    getAllMetadata(): ILankaScenarioMetadata[];
+    /** Whether a scenario with this name is registered. */
+    isRegistered(scenarioName: string): boolean;
+    /**
+     * Collects every scenario that registered itself at construction.
+     */
+    collectAutoRegisteredScenarios(): void;
+    /**
+     * A scenario by name.
+     *
+     * @returns `undefined` when there is none
+     */
+    getScenarioByName(scenarioName: string): ILankaScenario<unknown> | undefined;
+    /** Every registered ViewModel. */
+    getAllViewModels(): ILankaScenarioVM[];
+    /**
+     * Clears every registered scenario. Required by tests.
+     */
+    clear(): void;
+}
+
+/**
+ * The registry of ViewModels that use scenarios.
+ *
+ * They arrive by themselves: the factory registers a ViewModel when it declares
+ * scenario handlers.
+ */
+declare class LankaScenarioVMRegistry {
+    private registeredViewModels;
+    /**
+     * 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(): LankaScenarioVMRegistry;
+    /** Whether this ViewModel is already registered. */
+    isRegistered(viewModel: ILankaScenarioVM): boolean;
+    /**
+     * Registers a ViewModel.
+     *
+     * @returns `false` when it was already registered
+     */
+    register(viewModel: ILankaScenarioVM): boolean;
+    /** Removes a ViewModel from the registry. */
+    unregister(viewModel: ILankaScenarioVM): void;
+    /** Every registered ViewModel. */
+    getAllViewModels(): ILankaScenarioVM[];
+    /**
+     * Clears every registered ViewModel. Required by tests.
+     */
+    clear(): void;
+    /**
+     * 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(): void;
+}
+
+/**
+ * Resolves a gateway by property name (camelCase) or class name (PascalCase),
+ * constructing it lazily and caching the instance.
+ *
+ * Adding a gateway takes one export line in `@lanka_di/Gateways`: types are
+ * inferred and nothing is registered.
+ */
+declare class LankaGatewayLocator extends ALankaLocator<ALankaGateway<unknown>> {
+    constructor();
+}
+
+/**
+ * Resolves scenarios by property name (camelCase) or scenario name
+ * (PascalCase).
+ *
+ * Looks in the registry, then in the self-registration pool, and failing both
+ * constructs the scenario from the consumer's barrel on first use.
+ */
+declare class LankaScenarioLocator extends ALankaLocator<ILankaScenario<unknown>> {
+    /**
+     * The registry is read LAZILY rather than in a field initialiser.
+     *
+     * The locator is constructed INSIDE `createLanka`, before the instance becomes
+     * active. A field initialiser would ask for the active instance at that moment
+     * and fail with "no instance yet" while the instance being created is on the
+     * stack. Deferred reading resolves it: by the first scenario resolution an
+     * active instance exists.
+     */
+    private get registry();
+    constructor();
+}
+
+export { LankaGatewayLocator as L, LankaScenarioLocator as a, LankaScenarioVMRegistry as b, LankaScenariosRegistry as c };

package/dist/LankaSharedStoreLocator-MvCpav5F.d.ts

@@ -0,0 +1,126 @@
+import { A as ALankaSharedStore } from './ALankaSharedStore-B7uepuuk.js';
+
+/**
+ * Resolves instances by camelCase property name, mapping it to the PascalCase
+ * class name.
+ */
+interface ILankaLocator<TInstance> {
+    /**
+     * The instance for a camelCase property name.
+     *
+     * @param propertyName For example, `userGateway`
+     * @throws If no such instance exists
+     */
+    get(propertyName: string): TInstance;
+}
+
+/**
+ * Base locator configuration.
+ */
+interface ILankaLocatorConfig<TInstance> {
+    /** How to find a constructor by class name. */
+    findClassByName: (name: string) => (new () => TInstance) | undefined;
+    /** How to create an object from a constructor. */
+    createInstance?: (Class: new () => TInstance) => TInstance;
+    /** Custom resolution by name, when the ordinary one is not enough. */
+    getInstanceByName?: (name: string) => TInstance | undefined;
+    /** What to say when there is no such object. */
+    notFoundError?: (name: string, propertyName: string) => string;
+}
+/**
+ * The locator base: resolves objects by property name (camelCase), translating
+ * it into a class name (PascalCase).
+ *
+ * Handles what every locator shares — name translation, construction on first
+ * use from the barrel's exports, and caching what was constructed.
+ */
+declare abstract class ALankaLocator<TInstance> implements ILankaLocator<TInstance> {
+    protected readonly instanceCache: Map<string, TInstance>;
+    protected readonly registeredClasses: Map<string, new () => TInstance>;
+    protected readonly registeredInstances: Map<string, TInstance>;
+    protected readonly config: ILankaLocatorConfig<TInstance> & {
+        createInstance: (Class: new () => TInstance) => TInstance;
+        notFoundError: (name: string, propertyName: string) => string;
+    };
+    protected constructor(config: ILankaLocatorConfig<TInstance>);
+    /**
+     * An object by class name.
+     *
+     * The cache first, then custom resolution when configured, and only then
+     * construction.
+     */
+    protected getInstanceByName(instanceName: string): TInstance | undefined;
+    /**
+     * An object by property name (camelCase).
+     *
+     * Throws when there is none: a silent `undefined` would surface layers later.
+     */
+    get(propertyName: string): TInstance;
+    /**
+     * Clears the instance cache. Required by tests.
+     */
+    clearCache(): void;
+    /**
+     * Registers a class by hand, ahead of the consumer's barrel.
+     *
+     * The cache entry is dropped: what it holds was built from the previous class.
+     */
+    register(className: string, Class: new () => TInstance): void;
+    /**
+     * Registers an already-built object by hand.
+     *
+     * It goes straight into the cache: there is nothing left to construct, and a
+     * later lookup must not build a rival.
+     */
+    registerInstance(className: string, instance: TInstance): void;
+    /** Removes a class or object registered by hand, and what was built from it. */
+    unregister(className: string): void;
+    /** Whether this name resolves to anything the locator already holds. */
+    isRegistered(className: string): boolean;
+}
+
+/**
+ * LankaSingletonLocator configuration.
+ */
+interface ILankaSingletonLocatorConfig {
+    /** The module holding singleton classes — the consumer's barrel. */
+    singletonIndexModule?: Record<string, unknown>;
+}
+/**
+ * Resolves singletons by property name (camelCase) or class name (PascalCase),
+ * constructing them on first use and caching them.
+ *
+ * A class arrives either from the consumer's barrel or registered by hand — the
+ * latter for tests and for objects that arrive already built.
+ */
+declare class LankaSingletonLocator extends ALankaLocator<unknown> {
+    private readonly singletonIndexModule?;
+    constructor(config?: ILankaSingletonLocatorConfig);
+    /**
+     * Creates a NEW service object, bypassing the locator's cache.
+     *
+     * For scopes: they take the class from here and set the lifetime themselves.
+     * The root cache is untouched — otherwise the first resolution inside a scope
+     * would replace the application's root object.
+     */
+    createScopedInstance(className: string, propertyName: string): unknown;
+}
+
+type TSharedStoreState = object;
+/**
+ * LankaSharedStoreLocator configuration.
+ */
+interface ILankaSharedStoreLocatorConfig {
+    /** The module holding shared store classes — the consumer's barrel. */
+    sharedStoreIndexModule?: Record<string, unknown>;
+}
+/**
+ * Resolves shared stores by property name (camelCase) or class name
+ * (PascalCase), constructing them on first use and caching them.
+ */
+declare class LankaSharedStoreLocator extends ALankaLocator<ALankaSharedStore<TSharedStoreState>> {
+    private readonly sharedStoreIndexModule?;
+    constructor(config?: ILankaSharedStoreLocatorConfig);
+}
+
+export { ALankaLocator as A, type ILankaLocatorConfig as I, LankaSharedStoreLocator as L, type ILankaLocator as a, LankaSingletonLocator as b, type ILankaSharedStoreLocatorConfig as c, type ILankaSingletonLocatorConfig as d };

package/dist/TLankaErrorHandler-Yfqtdh1M.d.ts

@@ -0,0 +1,3 @@
+type TLankaErrorHandler = (response: Response) => Promise<never>;
+
+export type { TLankaErrorHandler as T };

package/dist/_extend/index.d.ts

@@ -0,0 +1,34 @@
+export { L as LankaGatewayLocator, a as LankaScenarioLocator, b as LankaScenarioVMRegistry, c as LankaScenariosRegistry } from '../LankaScenarioLocator-BGQHwf3n.js';
+import { a as ILankaLocator } from '../LankaSharedStoreLocator-MvCpav5F.js';
+export { A as ALankaLocator, L as LankaSharedStoreLocator, b as LankaSingletonLocator } from '../LankaSharedStoreLocator-MvCpav5F.js';
+export { c as createLankaScope } from '../createLankaScope-Bc_vChRs.js';
+export { c as composeLankaRequestMiddleware } from '../lankaRequestMiddleware-DAC5kCb7.js';
+import '../ILankaScenarioVM-DuCyPoyT.js';
+import '../ILankaScenarioMetadata-Bu-yggTZ.js';
+import '../ALankaGateway-ExlRGT3D.js';
+import '../lankaStandardValidator-CL-r-zEV.js';
+import '@standard-schema/spec';
+import '../ALankaSharedStore-B7uepuuk.js';
+import 'zustand/vanilla';
+
+/**
+ * Configuration of the global locator proxy.
+ */
+interface ILankaLocatorProxyConfig<TInstance> {
+    /** The locator that actually resolves instances. */
+    locator: ILankaLocator<TInstance>;
+    /** Properties whose access must throw. */
+    protectedProperties?: string[];
+    /** Prefix of the message thrown for an unknown property. */
+    errorPrefix?: string;
+}
+/**
+ * Creates a Proxy for dynamic access to instances with type safety.
+ * Converts camelCase property access to PascalCase instance names.
+ *
+ * @param config Proxy configuration
+ * @returns Proxy object typed as TType
+ */
+declare function createLankaLocatorProxy<TInstance, TType extends Record<string, TInstance>>(config: ILankaLocatorProxyConfig<TInstance>): TType;
+
+export { type ILankaLocatorProxyConfig, createLankaLocatorProxy };

package/dist/_extend/index.js

@@ -0,0 +1,36 @@
+import {
+  LankaGatewayLocator,
+  LankaScenarioLocator,
+  createLankaScope
+} from "../chunk-FIR4XTBL.js";
+import {
+  LankaScenarioVMRegistry,
+  LankaScenariosRegistry
+} from "../chunk-EWVDJYCC.js";
+import {
+  composeLankaRequestMiddleware
+} from "../chunk-YR4MZXMU.js";
+import {
+  createLankaLocatorProxy
+} from "../chunk-DTO27QFR.js";
+import {
+  ALankaLocator,
+  LankaSharedStoreLocator,
+  LankaSingletonLocator
+} from "../chunk-ILQNYQY5.js";
+import "../chunk-C2HP7CRD.js";
+import "../chunk-D27MREPB.js";
+import "../chunk-BGVDPDX4.js";
+export {
+  ALankaLocator,
+  LankaGatewayLocator,
+  LankaScenarioLocator,
+  LankaScenarioVMRegistry,
+  LankaScenariosRegistry,
+  LankaSharedStoreLocator,
+  LankaSingletonLocator,
+  composeLankaRequestMiddleware,
+  createLankaLocatorProxy,
+  createLankaScope
+};
+//# sourceMappingURL=index.js.map