effect-start 0.17.0 → 0.17.2

package/dist/bun/_BunEnhancedResolve.d.ts

@@ -0,0 +1,45 @@
+type ErrorWithDetail = Error & {
+    details?: string;
+};
+interface ResolveRequest {
+    path: string | false;
+    context?: object;
+    descriptionFilePath?: string;
+    descriptionFileRoot?: string;
+    descriptionFileData?: Record<string, unknown>;
+    relativePath?: string;
+    ignoreSymlinks?: boolean;
+    fullySpecified?: boolean;
+}
+interface ResolveContext {
+    contextDependencies?: {
+        add: (item: string) => void;
+    };
+    fileDependencies?: {
+        add: (item: string) => void;
+    };
+    missingDependencies?: {
+        add: (item: string) => void;
+    };
+    stack?: Set<string>;
+    log?: (str: string) => void;
+    yield?: (request: ResolveRequest) => void;
+}
+interface ResolveOptions {
+    extensions?: string[];
+    mainFields?: (string | string[])[];
+    conditionNames?: string[];
+    fileSystem?: unknown;
+    useSyncFileSystemCalls?: boolean;
+    modules?: string | string[];
+}
+export interface Resolver {
+    resolve(context: object, path: string, request: string, resolveContext: ResolveContext, callback: (err: null | ErrorWithDetail, res?: string | false, req?: ResolveRequest) => void): void;
+}
+export declare class CachedInputFileSystem {
+    constructor(_fileSystem: unknown, _duration: number);
+}
+export declare const ResolverFactory: {
+    createResolver(options: ResolveOptions): Resolver;
+};
+export {};

package/dist/bun/_BunEnhancedResolve.js

@@ -0,0 +1,104 @@
+/**
+ * Bun adapter for enhanced-resolve
+ *
+ * This module provides a drop-in replacement for `enhanced-resolve` that uses
+ * Bun's built-in resolver. It implements the subset of the enhanced-resolve API
+ * used for Tailwind CSS.
+ */
+import fs from "node:fs";
+import path from "node:path";
+export class CachedInputFileSystem {
+    constructor(_fileSystem, _duration) { }
+}
+export const ResolverFactory = {
+    createResolver(options) {
+        const extensions = options.extensions ?? [];
+        const mainFields = (options.mainFields ?? []).flatMap((f) => Array.isArray(f) ? f : [f]);
+        const conditionNames = options.conditionNames ?? [];
+        return {
+            resolve(_context, basePath, id, _resolveContext, callback) {
+                try {
+                    const result = resolveSync(id, basePath, {
+                        extensions,
+                        mainFields,
+                        conditionNames,
+                    });
+                    callback(null, result);
+                }
+                catch (err) {
+                    callback(err instanceof Error ? err : new Error(String(err)));
+                }
+            },
+        };
+    },
+};
+function resolveSync(id, base, options) {
+    if (id.startsWith(".") || id.startsWith("/")) {
+        for (const ext of ["", ...options.extensions]) {
+            const fullPath = path.resolve(base, id + ext);
+            if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+                return fullPath;
+            }
+        }
+        return undefined;
+    }
+    const packagePath = resolvePackagePath(id, base);
+    if (!packagePath)
+        return undefined;
+    const packageJsonPath = path.join(packagePath, "package.json");
+    if (!fs.existsSync(packageJsonPath))
+        return undefined;
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    for (const field of options.mainFields) {
+        if (typeof packageJson[field] === "string") {
+            const resolved = path.resolve(packagePath, packageJson[field]);
+            if (fs.existsSync(resolved))
+                return resolved;
+        }
+    }
+    if (packageJson.exports) {
+        const resolved = resolveExports(packageJson.exports, packagePath, options.conditionNames);
+        if (resolved && fs.existsSync(resolved))
+            return resolved;
+    }
+    try {
+        return Bun.resolveSync(id, base);
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolvePackagePath(id, base) {
+    const parts = id.split("/");
+    const packageName = id.startsWith("@")
+        ? parts.slice(0, 2).join("/")
+        : parts[0];
+    let dir = base;
+    while (dir !== path.dirname(dir)) {
+        const candidate = path.join(dir, "node_modules", packageName);
+        if (fs.existsSync(candidate))
+            return candidate;
+        dir = path.dirname(dir);
+    }
+    return undefined;
+}
+function resolveExports(exports, packagePath, conditionNames) {
+    if (typeof exports === "string") {
+        return path.resolve(packagePath, exports);
+    }
+    if (exports && typeof exports === "object" && !Array.isArray(exports)) {
+        const exportsObj = exports;
+        if ("." in exportsObj) {
+            return resolveExports(exportsObj["."], packagePath, conditionNames);
+        }
+        for (const condition of conditionNames) {
+            if (condition in exportsObj) {
+                return resolveExports(exportsObj[condition], packagePath, conditionNames);
+            }
+        }
+        if ("default" in exportsObj) {
+            return resolveExports(exportsObj["default"], packagePath, conditionNames);
+        }
+    }
+    return undefined;
+}

package/dist/bun/index.d.ts

@@ -0,0 +1,4 @@
+export * as BunBundle from "./BunBundle.ts";
+export * as BunHttpServer from "./BunHttpServer.ts";
+export * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.ts";
+export * as BunRoute from "./BunRoute.ts";

package/dist/bun/index.js

@@ -0,0 +1,4 @@
+export * as BunBundle from "./BunBundle.js";
+export * as BunHttpServer from "./BunHttpServer.js";
+export * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.js";
+export * as BunRoute from "./BunRoute.js";

package/dist/bundler/Bundle.d.ts

@@ -0,0 +1,60 @@
+import { Context, Effect, PubSub } from "effect";
+import * as Schema from "effect/Schema";
+export declare const BundleEntrypointMetaKey: unique symbol;
+export type BundleOutputMetaValue = {};
+/**
+ * Generic shape describing a bundle across multiple bundlers
+ * (like bun, esbuild & vite)
+ */
+export declare const BundleManifestSchema: Schema.Struct<{
+    entrypoints: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+    artifacts: Schema.Array$<Schema.Struct<{
+        path: typeof Schema.String;
+        type: typeof Schema.String;
+        size: typeof Schema.Number;
+        hash: Schema.optional<typeof Schema.String>;
+        imports: Schema.optional<Schema.Array$<Schema.Struct<{
+            path: typeof Schema.String;
+            kind: Schema.Literal<["import-statement", "require-call", "require-resolve", "dynamic-import", "import-rule", "url-token", "internal", "entry-point-run", "entry-point-build"]>;
+        }>>>;
+    }>>;
+}>;
+export type BundleManifest = typeof BundleManifestSchema.Type;
+export declare const BundleEvent: Schema.Union<[Schema.TaggedStruct<"Change", {
+    path: typeof Schema.String;
+}>, Schema.TaggedStruct<"BuildError", {
+    error: typeof Schema.String;
+}>]>;
+export type BundleEvent = typeof BundleEvent.Type;
+declare const IdPrefix = "effect-start/tags/";
+export type BundleKey = `${string}Bundle`;
+export type BundleId = `${typeof IdPrefix}${BundleKey}`;
+/**
+ * Passed to bundle effects and within bundle runtime.
+ * Used to expose artifacts via HTTP server and properly resolve
+ * imports within the bundle.
+ */
+export type BundleContext = BundleManifest & {
+    resolve: (url: string) => string | null;
+    getArtifact: (path: string) => Blob | null;
+    events?: PubSub.PubSub<BundleEvent>;
+};
+declare const BundleError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "BundleError";
+} & Readonly<A>;
+export declare class BundleError extends BundleError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
+export declare const emptyBundleContext: BundleContext;
+export declare const handleBundleErrorSilently: (effect: Effect.Effect<BundleContext, BundleError>) => Effect.Effect<BundleContext, never>;
+export declare const Tag: <const T extends BundleKey>(name: T) => <Identifier>() => Context.TagClass<Identifier, `effect-start/tags/${string}Bundle`, BundleContext>;
+export type Tag = Context.Tag<BundleId, BundleContext>;
+declare const ClientBundle_base: Context.TagClass<ClientBundle, `effect-start/tags/${string}Bundle`, BundleContext>;
+export declare class ClientBundle extends ClientBundle_base {
+}
+declare const ServerBundle_base: Context.TagClass<ServerBundle, `effect-start/tags/${string}Bundle`, BundleContext>;
+export declare class ServerBundle extends ServerBundle_base {
+}
+export {};

package/dist/bundler/Bundle.js

@@ -0,0 +1,48 @@
+import { Context, Data, Effect, pipe, } from "effect";
+import * as Schema from "effect/Schema";
+export const BundleEntrypointMetaKey = Symbol.for("effect-start/BundleEntrypointMetaKey");
+/**
+ * Generic shape describing a bundle across multiple bundlers
+ * (like bun, esbuild & vite)
+ */
+export const BundleManifestSchema = Schema.Struct({
+    entrypoints: Schema.Record({
+        key: Schema.String,
+        value: Schema.String,
+    }),
+    artifacts: Schema.Array(Schema.Struct({
+        path: Schema.String,
+        type: Schema.String,
+        size: Schema.Number,
+        hash: pipe(Schema.String, Schema.optional),
+        imports: pipe(Schema.Array(Schema.Struct({
+            path: Schema.String,
+            kind: Schema.Literal("import-statement", "require-call", "require-resolve", "dynamic-import", "import-rule", "url-token", "internal", "entry-point-run", "entry-point-build"),
+        })), Schema.optional),
+    })),
+});
+const BundleEventChange = Schema.TaggedStruct("Change", {
+    path: Schema.String,
+});
+const BundleEventBuildError = Schema.TaggedStruct("BuildError", {
+    error: Schema.String,
+});
+export const BundleEvent = Schema.Union(BundleEventChange, BundleEventBuildError);
+const IdPrefix = "effect-start/tags/";
+export class BundleError extends Data.TaggedError("BundleError") {
+}
+export const emptyBundleContext = {
+    entrypoints: {},
+    artifacts: [],
+    resolve: () => null,
+    getArtifact: () => null,
+};
+export const handleBundleErrorSilently = (effect) => pipe(effect, Effect.catchTag("BundleError", (error) => Effect.gen(function* () {
+    yield* Effect.logError("Bundle build failed", error);
+    return emptyBundleContext;
+})));
+export const Tag = (name) => () => Context.Tag(`${IdPrefix}${name}`)();
+export class ClientBundle extends Tag("ClientBundle")() {
+}
+export class ServerBundle extends Tag("ServerBundle")() {
+}

package/dist/bundler/BundleFiles.d.ts

@@ -0,0 +1,13 @@
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Effect from "effect/Effect";
+import { type BundleContext, BundleError } from "./Bundle.ts";
+/**
+ * Exports a bundle to a file system under specified directory.
+ */
+export declare const toFiles: (context: BundleContext, outDir: string) => Effect.Effect<undefined, import("@effect/platform/Error").PlatformError | BundleError, FileSystem.FileSystem>;
+/**
+ * Loads a bundle from a directory and returns a BundleContext.
+ * Expects the directory to contain a manifest.json file and all the artifacts
+ * referenced in the manifest.
+ */
+export declare const fromFiles: (directory: string) => Effect.Effect<BundleContext, BundleError, FileSystem.FileSystem>;

package/dist/bundler/BundleFiles.js

@@ -0,0 +1,94 @@
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Iterable from "effect/Iterable";
+import * as Record from "effect/Record";
+import * as S from "effect/Schema";
+import { BundleError, BundleManifestSchema, } from "./Bundle.js";
+/**
+ * Exports a bundle to a file system under specified directory.
+ */
+export const toFiles = (context, outDir) => {
+    return Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const manifest = {
+            entrypoints: context.entrypoints,
+            artifacts: context.artifacts,
+        };
+        const normalizedOutDir = outDir.replace(/\/$/, "");
+        const bundleArtifacts = Function.pipe(manifest.artifacts, Array.map((artifact) => [artifact.path, context.getArtifact(artifact.path)]), Record.fromEntries);
+        const extraArtifacts = {
+            "manifest.json": new Blob([JSON.stringify(manifest, undefined, 2)], {
+                type: "application/json",
+            }),
+        };
+        const allArtifacts = {
+            ...bundleArtifacts,
+            ...extraArtifacts,
+        };
+        const existingOutDirFiles = yield* fs.readDirectory(normalizedOutDir).pipe(Effect.catchAll(() => Effect.succeed(null)));
+        // check if the output directory is empty. if it contains previous build,
+        // remove it. Otherwise fail.
+        if (existingOutDirFiles && existingOutDirFiles.length > 0) {
+            if (existingOutDirFiles.includes("manifest.json")) {
+                yield* Effect.logWarning("Output directory seems to contain previous build. Overwriting...");
+                yield* fs.remove(normalizedOutDir, {
+                    recursive: true,
+                });
+            }
+            else {
+                return yield* Effect.fail(new BundleError({
+                    message: "Output directory is not empty",
+                }));
+            }
+        }
+        yield* fs.makeDirectory(normalizedOutDir, {
+            recursive: true,
+        });
+        // write all artifacts to files
+        yield* Effect.all(Function.pipe(allArtifacts, Record.toEntries, Array.map(([p, b]) => Function.pipe(Effect.tryPromise({
+            try: () => b.arrayBuffer(),
+            catch: (e) => new BundleError({
+                message: "Failed to read an artifact as a buffer",
+                cause: e,
+            }),
+        }), Effect.andThen((b) => fs.writeFile(`${normalizedOutDir}/${p}`, new Uint8Array(b)))))), { concurrency: 16 });
+    });
+};
+/**
+ * Loads a bundle from a directory and returns a BundleContext.
+ * Expects the directory to contain a manifest.json file and all the artifacts
+ * referenced in the manifest.
+ */
+export const fromFiles = (directory) => {
+    return Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const normalizedDir = directory.replace(/\/$/, "");
+        const manifest = yield* Function.pipe(fs.readFileString(`${normalizedDir}/manifest.json`), Effect.andThen((v) => JSON.parse(v)), Effect.andThen(S.decodeUnknownSync(BundleManifestSchema)), Effect.catchAll((e) => Effect.fail(new BundleError({
+            message: `Failed to read manifest.json from ${normalizedDir}`,
+            cause: e,
+        }))));
+        const artifactPaths = Array.map(manifest.artifacts, (a) => a.path);
+        const artifactBlobs = yield* Function.pipe(artifactPaths, Iterable.map((path) => fs.readFile(`${normalizedDir}/${path}`)), Effect.all, Effect.catchAll((e) => new BundleError({
+            message: `Failed to read an artifact from ${normalizedDir}`,
+            cause: e,
+        })), Effect.andThen(Iterable.map((v, i) => new Blob([v.slice(0)], {
+            type: manifest.artifacts[i].type,
+        }))));
+        const artifactsRecord = Function.pipe(Iterable.zip(artifactPaths, artifactBlobs), Record.fromEntries);
+        const bundleContext = {
+            ...manifest,
+            // TODO: support fullpath file:// urls
+            // this will require having an access to base path of a build
+            // and maybe problematic because bundlers transform urls on build
+            resolve: (url) => {
+                return manifest.entrypoints[url] ?? null;
+            },
+            getArtifact: (path) => {
+                return artifactsRecord[path] ?? null;
+            },
+        };
+        return bundleContext;
+    });
+};

package/dist/bundler/BundleHttp.d.ts

@@ -0,0 +1,45 @@
+import type * as HttpApp from "@effect/platform/HttpApp";
+import { RouteNotFound } from "@effect/platform/HttpServerError";
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
+import * as HttpServerResponse from "@effect/platform/HttpServerResponse";
+import * as Effect from "effect/Effect";
+import * as Scope from "effect/Scope";
+import * as Bundle from "./Bundle.ts";
+/**
+ * Handles all entrypoints automatically.
+ * Serves HTML entrypoints without requiring explicit route definitions for each one.
+ * Examples:
+ *  index.html -> /
+ *  contact.html -> /contact
+ *  about/index.html -> /about
+ */
+export declare function entrypoint(uri?: string): HttpApp.Default<RouteNotFound, Bundle.ClientBundle>;
+export declare function httpApp(opts?: {
+    urlPrefix?: string;
+}): HttpApp.Default<RouteNotFound, Scope.Scope | Bundle.ClientBundle>;
+export declare const toHttpApp: <E, R>(bundleTag: Effect.Effect<Bundle.BundleContext, E, R>, opts?: {
+    urlPrefix?: string;
+}) => Effect.Effect<HttpServerResponse.HttpServerResponse, RouteNotFound | E, HttpServerRequest.HttpServerRequest | R>;
+/**
+ * Render HTML to a string.
+ * Useful for SSR.
+ */
+export declare function renderPromise(clientBundle: Bundle.Tag, render: (request: Request, resolve: (url: string) => string) => Promise<Response>): Effect.Effect<HttpServerResponse.HttpServerResponse, Bundle.BundleError, HttpServerRequest.HttpServerRequest | `effect-start/tags/${string}Bundle`>;
+/**
+ * Exposes bundle assets via HTTP routes.
+ * Serves bundle artifacts, manifest.json, and events endpoint at the specified path.
+ */
+export declare function withAssets(opts?: {
+    path?: string;
+}): <E, R>(app: HttpApp.Default<E, R>) => Effect.Effect<HttpServerResponse.HttpServerResponse, RouteNotFound | E, HttpServerRequest.HttpServerRequest | Bundle.ClientBundle | R>;
+/**
+ * @see {entrypoint}
+ */
+export declare function withEntrypoints(): <E, R>(app: HttpApp.Default<E, R>) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, HttpServerRequest.HttpServerRequest | Bundle.ClientBundle | R>;
+/**
+ * Combines both withAssets and withEntrypoints.
+ * Provides complete bundle HTTP functionality in a single function call.
+ */
+export declare function withBundle(opts?: {
+    path?: string;
+}): <E, R>(app: HttpApp.Default<E, R>) => Effect.Effect<HttpServerResponse.HttpServerResponse, RouteNotFound | E, HttpServerRequest.HttpServerRequest | Bundle.ClientBundle | R>;

package/dist/bundler/BundleHttp.js

@@ -0,0 +1,176 @@
+import * as Headers from "@effect/platform/Headers";
+import * as HttpMiddleware from "@effect/platform/HttpMiddleware";
+import { RouteNotFound } from "@effect/platform/HttpServerError";
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
+import * as HttpServerResponse from "@effect/platform/HttpServerResponse";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import * as NPath from "node:path";
+import * as NUrl from "node:url";
+import * as SseHttpResponse from "../experimental/SseHttpResponse.js";
+import * as Bundle from "./Bundle.js";
+const DefaultBundleEndpoint = "/_bundle";
+/**
+ * Handles all entrypoints automatically.
+ * Serves HTML entrypoints without requiring explicit route definitions for each one.
+ * Examples:
+ *  index.html -> /
+ *  contact.html -> /contact
+ *  about/index.html -> /about
+ */
+export function entrypoint(uri) {
+    return Effect.gen(function* () {
+        uri = uri?.startsWith("file://") ? NUrl.fileURLToPath(uri) : uri;
+        const request = yield* HttpServerRequest.HttpServerRequest;
+        const bundle = yield* Bundle.ClientBundle;
+        const requestPath = request.url.substring(1);
+        const pathAttempts = uri
+            ? [
+                // try paths from all parent directories in case absolute path is passed,
+                // like it is the case for `import(f, { type: "file" })`
+                ...uri
+                    .split(NPath.sep)
+                    .map((_, i, a) => NPath.join(...a.slice(i))),
+            ]
+            : [
+                requestPath ? `${requestPath}.html` : null,
+                requestPath ? `${requestPath}/index.html` : null,
+                requestPath === "" ? "index.html" : "",
+            ];
+        const artifact = pathAttempts
+            .filter(Boolean)
+            .map(path => bundle.getArtifact(path))
+            .find(Boolean);
+        if (artifact) {
+            return yield* renderBlob(artifact);
+        }
+        return yield* Effect.fail(new RouteNotFound({
+            request,
+        }));
+    });
+}
+export function httpApp(opts) {
+    return toHttpApp(Bundle.ClientBundle, opts);
+}
+export const toHttpApp = (bundleTag, opts) => {
+    return Effect.gen(function* () {
+        const request = yield* HttpServerRequest.HttpServerRequest;
+        const bundle = yield* bundleTag;
+        const path = opts?.urlPrefix && request.url.startsWith(opts.urlPrefix + "/")
+            ? request.url.substring(opts.urlPrefix.length + 1)
+            : request.url.substring(1);
+        /**
+         * Expose manifest that contains information about the bundle.
+         */
+        if (path === "manifest.json") {
+            return HttpServerResponse.text(JSON.stringify({
+                entrypoints: bundle.entrypoints,
+                artifacts: bundle.artifacts,
+            }, undefined, 2), {
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            });
+        }
+        /**
+         * Expose events endpoint if available.
+         * Useful for development to implement live reload.
+         */
+        if (bundle.events && path === "events") {
+            return yield* SseHttpResponse.make(Stream.fromPubSub(bundle.events));
+        }
+        const artifact = bundle.artifacts.find((a) => a.path === path);
+        /**
+         * Expose artifacts.
+         */
+        if (artifact) {
+            const artifactBlob = bundle.getArtifact(path);
+            return yield* renderBlob(artifactBlob);
+        }
+        return yield* Effect.fail(new RouteNotFound({
+            request,
+        }));
+    });
+};
+/**
+ * Render HTML to a string.
+ * Useful for SSR.
+ */
+export function renderPromise(clientBundle, render) {
+    return Effect.gen(function* () {
+        const bundle = yield* clientBundle;
+        const req = yield* HttpServerRequest.HttpServerRequest;
+        const fetchReq = req.source;
+        // TODO: add support for file:// urls
+        // this will require handling source base path
+        const resolve = (url) => {
+            const path = url.startsWith("file://")
+                ? NUrl.fileURLToPath(url)
+                : url;
+            const publicBase = "/.bundle";
+            const publicPath = bundle.resolve(path);
+            return NPath.join(publicBase, publicPath ?? path);
+        };
+        const output = yield* Effect.tryPromise({
+            try: () => render(fetchReq, resolve),
+            catch: (e) => new Bundle.BundleError({
+                message: "Failed to render",
+                cause: e,
+            }),
+        });
+        return yield* HttpServerResponse.raw(output.body, {
+            status: output.status,
+            statusText: output.statusText,
+            headers: Headers.fromInput(output.headers),
+        });
+    });
+}
+const renderBlob = (blob) => {
+    return Effect.gen(function* () {
+        const bytes = yield* Effect
+            .promise(() => blob.arrayBuffer())
+            .pipe(Effect.andThen(v => new Uint8Array(v)));
+        return HttpServerResponse.uint8Array(bytes, {
+            headers: {
+                "content-type": blob.type,
+                "content-length": String(blob.size),
+                "cache-control": "public, max-age=3600",
+            },
+        });
+    });
+};
+/**
+ * Exposes bundle assets via HTTP routes.
+ * Serves bundle artifacts, manifest.json, and events endpoint at the specified path.
+ */
+export function withAssets(opts) {
+    const path = opts?.path ?? DefaultBundleEndpoint;
+    return HttpMiddleware.make((app) => Effect.gen(function* () {
+        const request = yield* HttpServerRequest.HttpServerRequest;
+        if (request.url.startsWith(path + "/")) {
+            return yield* toHttpApp(Bundle.ClientBundle, { urlPrefix: path });
+        }
+        return yield* app;
+    }));
+}
+/**
+ * @see {entrypoint}
+ */
+export function withEntrypoints() {
+    return HttpMiddleware.make((app) => Effect.gen(function* () {
+        const entrypointResponse = yield* entrypoint().pipe(Effect.option);
+        if (Option.isSome(entrypointResponse)) {
+            return entrypointResponse.value;
+        }
+        return yield* app;
+    }));
+}
+/**
+ * Combines both withAssets and withEntrypoints.
+ * Provides complete bundle HTTP functionality in a single function call.
+ */
+export function withBundle(opts) {
+    return Function.flow(withAssets(opts), withEntrypoints());
+}

package/dist/client/Overlay.d.ts

@@ -0,0 +1,2 @@
+export declare function getOverlay(): HTMLPreElement;
+export declare function showBuildError(message: string): void;

package/dist/client/Overlay.js

@@ -0,0 +1,32 @@
+const OVERLAY_ID = "_bundler_error_overlay";
+export function getOverlay() {
+    let overlay = document.getElementById(OVERLAY_ID);
+    if (!overlay) {
+        overlay = document.createElement("pre");
+        overlay.id = OVERLAY_ID;
+        Object.assign(overlay.style, {
+            position: "fixed",
+            top: "0",
+            left: "0",
+            right: "0",
+            maxHeight: "40%",
+            overflowY: "auto",
+            margin: "0",
+            padding: "4px",
+            background: "black",
+            color: "red",
+            fontFamily: "monospace",
+            zIndex: "2147483647",
+            whiteSpace: "pre-wrap",
+        });
+        document.body.appendChild(overlay);
+    }
+    return overlay;
+}
+export function showBuildError(message) {
+    const overlay = getOverlay();
+    const atBottom = overlay.scrollTop + overlay.clientHeight >= overlay.scrollHeight - 1;
+    overlay.textContent += message + "\n";
+    if (atBottom)
+        overlay.scrollTop = overlay.scrollHeight;
+}

package/dist/client/ScrollState.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Persist current scroll state to session storage.
+ * Scroll state is saved relatively to visible elements.
+ */
+export declare function persist(): void;
+export declare function restore(): void;