effect-start 0.23.1 → 0.26.0

package/dist/bun/_BunEnhancedResolve.d.ts

@@ -1,45 +0,0 @@
-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?: Array<string>;
-    mainFields?: Array<string | string[]>;
-    conditionNames?: Array<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

@@ -1,102 +0,0 @@
-/**
- * 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

@@ -1,5 +0,0 @@
-export * as BunChildProcessSpawner from "./BunChildProcessSpawner.ts";
-export * as BunBundle from "./BunBundle.ts";
-export * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.ts";
-export * as BunRoute from "./BunRoute.ts";
-export * as BunServer from "./BunServer.ts";

package/dist/bun/index.js

@@ -1,5 +0,0 @@
-export * as BunChildProcessSpawner from "./BunChildProcessSpawner.js";
-export * as BunBundle from "./BunBundle.js";
-export * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.js";
-export * as BunRoute from "./BunRoute.js";
-export * as BunServer from "./BunServer.js";

package/dist/bundler/Bundle.d.ts

@@ -1,61 +0,0 @@
-import type { PubSub } from "effect";
-import { Context, Effect } 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

@@ -1,48 +0,0 @@
-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

@@ -1,13 +0,0 @@
-import * as FileSystem from "../FileSystem.ts";
-import * as Effect from "effect/Effect";
-import * as Bundle from "./Bundle.ts";
-/**
- * Exports a bundle to a file system under specified directory.
- */
-export declare const toFiles: (context: Bundle.BundleContext, outDir: string) => Effect.Effect<undefined, import("../PlatformError.ts").PlatformError | Bundle.BundleError, FileSystem.FileSystem>;
-/**
- * Loads a bundle from a directory and returns a Bundle.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<Bundle.BundleContext, Bundle.BundleError, FileSystem.FileSystem>;

package/dist/bundler/BundleFiles.js

@@ -1,96 +0,0 @@
-import * as FileSystem from "../FileSystem.js";
-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 * as Bundle 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 Bundle.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 Bundle.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 Bundle.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(Bundle.BundleManifestSchema)), Effect.catchAll((e) => Effect.fail(new Bundle.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 Bundle.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

@@ -1,45 +0,0 @@
-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

@@ -1,176 +0,0 @@
-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/bundler/BundleRoute.d.ts

@@ -1,27 +0,0 @@
-import type * as Context from "effect/Context";
-import * as Layer from "effect/Layer";
-import * as PathPattern from "../PathPattern.ts";
-import * as Route from "../Route.ts";
-import * as Bundle from "./Bundle.ts";
-/**
- * Creates a GET route that serves bundle artifacts.
- * Mount at a path with a wildcard param (any name works).
- *
- * ```ts
- * RouteTree.make({
- *   "/_bundle/:path+": BundleRoute.make(Bundle.ClientBundle),
- * })
- * ```
- */
-export declare const make: <Tag extends Context.Tag<any, Bundle.BundleContext>>(tag: Tag) => import("../RouteMount.ts").RouteMount.Builder<{}, [Route.Route.Route<{
-    method: "GET";
-    format: "*";
-}, {}, Uint8Array<ArrayBuffer>, never, any>]>;
-export declare const client: () => import("../RouteMount.ts").RouteMount.Builder<{}, [Route.Route.Route<{
-    method: "GET";
-    format: "*";
-}, {}, Uint8Array<ArrayBuffer>, never, any>]>;
-export declare const layer: (options?: {
-    bundle?: Context.Tag<any, Bundle.BundleContext>;
-    path?: PathPattern.PathPattern;
-}) => Layer.Layer<Route.Routes, never, never>;