@bleedingdev/modern-js-bff-effect 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/dist/types/effect/handler/batch.d.ts

@@ -1,7 +1,6 @@
 import { type DataBatchRequestPayload, type DataBatchResponseItem } from '../../data-platform/index.js';
 export { toHeaderRecord } from '../../headers.js';
 export declare function normalizeBatchPath(pathname: string | undefined): `/${string}`;
-export declare function normalizeBatchAllowedMethods(allowedMethods: string[] | undefined): Set<string>;
 type ParsedBatchRequestPayload = Omit<DataBatchRequestPayload, 'items'> & {
     items: unknown[];
 };
@@ -9,7 +8,13 @@ export declare function isBatchRequestPayload(value: unknown): value is ParsedBa
 export declare function createBatchValidationResponse(message: string, status?: number): Response;
 export declare function prepareJsonRequestBody(request: Request): Promise<Request | Response>;
 export declare function toBatchItemError(id: string, status: number, message: string): DataBatchResponseItem;
-export declare class BatchItemTimeoutError extends Error {
+declare const BatchItemTimeoutError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "BatchItemTimeoutError";
+} & Readonly<A>;
+export declare class BatchItemTimeoutError extends BatchItemTimeoutError_base<{
+    readonly message: string;
+}> {
+    constructor(message: string);
 }
 export declare function promiseWithTimeout<T>(effect: Promise<T>, timeoutMs: number, onTimeout?: (error: BatchItemTimeoutError) => void): Promise<T>;
 export declare function mapWithConcurrency<TItem, TResult>(items: readonly TItem[], concurrency: number, mapper: (item: TItem, index: number) => Promise<TResult>): Promise<TResult[]>;

package/dist/types/effect/handler/types.d.ts

@@ -1,6 +1,5 @@
 import type { FileSystem, Path } from 'effect';
 import * as Context from 'effect/Context';
-import type * as EffectType from 'effect/Effect';
 import type * as Layer from 'effect/Layer';
 import type { Etag, HttpPlatform, HttpRouter } from 'effect/unstable/http';
 import type { HttpApi, HttpApiClient, HttpApiGroup } from 'effect/unstable/httpapi';
@@ -10,7 +9,7 @@ import type { createRpcApiHandler } from './rpc.js';
 export type EffectRuntimeRequirements = Etag.Generator | FileSystem.FileSystem | HttpPlatform.HttpPlatform | HttpRouter.HttpRouter | HttpRouter.Request<'Error', unknown> | HttpRouter.Request<'GlobalError', unknown> | HttpRouter.Request<'GlobalRequires', unknown> | HttpRouter.Request<'Requires', unknown> | Path.Path;
 export type EffectRuntimeLayer = Layer.Layer<never, never, EffectRuntimeRequirements>;
 export declare const toEffectServiceContext: (context: unknown) => Context.Context<any>;
-export type EffectRpcSerialization = 'json' | 'ndjson' | 'jsonRpc' | 'ndJsonRpc' | 'msgPack';
+export type EffectRpcSerialization = 'json' | 'ndjson' | 'jsonRpc' | 'ndJsonRpc';
 export type EffectRpcRuntimeLayer<TRpcs extends Rpc.Any = Rpc.Any> = Layer.Layer<Rpc.ToHandler<TRpcs> | Rpc.Middleware<TRpcs> | Rpc.ServicesServer<TRpcs>, unknown, never>;
 export type EffectRpcBffDefinition<TRpcs extends Rpc.Any = Rpc.Any, TRpcLayer extends EffectRpcRuntimeLayer<TRpcs> = EffectRpcRuntimeLayer<TRpcs>> = {
     group: RpcGroup.RpcGroup<TRpcs>;
@@ -23,13 +22,7 @@ export type EffectRpcBffDefinition<TRpcs extends Rpc.Any = Rpc.Any, TRpcLayer ex
     disableFatalDefects?: boolean;
 };
 export type EffectRpcBffHandlerOptions = Pick<EffectRpcBffDefinition, 'path' | 'serialization' | 'disableTracing' | 'spanPrefix' | 'spanAttributes' | 'disableFatalDefects'>;
-type EffectApiPromiseClient<TClient> = {
-    [GroupName in keyof TClient]: {
-        [EndpointName in keyof TClient[GroupName]]: TClient[GroupName][EndpointName] extends (...args: infer TArgs) => infer TResult ? TResult extends EffectType.Effect<unknown, unknown, unknown> ? (...args: TArgs) => Promise<Exclude<EffectType.Success<TResult>, readonly [unknown, unknown]>> : never : never;
-    };
-};
 export type EffectApiClientFromApi<TApi extends HttpApi.Constraint = HttpApi.Top> = TApi extends HttpApi.HttpApi<infer _ApiId, infer Groups> ? HttpApiClient.Client<Extract<Groups, HttpApiGroup.Constraint>, never, never> : never;
-export type EffectApiPromiseClientFromApi<TApi extends HttpApi.Constraint = HttpApi.Top> = EffectApiPromiseClient<EffectApiClientFromApi<TApi>>;
 export type EffectBffDefinition<TApi extends HttpApi.Constraint = HttpApi.Top, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer, TRpcs extends Rpc.Any = Rpc.Any> = {
     api: TApi;
     layer: TLayer;
@@ -63,12 +56,6 @@ export type EffectDataPlatformBatchOptions = {
      * Defaults to `65536` (64KiB).
      */
     maxBatchBytes?: number;
-    /**
-     * Client-side micro-batch flush window in milliseconds.
-     * Server runtime ignores this value and passes it through for codegen.
-     * Defaults to `8`.
-     */
-    flushIntervalMs?: number;
     /**
      * Maximum per-batch internal request concurrency.
      * Defaults to `4`.
@@ -136,7 +123,7 @@ export type EffectRequestInterceptor = (options: {
     request: Request;
     next: () => Promise<Response>;
 }) => Response | Promise<Response>;
-export type EffectBffHandlerFactory<TApi extends HttpApi.Constraint = HttpApi.Top, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer> = (options?: {
+export type EffectBffHandlerFactory<_TApi extends HttpApi.Constraint = HttpApi.Top, _TLayer extends EffectRuntimeLayer = EffectRuntimeLayer> = (options?: {
     openapi?: EffectBffOpenApiConfig;
     rpc?: Partial<EffectRpcBffHandlerOptions>;
     dataPlatform?: Partial<EffectDataPlatformValidationOptions>;
@@ -144,10 +131,8 @@ export type EffectBffHandlerFactory<TApi extends HttpApi.Constraint = HttpApi.To
 }) => ReturnType<typeof createHttpApiHandler>;
 export type EffectBffRuntime<TApi extends HttpApi.Constraint = HttpApi.Top, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer> = {
     createHandler: EffectBffHandlerFactory<TApi, TLayer>;
-    client: EffectApiPromiseClientFromApi<TApi>;
 };
 export type EffectBffOpenApiConfig = boolean | {
     path?: string;
 };
 export type EffectRpcBffHandlerFactory<TRpcs extends Rpc.Any = Rpc.Any> = (options?: Partial<EffectRpcBffHandlerOptions>) => ReturnType<typeof createRpcApiHandler<TRpcs>>;
-export {};

package/dist/types/effect/handler.d.ts

@@ -10,4 +10,4 @@ export { HttpApiBuilder } from 'effect/unstable/httpapi';
 export * from 'effect/unstable/rpc';
 export { defineEffectBff, defineEffectRpcBff } from './handler/definition.js';
 export { createHttpApiHandler } from './handler/http.js';
-export type { EffectApiClientFromApi, EffectApiPromiseClientFromApi, EffectBffDefinition, EffectBffHandlerFactory, EffectBffOpenApiConfig, EffectBffRuntime, EffectDataPlatformBatchOptions, EffectDataPlatformSelectionValidationOptions, EffectDataPlatformValidationOptions, EffectRequestValidator, EffectRpcBffDefinition, EffectRpcBffHandlerFactory, EffectRpcBffHandlerOptions, EffectRpcRuntimeLayer, EffectRpcSerialization, EffectRuntimeLayer, EffectRuntimeRequirements, } from './handler/types.js';
+export type { EffectApiClientFromApi, EffectBffDefinition, EffectBffHandlerFactory, EffectBffOpenApiConfig, EffectBffRuntime, EffectDataPlatformBatchOptions, EffectDataPlatformSelectionValidationOptions, EffectDataPlatformValidationOptions, EffectRequestValidator, EffectRpcBffDefinition, EffectRpcBffHandlerFactory, EffectRpcBffHandlerOptions, EffectRpcRuntimeLayer, EffectRpcSerialization, EffectRuntimeLayer, EffectRuntimeRequirements, } from './handler/types.js';

package/dist/types/effect/module.d.ts

@@ -1,5 +1,5 @@
 import type * as EffectServiceContext from 'effect/Context';
-import { type EffectBffOpenApiConfig, type EffectDataPlatformValidationOptions, type EffectRequestValidator } from './handler.js';
+import { type EffectBffOpenApiConfig, type EffectDataPlatformValidationOptions, type EffectRequestValidator, type EffectRpcBffDefinition } from './handler.js';
 import type { EffectContext } from './operation-context.js';
 export type EffectBffRequestHandler = (request: Request, context?: EffectServiceContext.Context<any> | EffectContext) => Promise<Response> | Response;
 export type EffectBffHandlerFactory = (options?: {
@@ -13,6 +13,7 @@ export type EffectBffHandlerFactory = (options?: {
 export type EffectApiModule = {
     api?: unknown;
     layer?: unknown;
+    rpc?: EffectRpcBffDefinition;
     handler?: EffectBffRequestHandler;
     createHandler?: EffectBffHandlerFactory;
     default?: unknown;

package/dist/types/effect/operation-context.d.ts

@@ -1,4 +1,4 @@
-import { type OperationContext } from '@modern-js/create-request';
+import { type OperationContext } from '@modern-js/runtime-extensions/request-context';
 export type EffectContext = {
     request: Request;
     env: Record<string, unknown>;
@@ -10,6 +10,5 @@ export type EffectContextStorage = {
     getStore: () => EffectContext | undefined;
     run: <TResult>(value: EffectContext, cb: () => TResult) => TResult;
 };
-export declare const kEffectContextStorage: unique symbol;
 export type CreateEffectOperationContextOptions = Omit<EffectContext, 'operationContext'>;
 export declare const createEffectOperationContext: ({ request, path, method, }: CreateEffectOperationContextOptions) => OperationContext;

package/dist/types/effect-client/cross-project.d.ts

@@ -0,0 +1,10 @@
+import { HttpClient } from 'effect/unstable/http';
+import { HttpApi, type HttpApiGroup } from 'effect/unstable/httpapi';
+export interface EffectCrossProjectClientOptions {
+    requestId: string;
+    operationVersion: number;
+    /** Server mount path, independent of the API origin. */
+    prefix: string;
+}
+/** Native transport middleware; endpoint encoding and inference stay in Effect. */
+export declare function withCrossProjectPolicy<Id extends string, Groups extends HttpApiGroup.Constraint>(api: HttpApi.HttpApi<Id, Groups>, options: EffectCrossProjectClientOptions, client: HttpClient.HttpClient): HttpClient.HttpClient;

package/dist/types/effect-client/index.d.ts

@@ -1,15 +1,18 @@
-import { type RequestContextInput } from '@modern-js/create-request';
+import { type RequestContextInput } from '@modern-js/runtime-extensions/request-context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 import { HttpClient } from 'effect/unstable/http';
 import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from 'effect/unstable/httpapi';
-import { Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization } from 'effect/unstable/rpc';
+import { Rpc, RpcClient, RpcClientError, RpcGroup, RpcSchema, RpcSerialization } from 'effect/unstable/rpc';
+import { type EffectCrossProjectClientOptions } from './cross-project.js';
 export * as Effect from 'effect/Effect';
 export * as Layer from 'effect/Layer';
 export * as Schema from 'effect/Schema';
 export * as HttpClientError from 'effect/unstable/http/HttpClientError';
+export type { EffectCrossProjectClientOptions } from './cross-project.js';
 export { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization, };
 export type EffectHttpApiClientOptions = {
+    crossProject?: EffectCrossProjectClientOptions;
     baseUrl?: URL | string;
     requestContext?: RequestContextInput;
     transformClient?: (client: HttpClient.HttpClient) => HttpClient.HttpClient;
@@ -27,7 +30,7 @@ export type EffectViewSelection<T> = {
 export type EffectViewData<T, Selection> = Selection extends true ? T : Selection extends Record<string, unknown> ? {
     [K in keyof Selection & keyof T]: EffectMaskedValue<T[K], Selection[K]>;
 } : T;
-export type EffectRpcSerialization = 'json' | 'ndjson' | 'jsonRpc' | 'ndJsonRpc' | 'msgPack';
+export type EffectRpcSerialization = 'json' | 'ndjson' | 'jsonRpc' | 'ndJsonRpc';
 declare const EffectRpcClientError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "EffectRpcClientError";
 } & Readonly<A>;
@@ -47,7 +50,7 @@ export type EffectRpcClientOptions<Rpcs extends Rpc.Any, Flatten extends boolean
     flatten?: Flatten;
     serialization?: EffectRpcSerialization;
 };
-export type EffectRpcClientHandle<Rpcs extends Rpc.Any, Flatten extends boolean = false> = (Flatten extends true ? RpcClient.RpcClient.Flat<Rpcs, unknown> : RpcClient.RpcClient<Rpcs, unknown>) & {
+export type EffectRpcClientHandle<Rpcs extends Rpc.Any, Flatten extends boolean = false> = (Flatten extends true ? RpcClient.RpcClient.Flat<Rpcs, RpcClientError.RpcClientError> : RpcClient.RpcClient<Rpcs, RpcClientError.RpcClientError>) & {
     dispose: () => Promise<void>;
 };
 export declare function view<T>(): <const Selection extends EffectViewSelection<T>>(selection: Selection) => Selection;

package/dist/types/microvertical-api.d.ts

@@ -0,0 +1,65 @@
+import { Schema } from 'effect';
+export declare const MicroVerticalBuildMarkerSchema: Schema.Struct<{
+    readonly appId: Schema.compose<Schema.String, Schema.brand<Schema.String, "MicroVerticalAppId">>;
+    readonly build: Schema.String;
+    readonly buildMarker: Schema.String;
+    readonly deployProfile: Schema.String;
+    readonly packageName: Schema.String;
+    readonly sourceRevision: Schema.String;
+    readonly surface: Schema.String;
+    readonly unitId: Schema.compose<Schema.String, Schema.brand<Schema.String, "MicroVerticalUnitId">>;
+    readonly version: Schema.String;
+}>;
+export type MicroVerticalBuildMarker = typeof MicroVerticalBuildMarkerSchema.Type;
+export declare const MicroVerticalReadinessSchema: Schema.Struct<{
+    readonly checks: Schema.Struct<{
+        readonly api: Schema.Literal<"ready">;
+        readonly moduleFederation: Schema.Literal<"ready">;
+        readonly ssr: Schema.Literal<"ready">;
+        readonly translations: Schema.Literal<"ready">;
+    }>;
+    readonly marker: Schema.Struct<{
+        readonly appId: Schema.compose<Schema.String, Schema.brand<Schema.String, "MicroVerticalAppId">>;
+        readonly build: Schema.String;
+        readonly buildMarker: Schema.String;
+        readonly deployProfile: Schema.String;
+        readonly packageName: Schema.String;
+        readonly sourceRevision: Schema.String;
+        readonly surface: Schema.String;
+        readonly unitId: Schema.compose<Schema.String, Schema.brand<Schema.String, "MicroVerticalUnitId">>;
+        readonly version: Schema.String;
+    }>;
+    readonly status: Schema.Literal<"ready">;
+    readonly versionSkew: Schema.Literal<"none">;
+}>;
+export type MicroVerticalReadiness = typeof MicroVerticalReadinessSchema.Type;
+export declare const MicroVerticalOperationSourceSchema: Schema.Literals<readonly ["client", "server", "generated-client", "effect-server", "data-platform", "unknown"]>;
+export type MicroVerticalOperationSource = typeof MicroVerticalOperationSourceSchema.Type;
+export declare const MicroVerticalOperationContextSchema: Schema.Struct<{
+    readonly method: Schema.String;
+    readonly operationId: Schema.compose<Schema.String, Schema.brand<Schema.String, "MicroVerticalOperationId">>;
+    readonly routePath: Schema.String;
+    readonly source: Schema.Literals<readonly ["client", "server", "generated-client", "effect-server", "data-platform", "unknown"]>;
+    readonly traceId: Schema.optionalKey<Schema.compose<Schema.String, Schema.brand<Schema.String, "MicroVerticalTraceId">>>;
+}>;
+export type MicroVerticalOperationContext = typeof MicroVerticalOperationContextSchema.Type;
+export declare const createMicroVerticalOperationContext: <const Method extends string, const OperationId extends string, const RoutePath extends string>(input: {
+    readonly method: Method;
+    readonly operationId: OperationId;
+    readonly routePath: RoutePath;
+    readonly traceId?: string;
+}) => Readonly<typeof input & {
+    source: 'generated-client';
+}>;
+export declare const microVerticalOperationAttributes: (operationContext: MicroVerticalOperationContext) => {
+    'modernjs.operation.id': string;
+    'modernjs.operation.method': string;
+    'modernjs.operation.route': string;
+    'modernjs.operation.source': "client" | "data-platform" | "effect-server" | "generated-client" | "server" | "unknown";
+} | {
+    'modernjs.operation.id': string;
+    'modernjs.operation.method': string;
+    'modernjs.operation.route': string;
+    'modernjs.operation.source': "client" | "data-platform" | "effect-server" | "generated-client" | "server" | "unknown";
+    'modernjs.trace.id': string;
+};

package/package.json

@@ -18,7 +18,7 @@
     "modern.js",
     "ultramodern.js"
   ],
-  "version": "3.9.0-ultramodern.2",
+  "version": "3.9.0-ultramodern.21",
   "files": [
     "dist",
     "src"
@@ -35,55 +35,50 @@
     "./package.json": "./package.json",
     ".": {
       "types": "./dist/types/index.d.ts",
-      "node": {
-        "import": "./dist/esm-node/index.mjs",
-        "require": "./dist/cjs/index.js"
-      },
+      "node": "./dist/esm-node/index.mjs",
+      "import": "./dist/esm/index.mjs",
       "default": "./dist/cjs/index.js"
     },
     "./effect": {
       "types": "./dist/types/effect/index.d.ts",
-      "node": {
-        "import": "./dist/esm-node/effect/index.mjs",
-        "require": "./dist/cjs/effect/index.js"
-      },
+      "node": "./dist/esm-node/effect/index.mjs",
+      "import": "./dist/esm/effect/index.mjs",
       "default": "./dist/cjs/effect/index.js"
     },
+    "./context": {
+      "types": "./dist/types/effect/context.d.ts",
+      "node": "./dist/esm-node/effect/context.mjs",
+      "import": "./dist/esm/effect/context.mjs",
+      "default": "./dist/cjs/effect/context.js"
+    },
     "./effect-edge": {
       "types": "./dist/types/effect/edge.d.ts",
-      "node": {
-        "import": "./dist/esm-node/effect/edge.mjs",
-        "require": "./dist/cjs/effect/edge.js"
-      },
+      "node": "./dist/esm-node/effect/edge.mjs",
       "import": "./dist/esm/effect/edge.mjs",
       "default": "./dist/esm/effect/edge.mjs"
     },
     "./effect-client": {
       "types": "./dist/types/effect-client/index.d.ts",
-      "node": {
-        "import": "./dist/esm-node/effect-client/index.mjs",
-        "require": "./dist/cjs/effect-client/index.js"
-      },
+      "node": "./dist/esm-node/effect-client/index.mjs",
       "import": "./dist/esm/effect-client/index.mjs",
       "default": "./dist/esm/effect-client/index.mjs"
     },
-    "./effect-client-runtime": {
-      "types": "./dist/types/effect-client/runtime.d.ts",
-      "node": {
-        "import": "./dist/esm-node/effect-client/runtime.mjs",
-        "require": "./dist/cjs/effect-client/runtime.js"
-      },
-      "import": "./dist/esm/effect-client/runtime.mjs",
-      "default": "./dist/esm/effect-client/runtime.mjs"
+    "./microvertical-api": {
+      "types": "./dist/types/microvertical-api.d.ts",
+      "node": "./dist/esm-node/microvertical-api.mjs",
+      "import": "./dist/esm/microvertical-api.mjs",
+      "default": "./dist/esm/microvertical-api.mjs"
     },
     "./data-platform": {
       "types": "./dist/types/data-platform/index.d.ts",
-      "node": {
-        "import": "./dist/esm-node/data-platform/index.mjs",
-        "require": "./dist/cjs/data-platform/index.js"
-      },
+      "node": "./dist/esm-node/data-platform/index.mjs",
       "import": "./dist/esm/data-platform/index.mjs",
       "default": "./dist/esm/data-platform/index.mjs"
+    },
+    "./assembly": {
+      "types": "./dist/types/assembly.d.ts",
+      "node": "./dist/esm-node/assembly.mjs",
+      "default": "./dist/esm/assembly.mjs"
     }
   },
   "typesVersions": {
@@ -96,6 +91,10 @@
         "./dist/types/effect/index.d.ts",
         "./src/effect/index.ts"
       ],
+      "context": [
+        "./dist/types/effect/context.d.ts",
+        "./src/effect/context.ts"
+      ],
       "effect-edge": [
         "./dist/types/effect/edge.d.ts",
         "./src/effect/edge.ts"
@@ -104,13 +103,17 @@
         "./dist/types/effect-client/index.d.ts",
         "./src/effect-client/index.ts"
       ],
-      "effect-client-runtime": [
-        "./dist/types/effect-client/runtime.d.ts",
-        "./src/effect-client/runtime.ts"
+      "microvertical-api": [
+        "./dist/types/microvertical-api.d.ts",
+        "./src/microvertical-api.ts"
       ],
       "data-platform": [
         "./dist/types/data-platform/index.d.ts",
         "./src/data-platform/index.ts"
+      ],
+      "assembly": [
+        "./dist/types/assembly.d.ts",
+        "./src/assembly.ts"
       ]
     }
   },
@@ -118,9 +121,10 @@
     "node": ">=26.7.0"
   },
   "dependencies": {
-    "@modern-js/bff-core": "npm:@bleedingdev/modern-js-bff-core@3.9.0-ultramodern.2",
-    "@modern-js/create-request": "npm:@bleedingdev/modern-js-create-request@3.9.0-ultramodern.2",
-    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.2",
+    "@modern-js/bff-core": "npm:@bleedingdev/modern-js-bff-core@3.9.0-ultramodern.21",
+    "@modern-js/create-request": "npm:@bleedingdev/modern-js-create-request@3.9.0-ultramodern.21",
+    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.21",
+    "@modern-js/server-runtime-extensions": "npm:@bleedingdev/modern-js-server-runtime-extensions@3.9.0-ultramodern.21",
     "@opentelemetry/api": "1.9.1",
     "@opentelemetry/api-logs": "0.222.0",
     "@opentelemetry/resources": "2.11.0",
@@ -132,8 +136,8 @@
     "@opentelemetry/semantic-conventions": "1.43.0"
   },
   "peerDependencies": {
-    "@effect/opentelemetry": "4.0.0-rc.112",
-    "effect": "4.0.0-rc.112"
+    "@effect/opentelemetry": "4.0.0-rc.117",
+    "effect": "4.0.0-rc.117"
   },
   "peerDependenciesMeta": {
     "@effect/opentelemetry": {
@@ -144,13 +148,14 @@
     }
   },
   "devDependencies": {
-    "@effect/opentelemetry": "4.0.0-rc.112",
-    "@rslib/core": "1.0.0",
+    "@effect/opentelemetry": "4.0.0-rc.117",
+    "@rslib/core": "1.0.2",
     "@scripts/rstest-config": "2.66.0",
-    "@types/node": "^26.4.1",
-    "@types/react": "^19.2.18",
+    "@types/node": "^26.6.2",
+    "@types/react": "^19.3.0",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
-    "effect": "4.0.0-rc.112"
+    "effect": "4.0.0-rc.117",
+    "esbuild": "^0.28.2"
   },
   "sideEffects": false,
   "publishConfig": {

package/src/assembly.ts

@@ -0,0 +1,43 @@
+/** Server-only assembly for the invariant tail of a strict Effect BFF runtime factory. */
+import * as Layer from 'effect/Layer';
+import type { HttpApi, HttpApiGroup } from 'effect/unstable/httpapi';
+import { HttpApiBuilder } from 'effect/unstable/httpapi';
+import { defineEffectBff } from './effect/handler/definition';
+import type { EffectRuntimeRequirements } from './effect/handler/types';
+
+export interface EffectBffRuntimeAssembly<
+  ApiId extends string,
+  Groups extends HttpApiGroup.Constraint,
+  HandlerRequirements extends EffectRuntimeRequirements,
+  TransportRequirements extends EffectRuntimeRequirements = never,
+> {
+  readonly api: HttpApi.HttpApi<ApiId, Groups>;
+  readonly handlers: Layer.Layer<
+    HttpApiGroup.ToService<ApiId, Groups>,
+    never,
+    HandlerRequirements
+  >;
+  readonly transport?: Layer.Layer<never, never, TransportRequirements>;
+}
+
+export const assembleEffectBffRuntime = <
+  ApiId extends string,
+  Groups extends HttpApiGroup.Constraint,
+  HandlerRequirements extends EffectRuntimeRequirements,
+  TransportRequirements extends EffectRuntimeRequirements = never,
+>({
+  api,
+  handlers,
+  transport,
+}: EffectBffRuntimeAssembly<
+  ApiId,
+  Groups,
+  HandlerRequirements,
+  TransportRequirements
+>) => {
+  const apiLayer = HttpApiBuilder.layer(api).pipe(Layer.provide(handlers));
+  const layer =
+    transport === undefined ? apiLayer : apiLayer.pipe(Layer.merge(transport));
+
+  return defineEffectBff({ api, layer });
+};

package/src/data-platform/batch/options.ts

@@ -0,0 +1,20 @@
+import type { DataBatchTransportOptions } from '../types';
+
+/** Wire limits and method eligibility are identical on both sides. */
+export function normalizeBatchLimits(
+  options: Pick<
+    DataBatchTransportOptions,
+    'maxBatchSize' | 'maxBatchBytes' | 'allowedMethods'
+  > = {},
+) {
+  return {
+    maxBatchSize: Math.max(1, options.maxBatchSize ?? 16),
+    maxBatchBytes: Math.max(1024, options.maxBatchBytes ?? 64 * 1024),
+    allowedMethods: new Set(
+      (options.allowedMethods !== undefined && options.allowedMethods.length > 0
+        ? options.allowedMethods
+        : ['GET']
+      ).map(method => method.toUpperCase()),
+    ),
+  };
+}