lanka 1.0.1 → 1.1.0

package/dist/createLanka-DI1CSy2Q.d.ts

@@ -0,0 +1,139 @@
+import { I as ILankaScope } from './createLankaScope-BiFxNQgl.js';
+import { I as ILankaRuntime } from './activeRuntime-B336NU5I.js';
+import { a as ILankaHost, I as ILankaFlags } from './ILankaRuntimeConfig-Vl436GWK.js';
+import { T as TLankaRequestMiddleware } from './lankaRequestMiddleware-DAC5kCb7.js';
+
+/**
+ * A plugin is an extension core knows by SHAPE rather than by name.
+ *
+ * ## Plugin versus module
+ *
+ * A module is called by the application (`app → module`) and core does not know
+ * it exists. A plugin sits on the path core itself walks (`app → core → plugin`).
+ * The test question: does core need a hook for this to work? No — then it is a
+ * module, and making it a plugin costs more, because the hook has to be supported
+ * forever.
+ *
+ * ## Why `install` receives the instance
+ *
+ * So a plugin has no private route to the framework. Everything it can do comes
+ * from the instance it was given, which means two instances in one process (a
+ * test beside the app) do not share its configuration.
+ */
+interface ILankaPlugin {
+    /**
+     * The name the plugin is recognised by. Registering the same name twice is
+     * rejected: two copies of a retry policy would silently double the request
+     * count.
+     */
+    readonly name: string;
+    /**
+     * Installation. The returned function removes everything the plugin installed
+     * and is called when the plugin is removed and when the instance is disposed.
+     */
+    install: (lanka: ILankaInstance) => (() => void) | void;
+}
+
+/**
+ * A framework instance: all framework state in one object.
+ *
+ * What instance-scoped state buys: two apps in one process (micro-frontends,
+ * Storybook beside the app) no longer share a bus, locator caches and mock mode;
+ * SSR does not reuse state between different users' requests; and test isolation
+ * rests on construction rather than on a global `beforeEach` reaching into
+ * internal registries.
+ *
+ * **Ambient facades** — `lankaEventBus.dispatch`, `lankaSingletons.foo`,
+ * `getLankaFlags()`, `lankaHttpInFlight` — resolve THE ONE active instance
+ * (`internal/activeRuntime.ts`). Isolation belongs to whoever holds an instance;
+ * a facade cannot offer it.
+ *
+ * One thing stays at module level deliberately: `ALankaScenario` collects
+ * constructed scenarios into a static pool. That is a REGISTRY OF DEFINITIONS,
+ * not runtime state — the classes come from one `@lanka_di/Scenarios` barrel and
+ * both instances must see the same list. Splitting it would be divergence.
+ */
+interface ILankaInstance extends ILankaRuntime {
+    /**
+     * Adds a wrapper around every request. Returns a function that removes it.
+     *
+     * This is how `@lankajs/plugin-http` installs retry, the idempotency key, the
+     * CSRF header and auth refresh.
+     */
+    useRequestMiddleware(middleware: TLankaRequestMiddleware): () => void;
+    /** Default timeout for every request of this instance. */
+    setRequestTimeout(timeoutMs: number | undefined): void;
+    /** Resolves a service in the root scope — for the instance's whole lifetime. */
+    resolve<TInstance>(propertyName: string): TInstance;
+    /**
+     * Creates a scope: a lifetime shorter than the application's.
+     *
+     * An object created in a scope goes away with it.
+     */
+    createScope(): ILankaScope;
+    /**
+     * Registers a plugin. Returns a function that removes it.
+     *
+     * The fifth and last extension point. An extension point declared before
+     * anything plugs into it describes an imagined need while costing real
+     * support, so this one arrived with the FIRST plugin.
+     */
+    use(plugin: ILankaPlugin): () => void;
+    /** Runs services and the scenario layer. Idempotent. */
+    bootstrap(config?: ILankaBootstrapConfig): Promise<void>;
+    /** Has bootstrap already run? */
+    isBootstrapped(): boolean;
+    /** Makes this instance the one ambient facades resolve to. */
+    activate(): void;
+    /**
+     * Removes subscriptions, clears registries and, if this instance was active,
+     * clears the pointer. Returns the framework to its pre-bootstrap state.
+     */
+    dispose(): void;
+}
+interface ILankaInstanceConfig {
+    host: ILankaHost;
+    flags?: ILankaFlags;
+}
+interface ILankaServiceConfig {
+    name?: string;
+    init: () => void | Promise<void>;
+    sync?: boolean;
+    priority?: number;
+    /**
+     * A failure of this service does not abort bootstrap.
+     *
+     * Without the flag one failed service takes the WHOLE phase with it: the async
+     * phase because of `Promise.all`, the sync phase because later tasks never run.
+     * Wrapping the failure in a swallowing `try/catch` is worse still — the app
+     * starts with a partially executed plan and does not know it.
+     */
+    optional?: boolean;
+    /**
+     * How long to wait for the service. Overrunning counts as a failure.
+     *
+     * Without a deadline a service that never settles holds bootstrap forever and
+     * the app never paints its first screen. Failing is more honest than waiting:
+     * an optional service is skipped, a required one names itself.
+     */
+    timeoutMs?: number;
+}
+interface ILankaScenarioBootstrapConfig {
+    sync?: boolean;
+    priority?: number;
+}
+interface ILankaBootstrapConfig {
+    services?: ILankaServiceConfig[];
+    scenarios?: ILankaScenarioBootstrapConfig;
+}
+/**
+ * Creates an instance and makes it active.
+ *
+ * Activating on creation is the deliberate default: there is almost always one
+ * app and the facades must work immediately. A second instance takes the
+ * pointer — the last one created serves the facades. Callers needing another
+ * order call `activate()` explicitly.
+ */
+declare function createLanka(config: ILankaInstanceConfig): ILankaInstance;
+
+export { type ILankaBootstrapConfig as I, type ILankaInstance as a, type ILankaInstanceConfig as b, type ILankaPlugin as c, type ILankaScenarioBootstrapConfig as d, type ILankaServiceConfig as e, createLanka as f };

package/dist/gateway/index.d.ts

@@ -1,9 +1,9 @@
-import { T as TLankaExecuteOptions, I as IALankaGatewayConfig, a as ILankaRequest, b as TLankaQueryBuilder } from '../ALankaGateway-ExlRGT3D.js';
-export { A as ALankaGateway, c as TLankaQueryParams } from '../ALankaGateway-ExlRGT3D.js';
+import { T as TLankaExecuteOptions, I as IALankaGatewayConfig, a as TLankaRequestInit, b as ILankaRequest, c as TLankaQueryBuilder } from '../ALankaGateway-CkW1LbKE.js';
+export { A as ALankaGateway, d as TLankaQueryParams } from '../ALankaGateway-CkW1LbKE.js';
+import { I as ILankaValidator } from '../lankaStandardValidator-CL-r-zEV.js';
 import { T as TLankaErrorHandler } from '../TLankaErrorHandler-Yfqtdh1M.js';
 export { I as ILankaInFlightCounter, l as lankaHttpInFlight } from '../lankaHttpInFlight-Bk1eIuSx.js';
 export { I as ILankaRequestContext, T as TLankaRequestMiddleware } from '../lankaRequestMiddleware-DAC5kCb7.js';
-import '../lankaStandardValidator-CL-r-zEV.js';
 import '@standard-schema/spec';
 
 /**
@@ -20,6 +20,8 @@ interface ILankaGatewayContext<TOptions> {
     request: <TReturn = unknown>(path: string, options?: TLankaExecuteOptions<TOptions>, mockHandler?: () => Promise<TReturn>) => Promise<TReturn>;
     /** Serialises query parameters the way this gateway was configured to. */
     buildQueryParams: <T extends object>(params: T) => URLSearchParams;
+    /** Checks a response body: the validator this gateway was given, or the Standard Schema port. */
+    validationService: ILankaValidator;
 }
 
 /** What a gateway is built from, whichever style builds it. */
@@ -47,13 +49,13 @@ declare const createLankaGateway: <TOptions, TMethods extends object>(config: IL
  * How a gateway request goes on the wire.
  *
  * A subclass declares one method, `request()`, and does only its own work there:
- * `LankaFetchJsonRequest` returns parsed JSON, `LankaFetchFormDataRequest`
- * returns the whole response, a custom transport returns whatever it likes.
+ * `LankaFetchJsonRequest` returns parsed JSON, `LankaFetchRequest` returns the
+ * whole response, a custom kind returns whatever it likes.
  *
  * Overriding `request()` customises the request flow, failure handling, mock
  * substitution, response transformation and log interception.
  */
-declare abstract class ALankaRequest<TOptions = RequestInit> implements ILankaRequest<TOptions> {
+declare abstract class ALankaRequest<TOptions = TLankaRequestInit> implements ILankaRequest<TOptions> {
     protected readonly errorHandler?: TLankaErrorHandler;
     protected readonly useMock: boolean;
     protected constructor(config: {
@@ -81,10 +83,23 @@ declare abstract class ALankaRequest<TOptions = RequestInit> implements ILankaRe
 }
 
 /**
- * Transport layer interface for Gateway.
- * Allows to swap between different communication protocols (HTTP Fetch, gRPC, WebSocket, etc.)
+ * How bytes travel. The seam a consumer replaces to change the PROTOCOL.
+ *
+ * `LankaFetchTransport` is the only implementation core ships, and one is the
+ * right number: HTTP over `fetch` is what almost every application does, and the
+ * things that once justified a second and a third — a JSON `content-type`, a
+ * multipart one — turned out to be encodings rather than protocols. An encoding
+ * belongs to the CALL, and the shipped transport reads the body to decide it.
+ *
+ * Implement this for something genuinely different: a native bridge, a socket, an
+ * offline queue, a double that never leaves the process. Anything that still ends
+ * in `fetch` and only wants to add a header, a credential, a retry or a refresh
+ * is POLICY — write a `TLankaRequestMiddleware` and register it with
+ * `useRequestMiddleware`, or reach for `@lankajs/plugin-http`, which already has
+ * all four. A transport rewritten to carry policy is how an application ends up
+ * maintaining its own copy of this package.
  */
-interface ILankaTransport<TOptions = RequestInit> {
+interface ILankaTransport<TOptions = TLankaRequestInit> {
     /**
      * Executes a request and returns a Response.
      * @param resource - Request resource (URL or Request object)
@@ -102,12 +117,17 @@ interface ILankaTransportRequestConfig<TOptions> {
 /**
  * The shape every fetch-backed request has: mock, send, check, parse.
  *
- * The three concrete requests differ in exactly two places — which transport
- * they default to, and how they turn a successful `Response` into a value. Both
- * are parameters of this template, so a fourth kind is a subclass with one
- * method rather than a fourth copy of the sequence.
+ * The concrete requests differ in ONE place — how they turn a successful
+ * `Response` into a value — so a third kind is a subclass with one method rather
+ * than a third copy of the sequence.
+ *
+ * The default transport stays a constructor PARAMETER even though both shipped
+ * kinds pass the same one. It is the seam a request kind that is not fetch-backed
+ * comes through: this template is the mock/send/check/parse sequence, and nothing
+ * in it is about HTTP. Defaulting the parameter here would fix `TOptions` to
+ * fetch options for everyone who reuses the sequence.
  */
-declare abstract class ALankaTransportRequest<TOptions = RequestInit> extends ALankaRequest<TOptions> {
+declare abstract class ALankaTransportRequest<TOptions = TLankaRequestInit> extends ALankaRequest<TOptions> {
     protected readonly transport: ILankaTransport<TOptions>;
     protected constructor(config: ILankaTransportRequestConfig<TOptions>, createDefaultTransport: () => ILankaTransport<TOptions>);
     protected request<TReturn>(endpoint: string, options?: TOptions, mockHandler?: () => Promise<TReturn>): Promise<TReturn>;
@@ -131,10 +151,19 @@ declare abstract class ALankaTransportRequest<TOptions = RequestInit> extends AL
 /**
  * The raw request: hands the `Response` back untouched.
  *
- * The minimal, extensible case — a caller wanting headers, a stream or a blob
- * reads them off the response itself.
+ * The minimal, extensible case — a caller wanting headers, a stream, a blob or a
+ * `204` reads them off the response itself. Multipart uploads come through here
+ * too: the transport encodes by looking at the body, so posting a `FormData` and
+ * posting an object are the same call.
+ *
+ * `TOptions` is CONSTRAINED to fetch options rather than merely defaulted to
+ * them. A consumer widening it — their own `interface IRequestOptions extends
+ * TLankaRequestInit` — still gets the shipped transport, because the constraint
+ * is what lets the framework hand one over without a cast. Unconstrained, the
+ * assignment did not typecheck and core cast its way past it; the cast worked
+ * here and was unavailable to the consumer, who wrote a transport instead.
  */
-declare class LankaFetchRequest<TOptions = RequestInit> extends ALankaTransportRequest<TOptions> {
+declare class LankaFetchRequest<TOptions extends TLankaRequestInit = TLankaRequestInit> extends ALankaTransportRequest<TOptions> {
     constructor(config?: ILankaTransportRequestConfig<TOptions>);
     protected parse<TReturn>(response: Response): Promise<TReturn>;
 }
@@ -145,7 +174,7 @@ declare class LankaFetchRequest<TOptions = RequestInit> extends ALankaTransportR
  * One line, and that is the point — the factory IS the class, so a behaviour
  * cannot exist in one style and not the other.
  */
-declare const createLankaFetchRequest: <TOptions = RequestInit>(config?: ILankaTransportRequestConfig<TOptions>) => LankaFetchRequest<TOptions>;
+declare const createLankaFetchRequest: <TOptions extends TLankaRequestInit = TLankaRequestInit>(config?: ILankaTransportRequestConfig<TOptions>) => LankaFetchRequest<TOptions>;
 
 /** The JSON request: parses the body, and refuses a body that is not JSON. */
 /**
@@ -155,7 +184,7 @@ declare const createLankaFetchRequest: <TOptions = RequestInit>(config?: ILankaT
  * what lets a test give the same gateway a transport that never leaves the
  * process. `createLankaFetchJsonRequest()` builds the same class.
  */
-declare class LankaFetchJsonRequest<TOptions = RequestInit> extends ALankaTransportRequest<TOptions> {
+declare class LankaFetchJsonRequest<TOptions extends TLankaRequestInit = TLankaRequestInit> extends ALankaTransportRequest<TOptions> {
     constructor(config?: ILankaTransportRequestConfig<TOptions>);
     /**
      * Parses the body, or names the failure.
@@ -180,58 +209,39 @@ declare class LankaFetchJsonRequest<TOptions = RequestInit> extends ALankaTransp
  * One line, and that is the point — the factory IS the class, so a behaviour
  * cannot exist in one style and not the other.
  */
-declare const createLankaFetchJsonRequest: <TOptions = RequestInit>(config?: ILankaTransportRequestConfig<TOptions>) => LankaFetchJsonRequest<TOptions>;
+declare const createLankaFetchJsonRequest: <TOptions extends TLankaRequestInit = TLankaRequestInit>(config?: ILankaTransportRequestConfig<TOptions>) => LankaFetchJsonRequest<TOptions>;
 
 /**
- * The multipart request: hands the `Response` back untouched.
+ * The network seam: `fetch`, plus the two things `fetch` cannot be told.
  *
- * Differs from `LankaFetchRequest` only in its transport — the one that must NOT
- * set `content-type`, because the browser writes it with the boundary and a
- * hand-set header leaves the body unparseable to the server.
- */
-declare class LankaFetchFormDataRequest<TOptions = RequestInit> extends ALankaTransportRequest<TOptions> {
-    constructor(config?: ILankaTransportRequestConfig<TOptions>);
-    protected parse<TReturn>(response: Response): Promise<TReturn>;
-}
-
-/**
- * The functional style of `LankaFetchFormDataRequest`: a multipart body, for an upload.
+ * ## Why there is ONE of these
  *
- * One line, and that is the point — the factory IS the class, so a behaviour
- * cannot exist in one style and not the other.
- */
-declare const createLankaFetchFormDataRequest: <TOptions = RequestInit>(config?: ILankaTransportRequestConfig<TOptions>) => LankaFetchFormDataRequest<TOptions>;
-
-/**
- * HTTP Fetch transport implementation.
- * Uses native fetch API without any project-specific decorators.
- * For project-specific logic (auth, error handling, etc.), use `request` parameter
- * in Gateway config or create a custom transport.
- */
-declare class LankaFetchTransport implements ILankaTransport<RequestInit> {
-    request(resource: RequestInfo, options?: RequestInit): Promise<Response>;
-}
-
-/**
- * HTTP Fetch JSON transport implementation.
- * Uses native fetch API with JSON-specific headers.
- * Automatically sets Content-Type to application/json for requests with body.
- * For project-specific logic (auth, error handling, etc.), use `request` parameter
- * in Gateway config or create a custom transport.
- */
-declare class LankaFetchJsonTransport implements ILankaTransport<RequestInit> {
-    request(resource: RequestInfo, options?: RequestInit): Promise<Response>;
-}
-
-/**
- * HTTP Fetch FormData transport implementation.
- * Uses native fetch API optimized for FormData requests.
- * Does not set Content-Type header (browser will set it automatically with boundary).
- * For project-specific logic (auth, error handling, etc.), use `request` parameter
- * in Gateway config or create a custom transport.
+ * There were three — a plain one, a JSON one and a multipart one — and the split
+ * was wrong at birth. `ILankaTransport` exists so a consumer can change the
+ * PROTOCOL: a native bridge, a socket, a double that never leaves the process.
+ * The three differed in a `content-type` header. That is not a protocol, it is an
+ * encoding, and an encoding is a property of the CALL: a gateway with fourteen
+ * JSON endpoints and one upload had no way to say so, because its request kind —
+ * and with it its transport — was fixed in its constructor. The application that
+ * hit this added a `useFormData` flag to its own options and wrote its own
+ * transport to read it.
+ *
+ * So the encoding is decided here, per call, by looking at the body. A gateway
+ * posts `FormData` to one endpoint and an object to the next, and neither it nor
+ * the request kind has to know.
+ *
+ * ## What does NOT belong here
+ *
+ * The base URL (`ALankaGateway` prefixes `apiBaseUrl`), credentials, static
+ * headers, CSRF, retry, auth refresh, idempotency keys and deadlines. Every one
+ * of those is policy around a request rather than a way of sending one, and every
+ * one is a middleware — `useRequestMiddleware`, which `@lankajs/plugin-http`
+ * occupies. A transport that grew them would be a second composition mechanism
+ * beside the one core already publishes, and "where does a header get added"
+ * would have two answers.
  */
-declare class LankaFetchFormDataTransport implements ILankaTransport<RequestInit> {
-    request(resource: RequestInfo, options?: RequestInit): Promise<Response>;
+declare class LankaFetchTransport implements ILankaTransport<TLankaRequestInit> {
+    request(resource: RequestInfo, options?: TLankaRequestInit): Promise<Response>;
 }
 
 /**
@@ -255,4 +265,4 @@ interface ILankaListQueryParams {
     filters?: Record<string, unknown>;
 }
 
-export { ALankaRequest, IALankaGatewayConfig, type ILankaGatewayConfig, type ILankaGatewayContext, type ILankaListQueryParams, ILankaRequest, type ILankaTransport, LankaFetchFormDataRequest, LankaFetchFormDataTransport, LankaFetchJsonRequest, LankaFetchJsonTransport, LankaFetchRequest, LankaFetchTransport, TLankaExecuteOptions, TLankaQueryBuilder, buildLankaQueryParams, createLankaFetchFormDataRequest, createLankaFetchJsonRequest, createLankaFetchRequest, createLankaGateway };
+export { ALankaRequest, IALankaGatewayConfig, type ILankaGatewayConfig, type ILankaGatewayContext, type ILankaListQueryParams, ILankaRequest, type ILankaTransport, LankaFetchJsonRequest, LankaFetchRequest, LankaFetchTransport, TLankaExecuteOptions, TLankaQueryBuilder, TLankaRequestInit, buildLankaQueryParams, createLankaFetchJsonRequest, createLankaFetchRequest, createLankaGateway };

package/dist/gateway/index.js

@@ -1,3 +1,6 @@
+import {
+  lankaStandardValidator
+} from "../chunk-D5WKKEIR.js";
 import {
   composeLankaRequestMiddleware
 } from "../chunk-YR4MZXMU.js";
@@ -181,30 +184,49 @@ var ALankaTransportRequest = class extends ALankaRequest {
   }
 };
 
-// src/gateway/transport/lanka-fetch-json-transport/LankaFetchJsonTransport.ts
-var LankaFetchJsonTransport = class {
+// src/gateway/lanka-fetch-transport/LankaFetchTransport.ts
+var CONTENT_TYPE = "content-type";
+var JSON_CONTENT_TYPE = "application/json";
+var LankaFetchTransport = class {
   async request(resource, options) {
-    if (options?.body && !(options.body instanceof FormData)) {
-      const headers = new Headers(options.headers);
-      let body = options.body;
-      if (typeof body === "object" && !(body instanceof FormData) && !(body instanceof Blob)) {
-        body = JSON.stringify(body);
-      }
-      headers.set("Content-Type", "application/json");
-      return await fetch(resource, {
-        ...options,
-        headers,
-        body
-      });
+    if (options === void 0 || options.body === void 0 || options.body === null) {
+      return await fetch(resource, options);
     }
-    return await fetch(resource, options);
+    const { body, headers } = options;
+    if (isFormData(body)) {
+      if (headers === void 0) return await fetch(resource, options);
+      const stripped = new Headers(headers);
+      stripped.delete(CONTENT_TYPE);
+      return await fetch(resource, { ...options, headers: stripped });
+    }
+    if (isEncodedBody(body)) return await fetch(resource, options);
+    return await fetch(resource, {
+      ...options,
+      headers: withJsonContentType(headers),
+      body: JSON.stringify(body)
+    });
   }
 };
+function withJsonContentType(headers) {
+  const result = new Headers(headers);
+  if (!result.has(CONTENT_TYPE)) result.set(CONTENT_TYPE, JSON_CONTENT_TYPE);
+  return result;
+}
+function isEncodedBody(body) {
+  if (typeof body === "string") return true;
+  if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) return true;
+  if (typeof Blob !== "undefined" && body instanceof Blob) return true;
+  if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return true;
+  return typeof ReadableStream !== "undefined" && body instanceof ReadableStream;
+}
+function isFormData(body) {
+  return typeof FormData !== "undefined" && body instanceof FormData;
+}
 
 // src/gateway/request/lanka-fetch-json-request/LankaFetchJsonRequest.ts
 var LankaFetchJsonRequest = class extends ALankaTransportRequest {
   constructor(config = {}) {
-    super(config, () => new LankaFetchJsonTransport());
+    super(config, () => new LankaFetchTransport());
   }
   /**
    * Parses the body, or names the failure.
@@ -269,12 +291,22 @@ var buildLankaQueryParams = (input) => {
 var ALankaGateway = class {
   requestExecutor;
   queryParamsHandler;
+  /**
+   * The validator a method checks a response body with.
+   *
+   * `config.validationService` when one was given, the Standard Schema port
+   * otherwise. It used to be accepted by the config and read by nothing: a
+   * consumer handing a test double to the gateway got the real validator and no
+   * error, which is the worst kind of ignored option — it looks honoured.
+   */
+  validationService;
   useMock;
   basePath;
   constructor(config) {
     lankaLogger.printGatewayLog("Create gateway", this);
     const flags = getLankaFlags();
     this.useMock = config.useMock ?? flags.isMockMode ?? false;
+    this.validationService = config.validationService ?? lankaStandardValidator;
     this.requestExecutor = config.request ?? new LankaFetchJsonRequest();
     this.basePath = config.basePath ?? "";
     this.queryParamsHandler = config.queryParamsHandler ?? buildLankaQueryParams;
@@ -363,20 +395,14 @@ var createLankaGateway = (config) => {
       return config.methods({
         endpoint: (path) => this.endpoint(path),
         request: (path, options, mockHandler) => this.request(path, options, mockHandler),
-        buildQueryParams: (params) => this.buildQueryParams(params)
+        buildQueryParams: (params) => this.buildQueryParams(params),
+        validationService: this.validationService
       });
     }
   }
   return new FunctionalGateway(config).build();
 };
 
-// src/gateway/transport/lanka-fetch-transport/LankaFetchTransport.ts
-var LankaFetchTransport = class {
-  async request(resource, options) {
-    return await fetch(resource, options);
-  }
-};
-
 // src/gateway/request/lanka-fetch-request/LankaFetchRequest.ts
 var LankaFetchRequest = class extends ALankaTransportRequest {
   constructor(config = {}) {
@@ -392,43 +418,13 @@ var createLankaFetchRequest = (config = {}) => new LankaFetchRequest(config);
 
 // src/gateway/request/_factories/create-lanka-fetch-json-request/createLankaFetchJsonRequest.ts
 var createLankaFetchJsonRequest = (config = {}) => new LankaFetchJsonRequest(config);
-
-// src/gateway/transport/lanka-fetch-form-data-transport/LankaFetchFormDataTransport.ts
-var LankaFetchFormDataTransport = class {
-  async request(resource, options) {
-    const formDataOptions = { ...options };
-    if (formDataOptions.body instanceof FormData && formDataOptions.headers) {
-      const headers = new Headers(formDataOptions.headers);
-      headers.delete("Content-Type");
-      formDataOptions.headers = headers;
-    }
-    return await fetch(resource, formDataOptions);
-  }
-};
-
-// src/gateway/request/lanka-fetch-form-data-request/LankaFetchFormDataRequest.ts
-var LankaFetchFormDataRequest = class extends ALankaTransportRequest {
-  constructor(config = {}) {
-    super(config, () => new LankaFetchFormDataTransport());
-  }
-  parse(response) {
-    return Promise.resolve(response);
-  }
-};
-
-// src/gateway/request/_factories/create-lanka-fetch-form-data-request/createLankaFetchFormDataRequest.ts
-var createLankaFetchFormDataRequest = (config = {}) => new LankaFetchFormDataRequest(config);
 export {
   ALankaGateway,
   ALankaRequest,
-  LankaFetchFormDataRequest,
-  LankaFetchFormDataTransport,
   LankaFetchJsonRequest,
-  LankaFetchJsonTransport,
   LankaFetchRequest,
   LankaFetchTransport,
   buildLankaQueryParams,
-  createLankaFetchFormDataRequest,
   createLankaFetchJsonRequest,
   createLankaFetchRequest,
   createLankaGateway,