effective-rsc 0.1.0

package/dist/application/server-fn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"application/server-fn.js","sources":["../../src/application/server-fn.ts"],"sourcesContent":["import { Effect, Predicate, Schema } from 'effect';\n\nimport { attachERSCMember, type ERSCIdentity, type ERSCMember } from './ersc-identity';\nimport type { AnyMiddleware } from './middleware';\n\nconst ServerFnInvocationTypeId: unique symbol = Symbol.for('ersc/ServerFnInvocation');\n\nclass ServerFnOperationError extends Schema.TaggedError<ServerFnOperationError>()(\n  'ServerFnOperationError',\n  { cause: Schema.Defect() },\n) {}\n\ntype ServerFnInvocation<ApplicationServices> = {\n  readonly [ServerFnInvocationTypeId]: {\n    readonly effect: Effect.Effect<unknown, ServerFnOperationError, ApplicationServices>;\n    readonly identity: ERSCIdentity<ApplicationServices>;\n    readonly middleware: ReadonlyArray<AnyMiddleware<ApplicationServices>>;\n  };\n};\n\ntype ServerFnInvocationMatch<ApplicationServices> =\n  | { readonly _tag: 'Native' }\n  | { readonly _tag: 'IdentityMismatch' }\n  | {\n      readonly _tag: 'Match';\n      readonly effect: Effect.Effect<unknown, ServerFnOperationError, ApplicationServices>;\n      readonly middleware: ReadonlyArray<AnyMiddleware<ApplicationServices>>;\n    };\n\ninterface ServerFunction<Input, Output, ApplicationServices> extends ERSCMember<\n  ApplicationServices,\n  'ServerFn'\n> {\n  (input: Input): Promise<Output>;\n}\n\ntype ServerFnOptions<InputSchema extends Schema.Constraint, Output, Error, Services> = {\n  readonly input: InputSchema;\n  readonly handler: (input: InputSchema['Type']) => Effect.Effect<Output, Error, Services>;\n};\n\nexport type ServerFnFactory<ApplicationServices, AvailableServices> = {\n  readonly make: <\n    InputSchema extends Schema.ConstraintDecoder<unknown, AvailableServices>,\n    Output,\n    Error,\n  >(\n    options: ServerFnOptions<InputSchema, Output, Error, AvailableServices>,\n  ) => ServerFunction<InputSchema['Encoded'], Output, ApplicationServices>;\n};\n\nconst directInvocationError = () =>\n  new TypeError(\n    'An ERSC ServerFn is a framework intrinsic and cannot be invoked directly in the server graph.',\n  );\n\nconst isServerFnInvocation = <ApplicationServices>(\n  value: unknown,\n): value is ServerFnInvocation<ApplicationServices> =>\n  Predicate.hasProperty(value, ServerFnInvocationTypeId);\n\nexport const matchServerFnInvocation = <ApplicationServices>(\n  value: unknown,\n  identity: ERSCIdentity<ApplicationServices>,\n): ServerFnInvocationMatch<ApplicationServices> => {\n  if (!isServerFnInvocation<ApplicationServices>(value)) {\n    return { _tag: 'Native' };\n  }\n\n  // The framework-owned brand proves the state shape; matching the opaque identity proves the\n  // application service universe erased by the native React invocation.\n  const metadata = value[ServerFnInvocationTypeId];\n  if (metadata.identity !== identity) {\n    return { _tag: 'IdentityMismatch' };\n  }\n\n  return { _tag: 'Match', effect: metadata.effect, middleware: metadata.middleware };\n};\n\nexport const makeServerFnFactory = <ApplicationServices, AvailableServices>(\n  identity: ERSCIdentity<ApplicationServices>,\n  middleware: ReadonlyArray<AnyMiddleware<ApplicationServices>>,\n): ServerFnFactory<ApplicationServices, AvailableServices> => ({\n  make: ({ input, handler }) => {\n    const decode = Schema.decodeUnknownEffect(input);\n    const serverFunction = (untrustedInput: typeof input.Encoded) => {\n      const effect = decode(untrustedInput).pipe(\n        Effect.flatMap(handler),\n        Effect.mapError((cause) => new ServerFnOperationError({ cause })),\n      );\n      const unavailable = Promise.reject<Effect.Success<typeof effect>>(directInvocationError());\n      void unavailable.catch(() => undefined);\n\n      return Object.assign(unavailable, {\n        [ServerFnInvocationTypeId]: Object.freeze({ effect, identity, middleware }),\n      });\n    };\n\n    return attachERSCMember(serverFunction, identity, 'ServerFn');\n  },\n});\n"],"names":["Effect","Predicate","Schema","attachERSCMember","ServerFnInvocationTypeId","Symbol","ServerFnOperationError","directInvocationError","TypeError","isServerFnInvocation","value","matchServerFnInvocation","identity","metadata","makeServerFnFactory","middleware","input","handler","decode","serverFunction","untrustedInput","effect","cause","unavailable","Promise","undefined","Object"],"mappings":";;;;;AAAmD;AAEoC;AAGvF,MAAMI,wBAAwBA,GAAkBC,OAAO,GAAG,CAAC;AAE3D,MAAMC,sBAAsBA,SAASJ,kBAAkB,GACrD,0BACA;IAAE,OAAOA,aAAa;AAAG;AACxB;AAyCH,MAAMK,qBAAqBA,GAAG,IAC5B,IAAIC,UACF;AAGJ,MAAMC,oBAAoBA,GAAG,CAC3BC,QAEAT,qBAAqB,CAACS,OAAON,wBAAwBA;AAEhD,MAAMO,uBAAuBA,GAAG,CACrCD,OACAE;IAEA,IAAI,CAACH,oBAAoBA,CAAsBC,QAAQ;QACrD,OAAO;YAAE,MAAM;QAAS;IAC1B;IAEA,4FAA4F;IAC5F,sEAAsE;IACtE,MAAMG,WAAWH,KAAK,CAACN,wBAAwBA,CAAC;IAChD,IAAIS,SAAS,QAAQ,KAAKD,UAAU;QAClC,OAAO;YAAE,MAAM;QAAmB;IACpC;IAEA,OAAO;QAAE,MAAM;QAAS,QAAQC,SAAS,MAAM;QAAE,YAAYA,SAAS,UAAU;IAAC;AACnF,EAAE;AAEK,MAAMC,mBAAmBA,GAAG,CACjCF,UACAG,aAC6D;QAC7D,MAAM,CAAC,EAAEC,KAAK,EAAEC,OAAO,EAAE;YACvB,MAAMC,SAAShB,0BAA0B,CAACc;YAC1C,MAAMG,iBAAiB,CAACC;gBACtB,MAAMC,SAASH,OAAOE,gBAAgB,IAAI,CACxCpB,cAAc,CAACiB,UACfjB,eAAe,CAAC,CAACsB,QAAU,IAAIhB,sBAAsBA,CAAC;wBAAEgB;oBAAM;gBAEhE,MAAMC,cAAcC,QAAQ,MAAM,CAAgCjB,qBAAqBA;gBACvF,KAAKgB,YAAY,KAAK,CAAC,IAAME;gBAE7B,OAAOC,OAAO,MAAM,CAACH,aAAa;oBAChC,CAACnB,wBAAwBA,CAAC,EAAEsB,OAAO,MAAM,CAAC;wBAAEL;wBAAQT;wBAAUG;oBAAW;gBAC3E;YACF;YAEA,OAAOZ,gBAAgBA,CAACgB,gBAAgBP,UAAU;QACpD;IACF,GAAG"}

package/dist/build/build.d.ts

@@ -0,0 +1,26 @@
+import { Effect, Path, Schema } from 'effect';
+import { Rspack } from './rspack.js';
+export type BuildOptions = {
+    readonly root: string;
+};
+export type ResolveApplicationBuildOptions = BuildOptions & {
+    readonly buildModuleUrl?: URL;
+};
+declare const BuildEntryError_base: Schema.Class<BuildEntryError, Schema.TaggedStruct<"BuildEntryError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class BuildEntryError extends BuildEntryError_base {
+}
+export declare const resolveApplicationBuild: (args_0: ResolveApplicationBuildOptions) => Effect.Effect<{
+    readonly applicationRoot: string;
+    readonly entries: {
+        application: string;
+        client: string;
+        rsc: string;
+        ssr: string;
+    };
+}, BuildEntryError, Path.Path>;
+export declare const build: (options: BuildOptions) => Effect.Effect<void, BuildEntryError | import("./rspack.js").RspackError, Path.Path | Rspack | import("effect/Scope").Scope>;
+export declare const buildApplication: (options: BuildOptions) => Effect.Effect<void, BuildEntryError | import("./rspack.js").RspackError, Path.Path>;
+export {};

package/dist/build/build.js

@@ -0,0 +1,59 @@
+import { Effect, Path, Schema } from "effect";
+import { ApplicationEntryPath } from "./contract.js";
+import { Rspack } from "./rspack.js";
+import { makeRspackBuildConfig } from "./rspack-config.js";
+
+
+
+
+
+
+
+
+
+class BuildEntryError extends Schema.TaggedError()('BuildEntryError', {
+    message: Schema.String,
+    cause: Schema.Defect()
+}) {
+}
+const ClientEntryPath = '../client/entry.js';
+const RscEntryPath = './rsc-entry.js';
+const SsrEntryPath = '../server/html-renderer.js';
+const resolveFrameworkEntry = Effect.fnUntraced(function*(buildModuleUrl, relativePath) {
+    const path = yield* Path.Path;
+    const buildModulePath = yield* path.fromFileUrl(buildModuleUrl).pipe(Effect.mapError((cause)=>new BuildEntryError({
+            message: `Failed to convert the framework build module ${buildModuleUrl.href} to a file path.`,
+            cause
+        })));
+    return path.resolve(path.dirname(buildModulePath), relativePath);
+});
+const resolveApplicationBuild = Effect.fnUntraced(function*({ root, buildModuleUrl = new URL(import.meta.url) }) {
+    const path = yield* Path.Path;
+    const applicationRoot = path.resolve(root);
+    const applicationPath = path.resolve(applicationRoot, ApplicationEntryPath);
+    const clientEntry = yield* resolveFrameworkEntry(buildModuleUrl, ClientEntryPath);
+    const rscEntry = yield* resolveFrameworkEntry(buildModuleUrl, RscEntryPath);
+    const ssrEntry = yield* resolveFrameworkEntry(buildModuleUrl, SsrEntryPath);
+    const entries = {
+        application: applicationPath,
+        client: clientEntry,
+        rsc: rscEntry,
+        ssr: ssrEntry
+    };
+    return {
+        applicationRoot,
+        entries
+    };
+});
+const build = Effect.fn('ersc/rspack/build')(function*(options) {
+    const { applicationRoot, entries } = yield* resolveApplicationBuild(options);
+    const rspack = yield* Rspack;
+    yield* rspack.build(makeRspackBuildConfig(applicationRoot, entries));
+});
+const buildApplication = Effect.fn('ersc/build/buildApplication')(function*(options) {
+    yield* build(options).pipe(Effect.provide(Rspack.layer), Effect.scoped);
+});
+
+export { BuildEntryError, build, buildApplication, resolveApplicationBuild };
+
+//# sourceMappingURL=build.js.map

package/dist/build/build.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build/build.js","sources":["../../src/build/build.ts"],"sourcesContent":["import { Effect, Path, Schema } from 'effect';\n\nimport { ApplicationEntryPath } from './contract';\nimport { Rspack } from './rspack';\nimport { makeRspackBuildConfig } from './rspack-config';\n\nexport type BuildOptions = {\n  readonly root: string;\n};\n\nexport type ResolveApplicationBuildOptions = BuildOptions & {\n  readonly buildModuleUrl?: URL;\n};\n\nexport class BuildEntryError extends Schema.TaggedError<BuildEntryError>()('BuildEntryError', {\n  message: Schema.String,\n  cause: Schema.Defect(),\n}) {}\n\nconst ClientEntryPath = '../client/entry.js';\nconst RscEntryPath = './rsc-entry.js';\nconst SsrEntryPath = '../server/html-renderer.js';\n\nconst resolveFrameworkEntry = Effect.fnUntraced(function* (\n  buildModuleUrl: URL,\n  relativePath: string,\n) {\n  const path = yield* Path.Path;\n\n  const buildModulePath = yield* path.fromFileUrl(buildModuleUrl).pipe(\n    Effect.mapError(\n      (cause) =>\n        new BuildEntryError({\n          message: `Failed to convert the framework build module ${buildModuleUrl.href} to a file path.`,\n          cause,\n        }),\n    ),\n  );\n\n  return path.resolve(path.dirname(buildModulePath), relativePath);\n});\n\nexport const resolveApplicationBuild = Effect.fnUntraced(function* ({\n  root,\n  buildModuleUrl = new URL(import.meta.url),\n}: ResolveApplicationBuildOptions) {\n  const path = yield* Path.Path;\n  const applicationRoot = path.resolve(root);\n  const applicationPath = path.resolve(applicationRoot, ApplicationEntryPath);\n  const clientEntry = yield* resolveFrameworkEntry(buildModuleUrl, ClientEntryPath);\n  const rscEntry = yield* resolveFrameworkEntry(buildModuleUrl, RscEntryPath);\n  const ssrEntry = yield* resolveFrameworkEntry(buildModuleUrl, SsrEntryPath);\n  const entries = {\n    application: applicationPath,\n    client: clientEntry,\n    rsc: rscEntry,\n    ssr: ssrEntry,\n  };\n\n  return { applicationRoot, entries } as const;\n});\n\nexport const build = Effect.fn('ersc/rspack/build')(function* (options: BuildOptions) {\n  const { applicationRoot, entries } = yield* resolveApplicationBuild(options);\n  const rspack = yield* Rspack;\n\n  yield* rspack.build(makeRspackBuildConfig(applicationRoot, entries));\n});\n\nexport const buildApplication = Effect.fn('ersc/build/buildApplication')(function* (\n  options: BuildOptions,\n) {\n  yield* build(options).pipe(Effect.provide(Rspack.layer), Effect.scoped);\n});\n"],"names":["Effect","Path","Schema","ApplicationEntryPath","Rspack","makeRspackBuildConfig","BuildEntryError","ClientEntryPath","RscEntryPath","SsrEntryPath","resolveFrameworkEntry","buildModuleUrl","relativePath","path","buildModulePath","cause","resolveApplicationBuild","root","URL","applicationRoot","applicationPath","clientEntry","rscEntry","ssrEntry","entries","build","options","rspack","buildApplication"],"mappings":";;;;;;;;;AAA8C;AAEI;AAChB;AACsB;AAUjD,MAAMM,eAAeA,SAASJ,kBAAkB,GAAoB,mBAAmB;IAC5F,SAASA,aAAa;IACtB,OAAOA,aAAa;AACtB;AAAI;AAEJ,MAAMK,eAAeA,GAAG;AACxB,MAAMC,YAAYA,GAAG;AACrB,MAAMC,YAAYA,GAAG;AAErB,MAAMC,qBAAqBA,GAAGV,iBAAiB,CAAC,UAC9CW,cAAmB,EACnBC,YAAoB;IAEpB,MAAMC,OAAO,OAAOZ,SAAS;IAE7B,MAAMa,kBAAkB,OAAOD,KAAK,WAAW,CAACF,gBAAgB,IAAI,CAClEX,eAAe,CACb,CAACe,QACC,IAAIT,eAAeA,CAAC;YAClB,SAAS,CAAC,6CAA6C,EAAEK,eAAe,IAAI,CAAC,gBAAgB,CAAC;YAC9FI;QACF;IAIN,OAAOF,KAAK,OAAO,CAACA,KAAK,OAAO,CAACC,kBAAkBF;AACrD;AAEO,MAAMI,uBAAuBA,GAAGhB,iBAAiB,CAAC,UAAW,EAClEiB,IAAI,EACJN,iBAAiB,IAAIO,IAAI,YAAY,GAAG,CAAC,EACV;IAC/B,MAAML,OAAO,OAAOZ,SAAS;IAC7B,MAAMkB,kBAAkBN,KAAK,OAAO,CAACI;IACrC,MAAMG,kBAAkBP,KAAK,OAAO,CAACM,iBAAiBhB,oBAAoBA;IAC1E,MAAMkB,cAAc,OAAOX,qBAAqBA,CAACC,gBAAgBJ,eAAeA;IAChF,MAAMe,WAAW,OAAOZ,qBAAqBA,CAACC,gBAAgBH,YAAYA;IAC1E,MAAMe,WAAW,OAAOb,qBAAqBA,CAACC,gBAAgBF,YAAYA;IAC1E,MAAMe,UAAU;QACd,aAAaJ;QACb,QAAQC;QACR,KAAKC;QACL,KAAKC;IACP;IAEA,OAAO;QAAEJ;QAAiBK;IAAQ;AACpC,GAAG;AAEI,MAAMC,KAAKA,GAAGzB,SAAS,CAAC,qBAAqB,UAAW0B,OAAqB;IAClF,MAAM,EAAEP,eAAe,EAAEK,OAAO,EAAE,GAAG,OAAOR,uBAAuBA,CAACU;IACpE,MAAMC,SAAS,OAAOvB,MAAMA;IAE5B,OAAOuB,OAAO,KAAK,CAACtB,qBAAqBA,CAACc,iBAAiBK;AAC7D,GAAG;AAEI,MAAMI,gBAAgBA,GAAG5B,SAAS,CAAC,+BAA+B,UACvE0B,OAAqB;IAErB,OAAOD,KAAKA,CAACC,SAAS,IAAI,CAAC1B,cAAc,CAACI,YAAY,GAAGJ,aAAa;AACxE,GAAG"}

package/dist/build/compiled-server.d.ts

@@ -0,0 +1,53 @@
+import { Effect, FileSystem, Layer, Path, Schema, Types } from 'effect';
+import { HttpRouter } from 'effect/unstable/http';
+import { ServerConfig } from '../server/server-config.js';
+declare const CompiledServerError_base: Schema.Class<CompiledServerError, Schema.TaggedStruct<"CompiledServerError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class CompiledServerError extends CompiledServerError_base {
+}
+declare const ServerBundle: Schema.Struct<{
+    readonly default: Schema.Struct<{
+        readonly entryCssFiles: Schema.$Array<Schema.String>;
+        readonly entryJsFiles: Schema.NonEmptyArray<Schema.String>;
+    }>;
+    readonly HttpLayer: Schema.declare<Layer.Layer<never, Types.unhandled, FileSystem.FileSystem | HttpRouter.HttpRouter | Path.Path | ServerConfig>, Layer.Layer<never, Types.unhandled, FileSystem.FileSystem | HttpRouter.HttpRouter | Path.Path | ServerConfig>>;
+    readonly ServerLayer: Schema.declare<Layer.Layer<never, Types.unhandled, ServerConfig>, Layer.Layer<never, Types.unhandled, ServerConfig>>;
+}>;
+export type ServerBundle = typeof ServerBundle.Type;
+export declare const decodeServerBundle: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
+    readonly default: {
+        readonly entryCssFiles: readonly string[];
+        readonly entryJsFiles: readonly [string, ...string[]];
+    };
+    readonly HttpLayer: Layer.Layer<never, Types.unhandled, FileSystem.FileSystem | HttpRouter.HttpRouter | Path.Path | ServerConfig>;
+    readonly ServerLayer: Layer.Layer<never, Types.unhandled, ServerConfig>;
+}, Schema.SchemaError, never>;
+type RunnableLayerOptions = {
+    readonly bundle: ServerBundle;
+    readonly clientAssetsCacheControl: string;
+    readonly clientOutputDir: string;
+    readonly hostname: string;
+    readonly port: number;
+    readonly root: string;
+};
+export declare const makeRunnableServerLayer: (options: RunnableLayerOptions) => Effect.Effect<Layer.Layer<never, Types.unhandled, never>, never, Path.Path>;
+export declare const makeRunnableHttpLayer: (options: RunnableLayerOptions) => Effect.Effect<Layer.Layer<never, Types.unhandled, FileSystem.FileSystem | HttpRouter.HttpRouter | Path.Path>, never, Path.Path>;
+export declare const loadServerBundle: (serverBundlePath: string) => Effect.Effect<{
+    readonly default: {
+        readonly entryCssFiles: readonly string[];
+        readonly entryJsFiles: readonly [string, ...string[]];
+    };
+    readonly HttpLayer: Layer.Layer<never, Types.unhandled, FileSystem.FileSystem | HttpRouter.HttpRouter | Path.Path | ServerConfig>;
+    readonly ServerLayer: Layer.Layer<never, Types.unhandled, ServerConfig>;
+}, CompiledServerError, Path.Path>;
+export declare const loadCompiledServer: (root: string) => Effect.Effect<{
+    readonly default: {
+        readonly entryCssFiles: readonly string[];
+        readonly entryJsFiles: readonly [string, ...string[]];
+    };
+    readonly HttpLayer: Layer.Layer<never, Types.unhandled, FileSystem.FileSystem | HttpRouter.HttpRouter | Path.Path | ServerConfig>;
+    readonly ServerLayer: Layer.Layer<never, Types.unhandled, ServerConfig>;
+}, CompiledServerError, Path.Path>;
+export {};

package/dist/build/compiled-server.js

@@ -0,0 +1,77 @@
+import { Effect, Layer, Path, Schema } from "effect";
+import { ServerConfig } from "../server/server-config.js";
+import { BuildServerBundlePath, CompiledServerExportNames, PublicAssetsDir } from "./contract.js";
+
+
+
+
+
+
+
+class CompiledServerError extends Schema.TaggedError()('CompiledServerError', {
+    message: Schema.String,
+    cause: Schema.Defect()
+}) {
+}
+const CompiledApplication = Schema.Struct({
+    entryCssFiles: Schema.Array(Schema.String),
+    entryJsFiles: Schema.NonEmptyArray(Schema.String)
+});
+const CompiledServerLayer = Schema.declare((input)=>Layer.isLayer(input), {
+    expected: 'the compiled effective-rsc ServerLayer'
+});
+const CompiledHttpLayer = Schema.declare((input)=>Layer.isLayer(input), {
+    expected: 'the compiled effective-rsc HttpLayer'
+});
+const ServerBundle = Schema.Struct({
+    [CompiledServerExportNames.application]: CompiledApplication,
+    [CompiledServerExportNames.httpLayer]: CompiledHttpLayer,
+    [CompiledServerExportNames.serverLayer]: CompiledServerLayer
+});
+const decodeServerBundle = Schema.decodeUnknownEffect(ServerBundle);
+const makeServerConfigLayer = Effect.fnUntraced(function*({ bundle, clientAssetsCacheControl, clientOutputDir, hostname, port, root }) {
+    const path = yield* Path.Path;
+    return Layer.succeed(ServerConfig, ServerConfig.of({
+        clientAssetsCacheControl,
+        clientAssetsRoot: path.resolve(root, clientOutputDir),
+        clientBootstrapScripts: bundle[CompiledServerExportNames.application].entryJsFiles,
+        clientStylesheets: bundle[CompiledServerExportNames.application].entryCssFiles,
+        hostname,
+        port,
+        publicAssetsRoot: path.resolve(root, PublicAssetsDir)
+    }));
+});
+const makeRunnableServerLayer = Effect.fnUntraced(function*(options) {
+    const ServerConfigLayer = yield* makeServerConfigLayer(options);
+    return options.bundle[CompiledServerExportNames.serverLayer].pipe(Layer.provide(ServerConfigLayer));
+});
+const makeRunnableHttpLayer = Effect.fnUntraced(function*(options) {
+    const ServerConfigLayer = yield* makeServerConfigLayer(options);
+    return options.bundle[CompiledServerExportNames.httpLayer].pipe(Layer.provide(ServerConfigLayer));
+});
+const loadServerBundle = Effect.fnUntraced(function*(serverBundlePath) {
+    const path = yield* Path.Path;
+    const serverBundleUrl = yield* path.toFileUrl(serverBundlePath).pipe(Effect.mapError((cause)=>new CompiledServerError({
+            message: `Failed to resolve the server bundle at ${serverBundlePath}.`,
+            cause
+        })));
+    const importedBundle = yield* Effect.tryPromise({
+        try: ()=>import(serverBundleUrl.href),
+        catch: (cause)=>new CompiledServerError({
+                message: `Failed to load the server bundle at ${serverBundlePath}.`,
+                cause
+            })
+    });
+    return yield* decodeServerBundle(importedBundle).pipe(Effect.mapError((cause)=>new CompiledServerError({
+            message: `The server bundle at ${serverBundlePath} has an invalid framework contract.`,
+            cause
+        })));
+});
+const loadCompiledServer = Effect.fnUntraced(function*(root) {
+    const path = yield* Path.Path;
+    return yield* loadServerBundle(path.resolve(root, BuildServerBundlePath));
+});
+
+export { CompiledServerError, decodeServerBundle, loadCompiledServer, loadServerBundle, makeRunnableHttpLayer, makeRunnableServerLayer };
+
+//# sourceMappingURL=compiled-server.js.map

package/dist/build/compiled-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build/compiled-server.js","sources":["../../src/build/compiled-server.ts"],"sourcesContent":["import { Effect, FileSystem, Layer, Path, Schema, Types } from 'effect';\nimport { HttpRouter } from 'effect/unstable/http';\n\nimport { ServerConfig } from '../server/server-config';\nimport { BuildServerBundlePath, CompiledServerExportNames, PublicAssetsDir } from './contract';\n\nexport class CompiledServerError extends Schema.TaggedError<CompiledServerError>()(\n  'CompiledServerError',\n  {\n    message: Schema.String,\n    cause: Schema.Defect(),\n  },\n) {}\n\nconst CompiledApplication = Schema.Struct({\n  entryCssFiles: Schema.Array(Schema.String),\n  entryJsFiles: Schema.NonEmptyArray(Schema.String),\n});\n\nconst CompiledServerLayer = Schema.declare(\n  (input): input is Layer.Layer<never, Types.unhandled, ServerConfig> => Layer.isLayer(input),\n  { expected: 'the compiled effective-rsc ServerLayer' },\n);\n\nconst CompiledHttpLayer = Schema.declare(\n  (\n    input,\n  ): input is Layer.Layer<\n    never,\n    Types.unhandled,\n    FileSystem.FileSystem | HttpRouter.HttpRouter | Path.Path | ServerConfig\n  > => Layer.isLayer(input),\n  { expected: 'the compiled effective-rsc HttpLayer' },\n);\n\nconst ServerBundle = Schema.Struct({\n  [CompiledServerExportNames.application]: CompiledApplication,\n  [CompiledServerExportNames.httpLayer]: CompiledHttpLayer,\n  [CompiledServerExportNames.serverLayer]: CompiledServerLayer,\n});\n\nexport type ServerBundle = typeof ServerBundle.Type;\n\nexport const decodeServerBundle = Schema.decodeUnknownEffect(ServerBundle);\n\ntype RunnableLayerOptions = {\n  readonly bundle: ServerBundle;\n  readonly clientAssetsCacheControl: string;\n  readonly clientOutputDir: string;\n  readonly hostname: string;\n  readonly port: number;\n  readonly root: string;\n};\n\nconst makeServerConfigLayer = Effect.fnUntraced(function* ({\n  bundle,\n  clientAssetsCacheControl,\n  clientOutputDir,\n  hostname,\n  port,\n  root,\n}: RunnableLayerOptions) {\n  const path = yield* Path.Path;\n\n  return Layer.succeed(\n    ServerConfig,\n    ServerConfig.of({\n      clientAssetsCacheControl,\n      clientAssetsRoot: path.resolve(root, clientOutputDir),\n      clientBootstrapScripts: bundle[CompiledServerExportNames.application].entryJsFiles,\n      clientStylesheets: bundle[CompiledServerExportNames.application].entryCssFiles,\n      hostname,\n      port,\n      publicAssetsRoot: path.resolve(root, PublicAssetsDir),\n    }),\n  );\n});\n\nexport const makeRunnableServerLayer = Effect.fnUntraced(function* (options: RunnableLayerOptions) {\n  const ServerConfigLayer = yield* makeServerConfigLayer(options);\n\n  return options.bundle[CompiledServerExportNames.serverLayer].pipe(\n    Layer.provide(ServerConfigLayer),\n  );\n});\n\nexport const makeRunnableHttpLayer = Effect.fnUntraced(function* (options: RunnableLayerOptions) {\n  const ServerConfigLayer = yield* makeServerConfigLayer(options);\n\n  return options.bundle[CompiledServerExportNames.httpLayer].pipe(Layer.provide(ServerConfigLayer));\n});\n\nexport const loadServerBundle = Effect.fnUntraced(function* (serverBundlePath: string) {\n  const path = yield* Path.Path;\n  const serverBundleUrl = yield* path.toFileUrl(serverBundlePath).pipe(\n    Effect.mapError(\n      (cause) =>\n        new CompiledServerError({\n          message: `Failed to resolve the server bundle at ${serverBundlePath}.`,\n          cause,\n        }),\n    ),\n  );\n  const importedBundle = yield* Effect.tryPromise({\n    try: (): Promise<unknown> => import(serverBundleUrl.href),\n    catch: (cause) =>\n      new CompiledServerError({\n        message: `Failed to load the server bundle at ${serverBundlePath}.`,\n        cause,\n      }),\n  });\n\n  return yield* decodeServerBundle(importedBundle).pipe(\n    Effect.mapError(\n      (cause) =>\n        new CompiledServerError({\n          message: `The server bundle at ${serverBundlePath} has an invalid framework contract.`,\n          cause,\n        }),\n    ),\n  );\n});\n\nexport const loadCompiledServer = Effect.fnUntraced(function* (root: string) {\n  const path = yield* Path.Path;\n\n  return yield* loadServerBundle(path.resolve(root, BuildServerBundlePath));\n});\n"],"names":["Effect","Layer","Path","Schema","ServerConfig","BuildServerBundlePath","CompiledServerExportNames","PublicAssetsDir","CompiledServerError","CompiledApplication","CompiledServerLayer","input","CompiledHttpLayer","ServerBundle","decodeServerBundle","makeServerConfigLayer","bundle","clientAssetsCacheControl","clientOutputDir","hostname","port","root","path","makeRunnableServerLayer","options","ServerConfigLayer","makeRunnableHttpLayer","loadServerBundle","serverBundlePath","serverBundleUrl","cause","importedBundle","loadCompiledServer"],"mappings":"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"}

package/dist/build/contract.d.ts

@@ -0,0 +1,23 @@
+export declare const ApplicationEntryPath = "src/application.tsx";
+export declare const ApplicationEntrySpecifier = "effective-rsc/application-entry";
+export declare const ErscOutputDir = ".ersc";
+export declare const ClientEntryName = "main";
+export declare const DevOutputDir = ".ersc/dev";
+export declare const PublicAssetsDir = "public";
+export declare const ServerEntryName = "main";
+export type Environment = 'development' | 'production';
+export type EnvironmentConfig = {
+    readonly clientAssetsCacheControl: string;
+    readonly clientCssFilename: string;
+    readonly clientJsFilename: string;
+    readonly clientOutputDir: string;
+    readonly serverJsFilename: string;
+    readonly serverOutputDir: string;
+};
+export declare const EnvironmentConfig: Record<Environment, EnvironmentConfig>;
+export declare const CompiledServerExportNames: {
+    readonly application: 'default';
+    readonly httpLayer: 'HttpLayer';
+    readonly serverLayer: 'ServerLayer';
+};
+export declare const BuildServerBundlePath: string;

package/dist/build/contract.js

@@ -0,0 +1,41 @@
+const ApplicationEntryPath = 'src/application.tsx';
+const ApplicationEntrySpecifier = 'effective-rsc/application-entry';
+const ErscOutputDir = '.ersc';
+const ClientEntryName = 'main';
+const DevOutputDir = `${ErscOutputDir}/dev`;
+const PublicAssetsDir = 'public';
+const ServerEntryName = 'main';
+// A client asset name changes whenever its bytes change, so a client may keep it forever, and
+// `ersc start` resolves the server bundle by path, so that one is named once.
+const production = {
+    clientAssetsCacheControl: 'public, max-age=31536000, immutable',
+    clientCssFilename: '[name].[contenthash].css',
+    clientJsFilename: '[name].[contenthash].js',
+    clientOutputDir: `${ErscOutputDir}/client`,
+    serverJsFilename: '[name].js',
+    serverOutputDir: `${ErscOutputDir}/server`
+};
+// Development keeps its own output directory, stores nothing across rebuilds, and reimports the
+// server bundle every generation, where a repeated specifier would resolve to the module already
+// in the registry.
+const development = {
+    ...production,
+    clientAssetsCacheControl: 'no-store',
+    clientOutputDir: `${DevOutputDir}/client`,
+    serverJsFilename: '[name].[contenthash].js',
+    serverOutputDir: `${DevOutputDir}/server`
+};
+const EnvironmentConfig = {
+    development: development,
+    production: production
+};
+const CompiledServerExportNames = {
+    application: 'default',
+    httpLayer: 'HttpLayer',
+    serverLayer: 'ServerLayer'
+};
+const BuildServerBundlePath = `${production.serverOutputDir}/${production.serverJsFilename.replace('[name]', ServerEntryName)}`;
+
+export { ApplicationEntryPath, ApplicationEntrySpecifier, BuildServerBundlePath, ClientEntryName, CompiledServerExportNames, DevOutputDir, EnvironmentConfig, ErscOutputDir, PublicAssetsDir, ServerEntryName };
+
+//# sourceMappingURL=contract.js.map

package/dist/build/contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build/contract.js","sources":["../../src/build/contract.ts"],"sourcesContent":["export const ApplicationEntryPath = 'src/application.tsx';\nexport const ApplicationEntrySpecifier = 'effective-rsc/application-entry';\n\nexport const ErscOutputDir = '.ersc';\nexport const ClientEntryName = 'main';\nexport const DevOutputDir = `${ErscOutputDir}/dev`;\nexport const PublicAssetsDir = 'public';\nexport const ServerEntryName = 'main';\n\nexport type Environment = 'development' | 'production';\n\nexport type EnvironmentConfig = {\n  readonly clientAssetsCacheControl: string;\n  readonly clientCssFilename: string;\n  readonly clientJsFilename: string;\n  readonly clientOutputDir: string;\n  readonly serverJsFilename: string;\n  readonly serverOutputDir: string;\n};\n\n// A client asset name changes whenever its bytes change, so a client may keep it forever, and\n// `ersc start` resolves the server bundle by path, so that one is named once.\nconst production: EnvironmentConfig = {\n  clientAssetsCacheControl: 'public, max-age=31536000, immutable',\n  clientCssFilename: '[name].[contenthash].css',\n  clientJsFilename: '[name].[contenthash].js',\n  clientOutputDir: `${ErscOutputDir}/client`,\n  serverJsFilename: '[name].js',\n  serverOutputDir: `${ErscOutputDir}/server`,\n};\n\n// Development keeps its own output directory, stores nothing across rebuilds, and reimports the\n// server bundle every generation, where a repeated specifier would resolve to the module already\n// in the registry.\nconst development: EnvironmentConfig = {\n  ...production,\n  clientAssetsCacheControl: 'no-store',\n  clientOutputDir: `${DevOutputDir}/client`,\n  serverJsFilename: '[name].[contenthash].js',\n  serverOutputDir: `${DevOutputDir}/server`,\n};\n\nexport const EnvironmentConfig: Record<Environment, EnvironmentConfig> = {\n  development,\n  production,\n};\n\nexport const CompiledServerExportNames: {\n  readonly application: 'default';\n  readonly httpLayer: 'HttpLayer';\n  readonly serverLayer: 'ServerLayer';\n} = {\n  application: 'default',\n  httpLayer: 'HttpLayer',\n  serverLayer: 'ServerLayer',\n};\n\nexport const BuildServerBundlePath = `${production.serverOutputDir}/${production.serverJsFilename.replace('[name]', ServerEntryName)}`;\n"],"names":["ApplicationEntryPath","ApplicationEntrySpecifier","ErscOutputDir","ClientEntryName","DevOutputDir","PublicAssetsDir","ServerEntryName","production","development","EnvironmentConfig","CompiledServerExportNames","BuildServerBundlePath"],"mappings":"AAAO,MAAMA,oBAAoBA,GAAG,sBAAsB;AACnD,MAAMC,yBAAyBA,GAAG,kCAAkC;AAEpE,MAAMC,aAAaA,GAAG,QAAQ;AAC9B,MAAMC,eAAeA,GAAG,OAAO;AAC/B,MAAMC,YAAYA,GAAG,GAAGF,aAAaA,CAAC,IAAI,CAAC,CAAC;AAC5C,MAAMG,eAAeA,GAAG,SAAS;AACjC,MAAMC,eAAeA,GAAG,OAAO;AAatC,8FAA8F;AAC9F,8EAA8E;AAC9E,MAAMC,UAAUA,GAAsB;IACpC,0BAA0B;IAC1B,mBAAmB;IACnB,kBAAkB;IAClB,iBAAiB,GAAGL,aAAaA,CAAC,OAAO,CAAC;IAC1C,kBAAkB;IAClB,iBAAiB,GAAGA,aAAaA,CAAC,OAAO,CAAC;AAC5C;AAEA,gGAAgG;AAChG,iGAAiG;AACjG,mBAAmB;AACnB,MAAMM,WAAWA,GAAsB;IACrC,GAAGD,UAAU;IACb,0BAA0B;IAC1B,iBAAiB,GAAGH,YAAYA,CAAC,OAAO,CAAC;IACzC,kBAAkB;IAClB,iBAAiB,GAAGA,YAAYA,CAAC,OAAO,CAAC;AAC3C;AAEO,MAAMK,iBAAiBA,GAA2C;IACvED,wBAAWA;IACXD,sBAAUA;AACZ,EAAE;AAEK,MAAMG,yBAAyBA,GAIlC;IACF,aAAa;IACb,WAAW;IACX,aAAa;AACf,EAAE;AAEK,MAAMC,qBAAqBA,GAAG,GAAGJ,UAAUA,CAAC,eAAe,CAAC,CAAC,EAAEA,UAAUA,CAAC,gBAAgB,CAAC,OAAO,CAAC,UAAUD,eAAeA,GAAG,CAAC"}

package/dist/build/dev-channel.d.ts

@@ -0,0 +1,20 @@
+import { Effect, Stream } from 'effect';
+import { HttpServerRequest, HttpServerResponse } from 'effect/unstable/http';
+export declare const makeDevChannel: Effect.Effect<{
+    close: Effect.Effect<void, never, never>;
+    httpEffect: Effect.Effect<HttpServerResponse.HttpServerResponse, never, HttpServerRequest.HttpServerRequest | import("effect/Scope").Scope>;
+    onCompilationStart: () => void;
+    onServerComponentChanges: () => void;
+    publishBuildFailure: (diagnostics: string) => Effect.Effect<void, never, never>;
+    publishCompilation: (clientHash: string) => Effect.Effect<void, never, never>;
+    updates: Stream.Stream<{
+        readonly _tag: "ClientUpdate";
+        readonly clientHash: string;
+    } | {
+        readonly _tag: "RscUpdate";
+        readonly clientHash: string;
+    } | {
+        readonly _tag: "BuildFailed";
+        readonly diagnostics: string;
+    }, never, never>;
+}, never, import("effect/Scope").Scope>;

package/dist/build/dev-channel.js

@@ -0,0 +1,71 @@
+import { Deferred, Effect, Layer, MutableRef, Stream, SubscriptionRef } from "effect";
+import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
+import { DevRpcs } from "../dev/channel.js";
+
+
+
+
+
+
+
+
+
+const hasSameOrigin = (request)=>{
+    const origin = request.headers['origin'];
+    if (origin === undefined) {
+        return false;
+    }
+    try {
+        return new URL(origin).origin === new URL(request.originalUrl).origin;
+    } catch  {
+        return false;
+    }
+};
+const makeDevChannel = Effect.gen(function*() {
+    const pending = MutableRef.make({
+        _tag: 'ClientUpdate'
+    });
+    const state = yield* SubscriptionRef.make({
+        _tag: 'Initial'
+    });
+    const shutdownSignal = yield* Deferred.make();
+    const updates = SubscriptionRef.changes(state).pipe(Stream.filter((update)=>update._tag !== 'Initial'));
+    const onCompilationStart = ()=>{
+        MutableRef.set(pending, {
+            _tag: 'ClientUpdate'
+        });
+    };
+    const onServerComponentChanges = ()=>{
+        MutableRef.set(pending, {
+            _tag: 'RscUpdate'
+        });
+    };
+    const publishCompilation = (clientHash)=>SubscriptionRef.set(state, {
+            ...MutableRef.get(pending),
+            clientHash
+        });
+    const publishBuildFailure = (diagnostics)=>SubscriptionRef.set(state, {
+            _tag: 'BuildFailed',
+            diagnostics
+        });
+    const Handlers = DevRpcs.toLayerHandler('ObserveDevUpdates', ()=>updates);
+    const rpcHttpEffect = yield* RpcServer.toHttpEffectWebsocket(DevRpcs).pipe(Effect.provide(Layer.merge(Handlers, RpcSerialization.layerJson)));
+    const sameOriginRpcHttpEffect = HttpServerRequest.HttpServerRequest.use((request)=>hasSameOrigin(request) ? rpcHttpEffect : Effect.succeed(HttpServerResponse.empty({
+            status: 403
+        })));
+    const httpEffect = Effect.raceFirst(Deferred["await"](shutdownSignal).pipe(Effect.as(HttpServerResponse.empty())), sameOriginRpcHttpEffect);
+    return {
+        close: Deferred.succeed(shutdownSignal, undefined).pipe(Effect.asVoid),
+        httpEffect,
+        onCompilationStart,
+        onServerComponentChanges,
+        publishBuildFailure,
+        publishCompilation,
+        updates
+    };
+});
+
+export { makeDevChannel };
+
+//# sourceMappingURL=dev-channel.js.map

package/dist/build/dev-channel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build/dev-channel.js","sources":["../../src/build/dev-channel.ts"],"sourcesContent":["import { Deferred, Effect, Layer, MutableRef, Stream, SubscriptionRef } from 'effect';\nimport { HttpServerRequest, HttpServerResponse } from 'effect/unstable/http';\nimport { RpcSerialization, RpcServer } from 'effect/unstable/rpc';\n\nimport { DevRpcs, type DevUpdate } from '../dev/channel';\n\ntype DevChannelState = { readonly _tag: 'Initial' } | DevUpdate;\ntype PendingDevUpdate = { readonly _tag: 'ClientUpdate' } | { readonly _tag: 'RscUpdate' };\n\nconst hasSameOrigin = (request: HttpServerRequest.HttpServerRequest) => {\n  const origin = request.headers['origin'];\n  if (origin === undefined) {\n    return false;\n  }\n\n  try {\n    return new URL(origin).origin === new URL(request.originalUrl).origin;\n  } catch {\n    return false;\n  }\n};\n\nexport const makeDevChannel = Effect.gen(function* () {\n  const pending = MutableRef.make<PendingDevUpdate>({ _tag: 'ClientUpdate' });\n  const state = yield* SubscriptionRef.make<DevChannelState>({ _tag: 'Initial' });\n  const shutdownSignal = yield* Deferred.make<void>();\n  const updates = SubscriptionRef.changes(state).pipe(\n    Stream.filter((update): update is DevUpdate => update._tag !== 'Initial'),\n  );\n  const onCompilationStart = () => {\n    MutableRef.set(pending, { _tag: 'ClientUpdate' });\n  };\n  const onServerComponentChanges = () => {\n    MutableRef.set(pending, { _tag: 'RscUpdate' });\n  };\n  const publishCompilation = (clientHash: string) =>\n    SubscriptionRef.set(state, { ...MutableRef.get(pending), clientHash });\n  const publishBuildFailure = (diagnostics: string) =>\n    SubscriptionRef.set(state, { _tag: 'BuildFailed', diagnostics });\n  const Handlers = DevRpcs.toLayerHandler('ObserveDevUpdates', () => updates);\n  const rpcHttpEffect = yield* RpcServer.toHttpEffectWebsocket(DevRpcs).pipe(\n    Effect.provide(Layer.merge(Handlers, RpcSerialization.layerJson)),\n  );\n  const sameOriginRpcHttpEffect = HttpServerRequest.HttpServerRequest.use((request) =>\n    hasSameOrigin(request)\n      ? rpcHttpEffect\n      : Effect.succeed(HttpServerResponse.empty({ status: 403 })),\n  );\n  const httpEffect = Effect.raceFirst(\n    Deferred.await(shutdownSignal).pipe(Effect.as(HttpServerResponse.empty())),\n    sameOriginRpcHttpEffect,\n  );\n\n  return {\n    close: Deferred.succeed(shutdownSignal, undefined).pipe(Effect.asVoid),\n    httpEffect,\n    onCompilationStart,\n    onServerComponentChanges,\n    publishBuildFailure,\n    publishCompilation,\n    updates,\n  };\n});\n"],"names":["Deferred","Effect","Layer","MutableRef","Stream","SubscriptionRef","HttpServerRequest","HttpServerResponse","RpcSerialization","RpcServer","DevRpcs","hasSameOrigin","request","origin","undefined","URL","makeDevChannel","pending","state","shutdownSignal","updates","update","onCompilationStart","onServerComponentChanges","publishCompilation","clientHash","publishBuildFailure","diagnostics","Handlers","rpcHttpEffect","sameOriginRpcHttpEffect","httpEffect"],"mappings":";;;;;;;;;AAAsF;AACT;AACX;AAET;AAKzD,MAAMW,aAAaA,GAAG,CAACC;IACrB,MAAMC,SAASD,QAAQ,OAAO,CAAC,SAAS;IACxC,IAAIC,WAAWC,WAAW;QACxB,OAAO;IACT;IAEA,IAAI;QACF,OAAO,IAAIC,IAAIF,QAAQ,MAAM,KAAK,IAAIE,IAAIH,QAAQ,WAAW,EAAE,MAAM;IACvE,EAAE,OAAM;QACN,OAAO;IACT;AACF;AAEO,MAAMI,cAAcA,GAAGf,UAAU,CAAC;IACvC,MAAMgB,UAAUd,eAAe,CAAmB;QAAE,MAAM;IAAe;IACzE,MAAMe,QAAQ,OAAOb,oBAAoB,CAAkB;QAAE,MAAM;IAAU;IAC7E,MAAMc,iBAAiB,OAAOnB,aAAa;IAC3C,MAAMoB,UAAUf,uBAAuB,CAACa,OAAO,IAAI,CACjDd,aAAa,CAAC,CAACiB,SAAgCA,OAAO,IAAI,KAAK;IAEjE,MAAMC,qBAAqB;QACzBnB,cAAc,CAACc,SAAS;YAAE,MAAM;QAAe;IACjD;IACA,MAAMM,2BAA2B;QAC/BpB,cAAc,CAACc,SAAS;YAAE,MAAM;QAAY;IAC9C;IACA,MAAMO,qBAAqB,CAACC,aAC1BpB,mBAAmB,CAACa,OAAO;YAAE,GAAGf,cAAc,CAACc,QAAQ;YAAEQ;QAAW;IACtE,MAAMC,sBAAsB,CAACC,cAC3BtB,mBAAmB,CAACa,OAAO;YAAE,MAAM;YAAeS;QAAY;IAChE,MAAMC,WAAWlB,sBAAsB,CAAC,qBAAqB,IAAMU;IACnE,MAAMS,gBAAgB,OAAOpB,+BAA+B,CAACC,OAAOA,EAAE,IAAI,CACxET,cAAc,CAACC,WAAW,CAAC0B,UAAUpB,0BAA0B;IAEjE,MAAMsB,0BAA0BxB,uCAAuC,CAAC,CAACM,UACvED,aAAaA,CAACC,WACViB,gBACA5B,cAAc,CAACM,wBAAwB,CAAC;YAAE,QAAQ;QAAI;IAE5D,MAAMwB,aAAa9B,gBAAgB,CACjCD,iBAAc,CAACmB,gBAAgB,IAAI,CAAClB,SAAS,CAACM,wBAAwB,MACtEuB;IAGF,OAAO;QACL,OAAO9B,gBAAgB,CAACmB,gBAAgBL,WAAW,IAAI,CAACb,aAAa;QACrE8B;QACAT;QACAC;QACAG;QACAF;QACAJ;IACF;AACF,GAAG"}

package/dist/build/dev.d.ts

@@ -0,0 +1,41 @@
+import { Effect, FileSystem, Path, Schema } from 'effect';
+import { HttpServer } from 'effect/unstable/http';
+import { Rspack, type RspackError, type RspackWatchEvent } from './rspack.js';
+type RspackCompilation = Extract<RspackWatchEvent, {
+    readonly _tag: 'Compiled';
+}>;
+declare const DevGenerationError_base: Schema.Class<DevGenerationError, Schema.TaggedStruct<"DevGenerationError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class DevGenerationError extends DevGenerationError_base {
+}
+type AcquireDevGenerationOptions = {
+    readonly compilation: RspackCompilation;
+    readonly hostname: string;
+    readonly port: number;
+    readonly root: string;
+};
+type DevGenerationOptions = Omit<AcquireDevGenerationOptions, 'compilation'>;
+export type DevApplicationOptions = DevGenerationOptions;
+export declare const acquireDevGeneration: (args_0: AcquireDevGenerationOptions) => Effect.Effect<{
+    hash: string;
+    httpEffect: Effect.Effect<import("effect/unstable/http/HttpServerResponse").HttpServerResponse, import("effect/unstable/http/HttpServerError").HttpServerError, import("effect/unstable/http/HttpServerRequest").HttpServerRequest | import("effect/Scope").Scope>;
+}, import("./compiled-server.js").CompiledServerError | DevGenerationError, FileSystem.FileSystem | Path.Path | import("effect/Scope").Scope>;
+type DevGenerationFailure = Effect.Error<ReturnType<typeof acquireDevGeneration>> | RspackError;
+export declare const makeDevGenerationStore: (options: DevGenerationOptions) => Effect.Effect<{
+    httpEffect: Effect.Effect<import("effect/unstable/http/HttpServerResponse").HttpServerResponse, import("effect/unstable/http/HttpServerError").HttpServerError | DevGenerationFailure, import("effect/unstable/http/HttpServerRequest").HttpServerRequest | import("effect/Scope").Scope>;
+    update: (event: RspackWatchEvent) => Effect.Effect<undefined, import("./compiled-server.js").CompiledServerError | DevGenerationError, FileSystem.FileSystem | Path.Path>;
+}, never, import("effect/Scope").Scope>;
+export declare const makeDevApplication: (args_0: DevGenerationOptions) => Effect.Effect<{
+    closeDevChannel: Effect.Effect<void, never, never>;
+    httpEffect: Effect.Effect<import("effect/unstable/http/HttpServerResponse").HttpServerResponse, import("./compiled-server.js").CompiledServerError | DevGenerationError | import("effect/unstable/http/HttpServerError").HttpServerError | RspackError, import("effect/unstable/http/HttpServerRequest").HttpServerRequest | import("effect/Scope").Scope>;
+    watch: Effect.Effect<void, import("./compiled-server.js").CompiledServerError | DevGenerationError | RspackError, FileSystem.FileSystem | Path.Path>;
+}, import("./build.js").BuildEntryError | import("effect/PlatformError").PlatformError, FileSystem.FileSystem | Path.Path | Rspack | import("effect/Scope").Scope>;
+export declare const launchDevApplication: (application: {
+    closeDevChannel: Effect.Effect<void, never, never>;
+    httpEffect: Effect.Effect<import("effect/unstable/http/HttpServerResponse").HttpServerResponse, import("./compiled-server.js").CompiledServerError | DevGenerationError | import("effect/unstable/http/HttpServerError").HttpServerError | RspackError, import("effect/unstable/http/HttpServerRequest").HttpServerRequest | import("effect/Scope").Scope>;
+    watch: Effect.Effect<void, import("./compiled-server.js").CompiledServerError | DevGenerationError | RspackError, FileSystem.FileSystem | Path.Path>;
+}) => Effect.Effect<void, import("./compiled-server.js").CompiledServerError | DevGenerationError | RspackError, FileSystem.FileSystem | HttpServer.HttpServer | Path.Path>;
+export declare const devApplication: (options: DevGenerationOptions) => Effect.Effect<void, import("./build.js").BuildEntryError | import("./compiled-server.js").CompiledServerError | DevGenerationError | import("effect/PlatformError").PlatformError | RspackError, FileSystem.FileSystem | HttpServer.HttpServer | Path.Path | import("effect/Scope").Scope>;
+export {};