effective-rsc 0.1.0

package/dist/dev/runtime-failure.d.ts

@@ -0,0 +1,11 @@
+import { Effect } from 'effect';
+export type DevRuntimeFailure = {
+    readonly _tag: 'RuntimeError' | 'UnhandledRejection';
+    readonly name: string;
+    readonly message: string;
+    readonly stack?: string;
+    readonly componentStack?: string;
+};
+export declare const fromBrowserError: (event: Pick<ErrorEvent, 'error' | 'message'>) => DevRuntimeFailure;
+export declare const fromUnhandledRejection: (event: Pick<PromiseRejectionEvent, 'reason'>) => DevRuntimeFailure;
+export declare const reportBrowserFailures: (report: (failure: DevRuntimeFailure) => Effect.Effect<void>) => Effect.Effect<void, never, never>;

package/dist/dev/runtime-failure.js

@@ -0,0 +1,32 @@
+import { Effect, Inspectable, Predicate, Stream } from "effect";
+
+
+
+const fromUnknown = (_tag, value, fallbackMessage)=>{
+    if (Predicate.isError(value)) {
+        return {
+            _tag,
+            name: value.name,
+            message: value.message,
+            ...value.stack === undefined ? {} : {
+                stack: value.stack
+            }
+        };
+    }
+    return {
+        _tag,
+        name: _tag === 'UnhandledRejection' ? 'UnhandledRejection' : 'Error',
+        message: value === undefined ? fallbackMessage : Inspectable.toStringUnknown(value)
+    };
+};
+const fromBrowserError = (event)=>fromUnknown('RuntimeError', event.error === null ? undefined : event.error, event.message || 'Unknown browser error.');
+const fromUnhandledRejection = (event)=>fromUnknown('UnhandledRejection', event.reason, 'Unhandled promise rejection.');
+const reportBrowserFailures = Effect.fnUntraced(function*(report) {
+    const errors = Stream.fromEventListener(window, 'error').pipe(Stream.map(fromBrowserError));
+    const rejections = Stream.fromEventListener(window, 'unhandledrejection').pipe(Stream.map(fromUnhandledRejection));
+    yield* Stream.merge(errors, rejections).pipe(Stream.runForEach(report));
+});
+
+export { fromBrowserError, fromUnhandledRejection, reportBrowserFailures };
+
+//# sourceMappingURL=runtime-failure.js.map

package/dist/dev/runtime-failure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev/runtime-failure.js","sources":["../../src/dev/runtime-failure.ts"],"sourcesContent":["import { Effect, Inspectable, Predicate, Stream } from 'effect';\n\nexport type DevRuntimeFailure = {\n  readonly _tag: 'RuntimeError' | 'UnhandledRejection';\n  readonly name: string;\n  readonly message: string;\n  readonly stack?: string;\n  readonly componentStack?: string;\n};\n\nconst fromUnknown = (\n  _tag: DevRuntimeFailure['_tag'],\n  value: unknown,\n  fallbackMessage: string,\n): DevRuntimeFailure => {\n  if (Predicate.isError(value)) {\n    return {\n      _tag,\n      name: value.name,\n      message: value.message,\n      ...(value.stack === undefined ? {} : { stack: value.stack }),\n    };\n  }\n\n  return {\n    _tag,\n    name: _tag === 'UnhandledRejection' ? 'UnhandledRejection' : 'Error',\n    message: value === undefined ? fallbackMessage : Inspectable.toStringUnknown(value),\n  };\n};\n\nexport const fromBrowserError = (event: Pick<ErrorEvent, 'error' | 'message'>): DevRuntimeFailure =>\n  fromUnknown(\n    'RuntimeError',\n    event.error === null ? undefined : event.error,\n    event.message || 'Unknown browser error.',\n  );\n\nexport const fromUnhandledRejection = (\n  event: Pick<PromiseRejectionEvent, 'reason'>,\n): DevRuntimeFailure =>\n  fromUnknown('UnhandledRejection', event.reason, 'Unhandled promise rejection.');\n\nexport const reportBrowserFailures = Effect.fnUntraced(function* (\n  report: (failure: DevRuntimeFailure) => Effect.Effect<void>,\n) {\n  const errors = Stream.fromEventListener<ErrorEvent>(window, 'error').pipe(\n    Stream.map(fromBrowserError),\n  );\n  const rejections = Stream.fromEventListener<PromiseRejectionEvent>(\n    window,\n    'unhandledrejection',\n  ).pipe(Stream.map(fromUnhandledRejection));\n\n  yield* Stream.merge(errors, rejections).pipe(Stream.runForEach(report));\n});\n"],"names":["Effect","Inspectable","Predicate","Stream","fromUnknown","_tag","value","fallbackMessage","undefined","fromBrowserError","event","fromUnhandledRejection","reportBrowserFailures","report","errors","window","rejections"],"mappings":";;;AAAgE;AAUhE,MAAMI,WAAWA,GAAG,CAClBC,MACAC,OACAC;IAEA,IAAIL,iBAAiB,CAACI,QAAQ;QAC5B,OAAO;YACLD;YACA,MAAMC,MAAM,IAAI;YAChB,SAASA,MAAM,OAAO;YACtB,GAAIA,MAAM,KAAK,KAAKE,YAAY,CAAC,IAAI;gBAAE,OAAOF,MAAM,KAAK;YAAC,CAAC;QAC7D;IACF;IAEA,OAAO;QACLD;QACA,MAAMA,SAAS,uBAAuB,uBAAuB;QAC7D,SAASC,UAAUE,YAAYD,kBAAkBN,2BAA2B,CAACK;IAC/E;AACF;AAEO,MAAMG,gBAAgBA,GAAG,CAACC,QAC/BN,WAAWA,CACT,gBACAM,MAAM,KAAK,KAAK,OAAOF,YAAYE,MAAM,KAAK,EAC9CA,MAAM,OAAO,IAAI,0BACjB;AAEG,MAAMC,sBAAsBA,GAAG,CACpCD,QAEAN,WAAWA,CAAC,sBAAsBM,MAAM,MAAM,EAAE,gCAAgC;AAE3E,MAAME,qBAAqBA,GAAGZ,iBAAiB,CAAC,UACrDa,MAA2D;IAE3D,MAAMC,SAASX,wBAAwB,CAAaY,QAAQ,SAAS,IAAI,CACvEZ,UAAU,CAACM,gBAAgBA;IAE7B,MAAMO,aAAab,wBAAwB,CACzCY,QACA,sBACA,IAAI,CAACZ,UAAU,CAACQ,sBAAsBA;IAExC,OAAOR,YAAY,CAACW,QAAQE,YAAY,IAAI,CAACb,iBAAiB,CAACU;AACjE,GAAG"}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { Application } from './application/ersc.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+
+
+
+export { Application } from "./application/ersc.js";
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":["export { Application } from './application/ersc';\n"],"names":["Application"],"mappings":";AAAiD"}

package/dist/rsc/flight.d.ts

@@ -0,0 +1,16 @@
+import type { ReactFormState } from 'react-dom/client';
+import type { RouteTreeModel } from './route-tree.js';
+export type FlightPayload = {
+    readonly formState: ReactFormState | null;
+    readonly routeTree: RouteTreeModel;
+    readonly serverFnResult: ServerFnResult | null;
+};
+export type ServerFnResult = {
+    readonly _tag: 'Success';
+    readonly value: unknown;
+} | {
+    readonly _tag: 'Failure';
+    readonly error: unknown;
+};
+export declare const FlightMediaType = "text/x-component";
+export declare const ServerFnIdHeader = "x-ersc-server-fn";

package/dist/rsc/flight.js

@@ -0,0 +1,6 @@
+const FlightMediaType = 'text/x-component';
+const ServerFnIdHeader = 'x-ersc-server-fn';
+
+export { FlightMediaType, ServerFnIdHeader };
+
+//# sourceMappingURL=flight.js.map

package/dist/rsc/flight.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rsc/flight.js","sources":["../../src/rsc/flight.ts"],"sourcesContent":["import type { ReactFormState } from 'react-dom/client';\n\nimport type { RouteTreeModel } from './route-tree';\n\nexport type FlightPayload = {\n  readonly formState: ReactFormState | null;\n  readonly routeTree: RouteTreeModel;\n  readonly serverFnResult: ServerFnResult | null;\n};\n\nexport type ServerFnResult =\n  | { readonly _tag: 'Success'; readonly value: unknown }\n  | { readonly _tag: 'Failure'; readonly error: unknown };\n\nexport const FlightMediaType = 'text/x-component';\nexport const ServerFnIdHeader = 'x-ersc-server-fn';\n"],"names":["FlightMediaType","ServerFnIdHeader"],"mappings":"AAcO,MAAMA,eAAeA,GAAG,mBAAmB;AAC3C,MAAMC,gBAAgBA,GAAG,mBAAmB"}

package/dist/rsc/render-route-tree.d.ts

@@ -0,0 +1,11 @@
+import type { PagePathParams } from '../application/page.js';
+import type { CompiledDestination } from '../application/route-graph.js';
+import type { AbsolutePath } from '../application/route-path.js';
+import type { RouteTreeModel } from './route-tree.js';
+type RenderRouteTreeOptions<Services> = {
+    readonly destination: CompiledDestination<Services>;
+    readonly pathname: AbsolutePath;
+    readonly pathParams: PagePathParams;
+};
+export declare const renderRouteTree: <Services>({ destination, pathname, pathParams, }: RenderRouteTreeOptions<Services>) => RouteTreeModel;
+export {};

package/dist/rsc/render-route-tree.js

@@ -0,0 +1,52 @@
+import { jsx } from "react/jsx-runtime";
+import { Suspense } from "react";
+import { RouteOutlet } from "../client/route-tree.js";
+
+
+
+
+
+
+
+const renderRouteTree = ({ destination, pathname, pathParams })=>{
+    const Page = destination.page.component;
+    let tree = {
+        child: null,
+        content: /*#__PURE__*/ jsx(Page, {
+            params: pathParams
+        }),
+        id: `page:${pathname}`
+    };
+    for(let index = destination.scopes.length - 1; index >= 0; index--){
+        const scope = destination.scopes[index];
+        if (scope === undefined) {
+            continue;
+        }
+        if (scope.loading !== null) {
+            const Loading = scope.loading;
+            tree = {
+                child: tree,
+                content: /*#__PURE__*/ jsx(Suspense, {
+                    fallback: /*#__PURE__*/ jsx(Loading, {}),
+                    children: /*#__PURE__*/ jsx(RouteOutlet, {})
+                }),
+                id: `loading:${scope.id}:${pathname}`
+            };
+        }
+        if (scope.layout !== null) {
+            const Layout = scope.layout;
+            tree = {
+                child: tree,
+                content: /*#__PURE__*/ jsx(Layout, {
+                    children: /*#__PURE__*/ jsx(RouteOutlet, {})
+                }),
+                id: `layout:${scope.id}`
+            };
+        }
+    }
+    return tree;
+};
+
+export { renderRouteTree };
+
+//# sourceMappingURL=render-route-tree.js.map

package/dist/rsc/render-route-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rsc/render-route-tree.js","sources":["../../src/rsc/render-route-tree.tsx"],"sourcesContent":["import { Suspense } from 'react';\n\nimport type { PagePathParams } from '../application/page';\nimport type { CompiledDestination } from '../application/route-graph';\nimport type { AbsolutePath } from '../application/route-path';\nimport { RouteOutlet } from '../client/route-tree';\nimport type { RouteTreeModel } from './route-tree';\n\ntype RenderRouteTreeOptions<Services> = {\n  readonly destination: CompiledDestination<Services>;\n  readonly pathname: AbsolutePath;\n  readonly pathParams: PagePathParams;\n};\n\nexport const renderRouteTree = <Services,>({\n  destination,\n  pathname,\n  pathParams,\n}: RenderRouteTreeOptions<Services>): RouteTreeModel => {\n  const Page = destination.page.component;\n  let tree: RouteTreeModel = {\n    child: null,\n    content: <Page params={pathParams} />,\n    id: `page:${pathname}`,\n  };\n\n  for (let index = destination.scopes.length - 1; index >= 0; index--) {\n    const scope = destination.scopes[index];\n    if (scope === undefined) {\n      continue;\n    }\n\n    if (scope.loading !== null) {\n      const Loading = scope.loading;\n      tree = {\n        child: tree,\n        content: (\n          <Suspense fallback={<Loading />}>\n            <RouteOutlet />\n          </Suspense>\n        ),\n        id: `loading:${scope.id}:${pathname}`,\n      };\n    }\n\n    if (scope.layout !== null) {\n      const Layout = scope.layout;\n      tree = {\n        child: tree,\n        content: (\n          <Layout>\n            <RouteOutlet />\n          </Layout>\n        ),\n        id: `layout:${scope.id}`,\n      };\n    }\n  }\n\n  return tree;\n};\n"],"names":["Suspense","RouteOutlet","renderRouteTree","destination","pathname","pathParams","Page","tree","index","scope","undefined","Loading","Layout"],"mappings":";;;;;;;;AAAiC;AAKkB;AAS5C,MAAME,eAAeA,GAAG,CAAY,EACzCC,WAAW,EACXC,QAAQ,EACRC,UAAU,EACuB;IACjC,MAAMC,OAAOH,YAAY,IAAI,CAAC,SAAS;IACvC,IAAII,OAAuB;QACzB,OAAO;QACP,uBAAS,IAACD;YAAK,QAAQD;;QACvB,IAAI,CAAC,KAAK,EAAED,UAAU;IACxB;IAEA,IAAK,IAAII,QAAQL,YAAY,MAAM,CAAC,MAAM,GAAG,GAAGK,SAAS,GAAGA,QAAS;QACnE,MAAMC,QAAQN,YAAY,MAAM,CAACK,MAAM;QACvC,IAAIC,UAAUC,WAAW;YACvB;QACF;QAEA,IAAID,MAAM,OAAO,KAAK,MAAM;YAC1B,MAAME,UAAUF,MAAM,OAAO;YAC7BF,OAAO;gBACL,OAAOA;gBACP,uBACE,IAACP,QAAQA;oBAAC,wBAAU,IAACW;8BACnB,kBAACV,WAAWA;;gBAGhB,IAAI,CAAC,QAAQ,EAAEQ,MAAM,EAAE,CAAC,CAAC,EAAEL,UAAU;YACvC;QACF;QAEA,IAAIK,MAAM,MAAM,KAAK,MAAM;YACzB,MAAMG,SAASH,MAAM,MAAM;YAC3BF,OAAO;gBACL,OAAOA;gBACP,uBACE,IAACK;8BACC,kBAACX,WAAWA;;gBAGhB,IAAI,CAAC,OAAO,EAAEQ,MAAM,EAAE,EAAE;YAC1B;QACF;IACF;IAEA,OAAOF;AACT,EAAE"}

package/dist/rsc/route-tree.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from 'react';
+export type RouteTreeModel = {
+    readonly child: RouteTreeModel | null;
+    readonly content: ReactNode;
+    readonly id: string;
+};

package/dist/rsc/route-tree.js

@@ -0,0 +1,5 @@
+
+
+export {};
+
+//# sourceMappingURL=route-tree.js.map

package/dist/rsc/route-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rsc/route-tree.js","sources":["../../src/rsc/route-tree.ts"],"sourcesContent":["import type { ReactNode } from 'react';\n\nexport type RouteTreeModel = {\n  readonly child: RouteTreeModel | null;\n  readonly content: ReactNode;\n  readonly id: string;\n};\n"],"names":[],"mappings":"AAME"}

package/dist/server/application.d.ts

@@ -0,0 +1,17 @@
+import { Layer } from 'effect';
+import type { PlatformError } from 'effect/PlatformError';
+import { HttpRouter, HttpStaticServer } from 'effect/unstable/http';
+import { type ApplicationDefinition } from '../application/definition.js';
+import { HtmlRenderError } from './html-renderer.js';
+import { ServerConfig } from './server-config.js';
+import { type ServerFnRequestFailure } from './server-fn-request.js';
+type HttpApplicationRequirements = ServerConfig | Layer.Services<ReturnType<typeof HttpStaticServer.layer>> | HttpRouter.Request.From<'Error', HtmlRenderError | ServerFnRequestFailure>;
+export type HttpApplicationLayer<ApplicationError> = Layer.Layer<never, ApplicationError | PlatformError, HttpApplicationRequirements>;
+export type ServerApplicationLayer<ApplicationError> = Layer.Layer<never, ApplicationError | PlatformError, ServerConfig>;
+declare const httpLayer: <Services, ApplicationError>(application: ApplicationDefinition<Services, ApplicationError>) => HttpApplicationLayer<ApplicationError>;
+declare const serverLayer: <Services, ApplicationError>(application: ApplicationDefinition<Services, ApplicationError>) => ServerApplicationLayer<ApplicationError>;
+export declare const ServerApplication: {
+    httpLayer: typeof httpLayer;
+    serverLayer: typeof serverLayer;
+};
+export {};

package/dist/server/application.js

@@ -0,0 +1,178 @@
+import { Effect, Layer, Option, Stream } from "effect";
+import { HttpEffect, HttpRouter, HttpServerRequest, HttpServerResponse, HttpStaticServer } from "effect/unstable/http";
+import { getApplicationState } from "../application/definition.js";
+import { getERSCIdentity } from "../application/ersc-identity.js";
+import { applyMiddleware, getScopedHttpMiddleware } from "../application/middleware.js";
+import { FrameworkAssetNamespace, isAbsolutePath } from "../application/route-path.js";
+import { FlightMediaType } from "../rsc/flight.js";
+import { renderRouteTree } from "../rsc/render-route-tree.js";
+import { FlightHtmlInjector } from "./flight-html-stream.js";
+import { FlightRenderer } from "./flight-renderer.js";
+import { HtmlRenderer } from "./html-renderer.js";
+import { ApplicationIdleTimeoutSeconds, ApplicationMaxRequestBodySizeBytes, ServerConfig } from "./server-config.js";
+import { prepareServerFnRequest } from "./server-fn-request.js";
+
+import * as __rspack_external__effect_platform_bun_BunHttpServer_0e4f7bbb from "@effect/platform-bun/BunHttpServer";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const RenderersLayer = Layer.mergeAll(FlightRenderer.layer, HtmlRenderer.layer).pipe(Layer.provide(FlightHtmlInjector.layer));
+const StaticAssetsLayer = Layer.unwrap(Effect.map(ServerConfig, ({ clientAssetsCacheControl, clientAssetsRoot })=>HttpStaticServer.layer({
+        cacheControl: clientAssetsCacheControl,
+        prefix: FrameworkAssetNamespace,
+        root: clientAssetsRoot
+    }).pipe(Layer.provide(HttpRouter.disableLogger))));
+const PublicAssetsLayer = Layer.unwrap(Effect.map(ServerConfig, ({ publicAssetsRoot })=>HttpStaticServer.layer({
+        cacheControl: 'public, max-age=0',
+        root: publicAssetsRoot
+    })));
+// Bun derives `development` from NODE_ENV, which `ersc start` does not set, and its error page
+// carries the failure message and source stack.
+const BunServerLayer = Layer.unwrap(Effect.map(ServerConfig, ({ hostname, port })=>__rspack_external__effect_platform_bun_BunHttpServer_0e4f7bbb.layer({
+        development: false,
+        hostname,
+        idleTimeout: ApplicationIdleTimeoutSeconds,
+        maxRequestBodySize: ApplicationMaxRequestBodySizeBytes,
+        port
+    })));
+const EmptyPathParams = Object.freeze({});
+const DynamicResponseHeaders = {
+    'cache-control': 'private, no-store'
+};
+const appendAcceptVary = (vary)=>{
+    if (vary === undefined || vary.trim() === '') {
+        return 'Accept';
+    }
+    const fields = vary.split(',').map((field)=>field.trim().toLowerCase());
+    return fields.includes('*') || fields.includes('accept') ? vary : `${vary}, Accept`;
+};
+const acceptVaryPreResponseHandler = (_request, response)=>Effect.succeed(HttpServerResponse.setHeader(response, 'vary', appendAcceptVary(response.headers['vary'])));
+const fromWebStream = (stream, options)=>Stream.fromReadableStream({
+        evaluate: ()=>stream,
+        onError: (cause)=>cause,
+        releaseLockOnEnd: options?.releaseLockOnEnd
+    });
+const combinePageMiddleware = (middleware, last)=>middleware.slice(0, -1).reduceRight((combined, current)=>combined.combine(getScopedHttpMiddleware(current)), getScopedHttpMiddleware(last));
+const httpLayer = (application)=>{
+    const applicationState = getApplicationState(application);
+    const identity = getERSCIdentity(application);
+    const render = Effect.fnUntraced(function*({ destination, formState, middleware, request, serverFnResult, status, temporaryReferences }) {
+        const requestUrl = HttpServerRequest.toURL(request);
+        if (Option.isNone(requestUrl) || !isAbsolutePath(requestUrl.value.pathname)) {
+            return yield* Effect.die(new TypeError(`Expected request URL "${request.originalUrl}" to contain an absolute path.`));
+        }
+        const pathParams = yield* destination.page.paramsSchema === null ? Effect.succeed(EmptyPathParams) : HttpRouter.params;
+        const routeTree = renderRouteTree({
+            destination,
+            pathParams,
+            pathname: requestUrl.value.pathname
+        });
+        const flightRenderer = yield* FlightRenderer;
+        const flight = yield* flightRenderer.render({
+            formState,
+            middleware,
+            renderRuntime: identity.renderRuntime,
+            routeTree,
+            serverFnResult,
+            temporaryReferences
+        });
+        if (request.headers['accept'] === FlightMediaType) {
+            return HttpServerResponse.stream(fromWebStream(flight.stream, {
+                releaseLockOnEnd: true
+            }).pipe(Stream.ensuring(flight.release)), {
+                contentType: `${FlightMediaType};charset=utf-8`,
+                headers: {
+                    ...DynamicResponseHeaders,
+                    'content-location': requestUrl.value.href
+                },
+                status
+            });
+        }
+        const htmlRenderer = yield* HtmlRenderer;
+        const htmlStream = yield* htmlRenderer.render({
+            flight,
+            formState
+        }).pipe(Effect.onError(()=>flight.release));
+        return HttpServerResponse.stream(fromWebStream(htmlStream).pipe(Stream.ensuring(flight.release)), {
+            contentType: 'text/html;charset=utf-8',
+            headers: DynamicResponseHeaders,
+            status
+        });
+    });
+    const executeServerFnAndRefresh = (prepared, destination, request)=>{
+        const refreshMiddleware = destination.middleware.filter((middleware)=>!prepared.middleware.includes(middleware));
+        const renderMiddleware = refreshMiddleware.length === 0 ? prepared.middleware : Object.freeze([
+            ...prepared.middleware,
+            ...refreshMiddleware
+        ]);
+        const response = prepared.execute.pipe(Effect.flatMap((outcome)=>{
+            const refresh = render({
+                ...outcome,
+                destination,
+                middleware: renderMiddleware,
+                request
+            });
+            return applyMiddleware(refreshMiddleware, refresh);
+        }));
+        return applyMiddleware(prepared.middleware, response);
+    };
+    const RequestLayer = Layer.mergeAll(RenderersLayer, applicationState.layer);
+    const ApplicationRoutesLayer = Layer.unwrap(Effect.map(Effect.context(), (requestContext)=>{
+        const RequestContextMiddleware = HttpRouter.middleware()((httpEffect)=>httpEffect.pipe(Effect.provideContext(requestContext)));
+        const makeRouteLayer = (destination)=>{
+            const GetLayer = HttpRouter.add('GET', destination.pattern, (request)=>render({
+                    destination,
+                    formState: null,
+                    middleware: destination.middleware,
+                    request,
+                    serverFnResult: null,
+                    status: 200
+                }).pipe(HttpEffect.withPreResponseHandler(acceptVaryPreResponseHandler)));
+            const lastPageMiddleware = destination.middleware.at(-1);
+            const PageMiddleware = lastPageMiddleware === undefined ? RequestContextMiddleware : combinePageMiddleware(destination.middleware, lastPageMiddleware).combine(RequestContextMiddleware);
+            const PageLayer = GetLayer.pipe(Layer.provide(PageMiddleware.layer));
+            const ServerFnLayer = HttpRouter.add('POST', destination.pattern, (request)=>prepareServerFnRequest(request, identity).pipe(Effect.flatMap((prepared)=>executeServerFnAndRefresh(prepared, destination, request)), Effect.catchTag('ServerFnRequestError', (error)=>Effect.succeed(HttpServerResponse.text(error.message, {
+                        headers: DynamicResponseHeaders,
+                        status: error.status
+                    }))), HttpEffect.withPreResponseHandler(acceptVaryPreResponseHandler))).pipe(Layer.provide(RequestContextMiddleware.layer));
+            return Layer.mergeAll(PageLayer, ServerFnLayer);
+        };
+        const [firstDestination, ...remainingDestinations] = applicationState.routes;
+        return Layer.mergeAll(makeRouteLayer(firstDestination), ...remainingDestinations.map(makeRouteLayer));
+    })).pipe(Layer.provide(RequestLayer));
+    return Layer.mergeAll(StaticAssetsLayer, PublicAssetsLayer).pipe(Layer.provideMerge(ApplicationRoutesLayer));
+};
+const serverLayer = (application)=>HttpRouter.serve(httpLayer(application)).pipe(Layer.provide(BunServerLayer));
+const ServerApplication = {
+    httpLayer: httpLayer,
+    serverLayer: serverLayer
+};
+
+export { ServerApplication };
+
+//# sourceMappingURL=application.js.map

package/dist/server/application.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server/application.js","sources":["../../src/server/application.ts"],"sourcesContent":["import * as BunHttpServer from '@effect/platform-bun/BunHttpServer';\nimport { Effect, Layer, Option, Stream, type Types } from 'effect';\nimport type { PlatformError } from 'effect/PlatformError';\nimport {\n  HttpEffect,\n  HttpRouter,\n  HttpServerRequest,\n  HttpServerResponse,\n  HttpStaticServer,\n} from 'effect/unstable/http';\n\nimport { type ApplicationDefinition, getApplicationState } from '../application/definition';\nimport { getERSCIdentity } from '../application/ersc-identity';\nimport {\n  applyMiddleware,\n  type AnyMiddleware,\n  getScopedHttpMiddleware,\n} from '../application/middleware';\nimport type { PagePathParams } from '../application/page';\nimport type { CompiledDestination } from '../application/route-graph';\nimport { FrameworkAssetNamespace, isAbsolutePath } from '../application/route-path';\nimport { FlightMediaType } from '../rsc/flight';\nimport { renderRouteTree } from '../rsc/render-route-tree';\nimport { FlightHtmlInjector } from './flight-html-stream';\nimport { FlightRenderer } from './flight-renderer';\nimport { HtmlRenderError, HtmlRenderer } from './html-renderer';\nimport type { RequestOutcome } from './request-outcome';\nimport {\n  ApplicationIdleTimeoutSeconds,\n  ApplicationMaxRequestBodySizeBytes,\n  ServerConfig,\n} from './server-config';\nimport {\n  prepareServerFnRequest,\n  type PreparedServerFnRequest,\n  type ServerFnRequestFailure,\n} from './server-fn-request';\n\nconst RenderersLayer = Layer.mergeAll(FlightRenderer.layer, HtmlRenderer.layer).pipe(\n  Layer.provide(FlightHtmlInjector.layer),\n);\n\nconst StaticAssetsLayer = Layer.unwrap(\n  Effect.map(ServerConfig, ({ clientAssetsCacheControl, clientAssetsRoot }) =>\n    HttpStaticServer.layer({\n      cacheControl: clientAssetsCacheControl,\n      prefix: FrameworkAssetNamespace,\n      root: clientAssetsRoot,\n    }).pipe(Layer.provide(HttpRouter.disableLogger)),\n  ),\n);\n\nconst PublicAssetsLayer = Layer.unwrap(\n  Effect.map(ServerConfig, ({ publicAssetsRoot }) =>\n    HttpStaticServer.layer({\n      cacheControl: 'public, max-age=0',\n      root: publicAssetsRoot,\n    }),\n  ),\n);\n\n// Bun derives `development` from NODE_ENV, which `ersc start` does not set, and its error page\n// carries the failure message and source stack.\nconst BunServerLayer = Layer.unwrap(\n  Effect.map(ServerConfig, ({ hostname, port }) =>\n    BunHttpServer.layer({\n      development: false,\n      hostname,\n      idleTimeout: ApplicationIdleTimeoutSeconds,\n      maxRequestBodySize: ApplicationMaxRequestBodySizeBytes,\n      port,\n    }),\n  ),\n);\n\nconst EmptyPathParams: PagePathParams = Object.freeze({});\nconst DynamicResponseHeaders = {\n  'cache-control': 'private, no-store',\n} as const;\n\nconst appendAcceptVary = (vary: string | undefined) => {\n  if (vary === undefined || vary.trim() === '') {\n    return 'Accept';\n  }\n\n  const fields = vary.split(',').map((field) => field.trim().toLowerCase());\n  return fields.includes('*') || fields.includes('accept') ? vary : `${vary}, Accept`;\n};\n\nconst acceptVaryPreResponseHandler: HttpEffect.PreResponseHandler = (_request, response) =>\n  Effect.succeed(\n    HttpServerResponse.setHeader(response, 'vary', appendAcceptVary(response.headers['vary'])),\n  );\n\ntype RenderOptions<Services> = RequestOutcome & {\n  readonly destination: CompiledDestination<Services>;\n  readonly middleware: ReadonlyArray<AnyMiddleware<Services>>;\n  readonly request: HttpServerRequest.HttpServerRequest;\n};\n\nconst fromWebStream = (\n  stream: ReadableStream<Uint8Array>,\n  options?: { readonly releaseLockOnEnd?: boolean },\n) =>\n  Stream.fromReadableStream({\n    evaluate: () => stream,\n    onError: (cause) => cause,\n    releaseLockOnEnd: options?.releaseLockOnEnd,\n  });\n\nconst combinePageMiddleware = <Services>(\n  middleware: ReadonlyArray<AnyMiddleware<Services>>,\n  last: AnyMiddleware<Services>,\n) =>\n  middleware\n    .slice(0, -1)\n    .reduceRight(\n      (combined, current) => combined.combine(getScopedHttpMiddleware(current)),\n      getScopedHttpMiddleware(last),\n    );\n\ntype HttpApplicationRequirements =\n  | ServerConfig\n  | Layer.Services<ReturnType<typeof HttpStaticServer.layer>>\n  | HttpRouter.Request.From<'Error', HtmlRenderError | ServerFnRequestFailure>;\n\nexport type HttpApplicationLayer<ApplicationError> = Layer.Layer<\n  never,\n  ApplicationError | PlatformError,\n  HttpApplicationRequirements\n>;\n\nexport type ServerApplicationLayer<ApplicationError> = Layer.Layer<\n  never,\n  ApplicationError | PlatformError,\n  ServerConfig\n>;\n\nconst httpLayer = <Services, ApplicationError>(\n  application: ApplicationDefinition<Services, ApplicationError>,\n): HttpApplicationLayer<ApplicationError> => {\n  const applicationState = getApplicationState(application);\n  const identity = getERSCIdentity(application);\n  const render = Effect.fnUntraced(function* ({\n    destination,\n    formState,\n    middleware,\n    request,\n    serverFnResult,\n    status,\n    temporaryReferences,\n  }: RenderOptions<Services>) {\n    const requestUrl = HttpServerRequest.toURL(request);\n    if (Option.isNone(requestUrl) || !isAbsolutePath(requestUrl.value.pathname)) {\n      return yield* Effect.die(\n        new TypeError(`Expected request URL \"${request.originalUrl}\" to contain an absolute path.`),\n      );\n    }\n\n    const pathParams = yield* destination.page.paramsSchema === null\n      ? Effect.succeed(EmptyPathParams)\n      : HttpRouter.params;\n    const routeTree = renderRouteTree({\n      destination,\n      pathParams,\n      pathname: requestUrl.value.pathname,\n    });\n    const flightRenderer = yield* FlightRenderer;\n    const flight = yield* flightRenderer.render({\n      formState,\n      middleware,\n      renderRuntime: identity.renderRuntime,\n      routeTree,\n      serverFnResult,\n      temporaryReferences,\n    });\n\n    if (request.headers['accept'] === FlightMediaType) {\n      return HttpServerResponse.stream(\n        fromWebStream(flight.stream, { releaseLockOnEnd: true }).pipe(\n          Stream.ensuring(flight.release),\n        ),\n        {\n          contentType: `${FlightMediaType};charset=utf-8`,\n          headers: {\n            ...DynamicResponseHeaders,\n            'content-location': requestUrl.value.href,\n          },\n          status,\n        },\n      );\n    }\n\n    const htmlRenderer = yield* HtmlRenderer;\n    const htmlStream = yield* htmlRenderer\n      .render({ flight, formState })\n      .pipe(Effect.onError(() => flight.release));\n\n    return HttpServerResponse.stream(\n      fromWebStream(htmlStream).pipe(Stream.ensuring(flight.release)),\n      {\n        contentType: 'text/html;charset=utf-8',\n        headers: DynamicResponseHeaders,\n        status,\n      },\n    );\n  });\n\n  const executeServerFnAndRefresh = (\n    prepared: PreparedServerFnRequest<Services>,\n    destination: CompiledDestination<Services>,\n    request: HttpServerRequest.HttpServerRequest,\n  ) => {\n    const refreshMiddleware = destination.middleware.filter(\n      (middleware) => !prepared.middleware.includes(middleware),\n    );\n    const renderMiddleware =\n      refreshMiddleware.length === 0\n        ? prepared.middleware\n        : Object.freeze([...prepared.middleware, ...refreshMiddleware]);\n    const response = prepared.execute.pipe(\n      Effect.flatMap((outcome) => {\n        const refresh = render({\n          ...outcome,\n          destination,\n          middleware: renderMiddleware,\n          request,\n        });\n        return applyMiddleware(refreshMiddleware, refresh);\n      }),\n    );\n\n    return applyMiddleware(prepared.middleware, response);\n  };\n\n  const RequestLayer = Layer.mergeAll(RenderersLayer, applicationState.layer);\n  const ApplicationRoutesLayer = Layer.unwrap(\n    Effect.map(Effect.context<Services | FlightRenderer | HtmlRenderer>(), (requestContext) => {\n      const RequestContextMiddleware = HttpRouter.middleware<{\n        provides: Services | FlightRenderer | HtmlRenderer;\n      }>()((httpEffect): Effect.Effect<HttpServerResponse.HttpServerResponse, Types.unhandled> =>\n        httpEffect.pipe(Effect.provideContext(requestContext)),\n      );\n      const makeRouteLayer = (destination: CompiledDestination<Services>) => {\n        const GetLayer = HttpRouter.add('GET', destination.pattern, (request) =>\n          render({\n            destination,\n            formState: null,\n            middleware: destination.middleware,\n            request,\n            serverFnResult: null,\n            status: 200,\n          }).pipe(HttpEffect.withPreResponseHandler(acceptVaryPreResponseHandler)),\n        );\n        const lastPageMiddleware = destination.middleware.at(-1);\n        const PageMiddleware =\n          lastPageMiddleware === undefined\n            ? RequestContextMiddleware\n            : combinePageMiddleware(destination.middleware, lastPageMiddleware).combine(\n                RequestContextMiddleware,\n              );\n        const PageLayer = GetLayer.pipe(Layer.provide(PageMiddleware.layer));\n        const ServerFnLayer = HttpRouter.add('POST', destination.pattern, (request) =>\n          prepareServerFnRequest(request, identity).pipe(\n            Effect.flatMap((prepared) => executeServerFnAndRefresh(prepared, destination, request)),\n            Effect.catchTag('ServerFnRequestError', (error) =>\n              Effect.succeed(\n                HttpServerResponse.text(error.message, {\n                  headers: DynamicResponseHeaders,\n                  status: error.status,\n                }),\n              ),\n            ),\n            HttpEffect.withPreResponseHandler(acceptVaryPreResponseHandler),\n          ),\n        ).pipe(Layer.provide(RequestContextMiddleware.layer));\n\n        return Layer.mergeAll(PageLayer, ServerFnLayer);\n      };\n      const [firstDestination, ...remainingDestinations] = applicationState.routes;\n      return Layer.mergeAll(\n        makeRouteLayer(firstDestination),\n        ...remainingDestinations.map(makeRouteLayer),\n      );\n    }),\n  ).pipe(Layer.provide(RequestLayer));\n\n  return Layer.mergeAll(StaticAssetsLayer, PublicAssetsLayer).pipe(\n    Layer.provideMerge(ApplicationRoutesLayer),\n  );\n};\n\nconst serverLayer = <Services, ApplicationError>(\n  application: ApplicationDefinition<Services, ApplicationError>,\n): ServerApplicationLayer<ApplicationError> =>\n  HttpRouter.serve(httpLayer(application)).pipe(Layer.provide(BunServerLayer));\n\nexport const ServerApplication = { httpLayer, serverLayer };\n"],"names":["BunHttpServer","Effect","Layer","Option","Stream","HttpEffect","HttpRouter","HttpServerRequest","HttpServerResponse","HttpStaticServer","getApplicationState","getERSCIdentity","applyMiddleware","getScopedHttpMiddleware","FrameworkAssetNamespace","isAbsolutePath","FlightMediaType","renderRouteTree","FlightHtmlInjector","FlightRenderer","HtmlRenderer","ApplicationIdleTimeoutSeconds","ApplicationMaxRequestBodySizeBytes","ServerConfig","prepareServerFnRequest","RenderersLayer","StaticAssetsLayer","clientAssetsCacheControl","clientAssetsRoot","PublicAssetsLayer","publicAssetsRoot","BunServerLayer","hostname","port","EmptyPathParams","Object","DynamicResponseHeaders","appendAcceptVary","vary","undefined","fields","field","acceptVaryPreResponseHandler","_request","response","fromWebStream","stream","options","cause","combinePageMiddleware","middleware","last","combined","current","httpLayer","application","applicationState","identity","render","destination","formState","request","serverFnResult","status","temporaryReferences","requestUrl","TypeError","pathParams","routeTree","flightRenderer","flight","htmlRenderer","htmlStream","executeServerFnAndRefresh","prepared","refreshMiddleware","renderMiddleware","outcome","refresh","RequestLayer","ApplicationRoutesLayer","requestContext","RequestContextMiddleware","httpEffect","makeRouteLayer","GetLayer","lastPageMiddleware","PageMiddleware","PageLayer","ServerFnLayer","error","firstDestination","remainingDestinations","serverLayer","ServerApplication"],"mappings":"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"}

package/dist/server/flight-html-stream.d.ts

@@ -0,0 +1,19 @@
+import { Context, Effect, Layer } from 'effect';
+export type FlightHtmlStreamOptions = {
+    readonly nonce?: string;
+};
+export declare const injectFlightPayload: (flightStream: ReadableStream<Uint8Array>, options?: FlightHtmlStreamOptions) => TransformStream<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
+declare const FlightHtmlInjector_base: Context.ServiceClass<FlightHtmlInjector, "ersc/server/flight-html-stream/FlightHtmlInjector", {
+    inject: typeof injectFlightPayload;
+}> & {
+    readonly make: Effect.Effect<{
+        inject: typeof injectFlightPayload;
+    }, never, never>;
+};
+export declare class FlightHtmlInjector extends FlightHtmlInjector_base {
+    static readonly layer: Layer.Layer<FlightHtmlInjector, never, never>;
+    static readonly layerTest: (implementation: {
+        inject: typeof injectFlightPayload;
+    }) => Layer.Layer<FlightHtmlInjector, never, never>;
+}
+export {};

package/dist/server/flight-html-stream.js

@@ -0,0 +1,193 @@
+import { Context, Effect, Layer } from "effect";
+
+
+// Adapted from rsc-html-stream by Devon Govett.
+// Copyright (c) 2024-present Devon Govett. Licensed under the MIT License; see vendor/rsc-html-stream/LICENSE.
+
+const Encoder = new TextEncoder();
+const HtmlTrailer = Encoder.encode('</body></html>');
+const EmptyBytes = new Uint8Array();
+const trailerPrefixLength = (bytes)=>{
+    const maximumLength = Math.min(bytes.byteLength, HtmlTrailer.byteLength);
+    for(let length = maximumLength; length > 0; length -= 1){
+        const offset = bytes.byteLength - length;
+        let matches = true;
+        for(let index = 0; index < length; index += 1){
+            if (bytes[offset + index] !== HtmlTrailer[index]) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches) {
+            return length;
+        }
+    }
+    return 0;
+};
+const escapeInlineScript = (script)=>script.replace(/<!--|<\/script/gi, (match)=>match === '<!--' ? '<\\!--' : `</\\${match.slice(2)}`);
+const writeFlightValue = (value, controller, nonce)=>{
+    const script = escapeInlineScript(`(self.__FLIGHT_DATA||=[]).push(${value})`);
+    const nonceAttribute = nonce === undefined ? '' : ` nonce="${nonce}"`;
+    controller.enqueue(Encoder.encode(`<script${nonceAttribute}>${script}</script>`));
+};
+const writeFlightChunk = (decoder, chunk, controller, nonce)=>{
+    try {
+        const text = decoder.decode(chunk);
+        if (text.length > 0) {
+            writeFlightValue(JSON.stringify(text), controller, nonce);
+        }
+    } catch  {
+        const base64 = JSON.stringify(chunk.toBase64());
+        writeFlightValue(`Uint8Array.from(atob(${base64}),character=>character.codePointAt(0))`, controller, nonce);
+    }
+};
+const writeFlightStream = (stream, controller, nonce)=>{
+    const decoder = new TextDecoder('utf-8', {
+        fatal: true,
+        ignoreBOM: true
+    });
+    const reader = stream.getReader();
+    let released = false;
+    const release = ()=>{
+        if (!released) {
+            released = true;
+            reader.releaseLock();
+        }
+    };
+    const cancel = (cause)=>{
+        let cancellation;
+        try {
+            cancellation = reader.cancel(cause);
+        } catch  {
+            release();
+            return Promise.reject(cause);
+        }
+        return cancellation.then(()=>{
+            release();
+            return Promise.reject(cause);
+        }, ()=>{
+            release();
+            return Promise.reject(cause);
+        });
+    };
+    const handle = (result)=>{
+        if (result.done) {
+            release();
+            return Promise.resolve();
+        }
+        try {
+            for (const chunk of result.value){
+                writeFlightChunk(decoder, chunk, controller, nonce);
+            }
+        } catch (cause) {
+            return cancel(cause);
+        }
+        return read();
+    };
+    const read = ()=>{
+        let result;
+        try {
+            result = reader.readMany();
+        } catch (cause) {
+            return cancel(cause);
+        }
+        return 'then' in result ? result.then(handle, cancel) : handle(result);
+    };
+    return read();
+};
+const makeHtmlWriter = ()=>{
+    let tail = EmptyBytes;
+    return {
+        finish (controller) {
+            if (tail.byteLength !== HtmlTrailer.byteLength && tail.byteLength > 0) {
+                controller.enqueue(tail);
+            }
+            controller.enqueue(HtmlTrailer);
+        },
+        write (chunks, controller) {
+            if (chunks.length === 0) {
+                return;
+            }
+            const byteLength = chunks.reduce((total, chunk)=>total + chunk.byteLength, tail.byteLength);
+            const combined = new Uint8Array(byteLength);
+            combined.set(tail);
+            let offset = tail.byteLength;
+            for (const chunk of chunks){
+                combined.set(chunk, offset);
+                offset += chunk.byteLength;
+            }
+            const bodyLength = combined.byteLength - trailerPrefixLength(combined);
+            if (bodyLength > 0) {
+                controller.enqueue(combined.subarray(0, bodyLength));
+            }
+            tail = combined.slice(bodyLength);
+        }
+    };
+};
+const injectFlightPayload = (flightStream, options)=>{
+    const htmlWriter = makeHtmlWriter();
+    const bufferedHtml = [];
+    const flightCompletion = Promise.withResolvers();
+    let flightStarted = false;
+    let flushScheduled = false;
+    const fail = (controller, cause)=>{
+        try {
+            controller.error(cause);
+        } finally{
+            flightCompletion.resolve();
+        }
+    };
+    const flushHtml = (controller)=>{
+        htmlWriter.write(bufferedHtml, controller);
+        bufferedHtml.length = 0;
+    };
+    const startFlight = (controller)=>{
+        if (flightStarted) {
+            return;
+        }
+        flightStarted = true;
+        writeFlightStream(flightStream, controller, options?.nonce).then(flightCompletion.resolve, (cause)=>fail(controller, cause));
+    };
+    const flushAndStartFlight = (controller)=>{
+        try {
+            flushHtml(controller);
+            startFlight(controller);
+        } catch (cause) {
+            fail(controller, cause);
+        }
+    };
+    return new TransformStream({
+        flush (controller) {
+            if (flushScheduled) {
+                flushScheduled = false;
+                flushHtml(controller);
+            }
+            startFlight(controller);
+            return flightCompletion.promise.then(()=>htmlWriter.finish(controller));
+        },
+        transform (chunk, controller) {
+            bufferedHtml.push(chunk);
+            if (!flushScheduled) {
+                flushScheduled = true;
+                void Bun.sleep(0).then(()=>{
+                    if (flushScheduled) {
+                        flushScheduled = false;
+                        flushAndStartFlight(controller);
+                    }
+                });
+            }
+        }
+    });
+};
+class FlightHtmlInjector extends Context.Service()('ersc/server/flight-html-stream/FlightHtmlInjector', {
+    make: Effect.succeed({
+        inject: injectFlightPayload
+    })
+}) {
+    static layer = Layer.effect(this, this.make);
+    static layerTest = Layer.mock(this);
+}
+
+export { FlightHtmlInjector, injectFlightPayload };
+
+//# sourceMappingURL=flight-html-stream.js.map