effect-start 0.22.0 → 0.23.0

package/dist/Development.js

@@ -1,4 +1,4 @@
-import * as FileSystem from "@effect/platform/FileSystem";
+import * as FileSystem from "./FileSystem.js";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
@@ -28,15 +28,14 @@ export const filterDirectory = (event) => {
 export const watchSource = (opts) => {
     const baseDir = opts?.path ?? process.cwd();
     const customFilter = opts?.filter;
-    return Function.pipe(Stream.unwrap(Effect.map(FileSystem.FileSystem, fs => fs.watch(baseDir, { recursive: opts?.recursive ?? true }))), customFilter ? Stream.filter(customFilter) : Function.identity, Stream.rechunk(1), Stream.throttle({
+    return Function.pipe(Stream.unwrap(Effect.map(FileSystem.FileSystem, (fs) => fs.watch(baseDir, { recursive: opts?.recursive ?? true }))), customFilter ? Stream.filter(customFilter) : Function.identity, Stream.rechunk(1), Stream.throttle({
         units: 1,
         cost: () => 1,
         duration: "400 millis",
         strategy: "enforce",
     }));
 };
-export const watch = (opts) => Effect
-    .gen(function* () {
+export const watch = (opts) => Effect.gen(function* () {
     devState.count++;
     if (devState.count === 1) {
         const pubsub = yield* PubSub.unbounded();

package/dist/Effectify.d.ts

@@ -2,10 +2,7 @@ import * as Effect from "effect/Effect";
 interface Callback<E, A> {
     (err: E, a?: A): void;
 }
-type ArgsWithCallback<Args extends Array<any>, E, A> = [
-    ...args: Args,
-    cb: Callback<E, A>
-];
+type ArgsWithCallback<Args extends Array<any>, E, A> = [...args: Args, cb: Callback<E, A>];
 type WithoutNull<A> = unknown extends A ? void : Exclude<A, null | undefined>;
 type Effectify<T, E> = T extends {
     (...args: ArgsWithCallback<infer Args1, infer _E1, infer A1>): infer _R1;

package/dist/FilePathPattern.d.ts

@@ -17,13 +17,13 @@ export type Segment = {
     _tag: "InvalidSegment";
     value: string;
 };
-export declare function segments(pattern: string): Segment[];
+export declare function segments(pattern: string): Array<Segment>;
 export type ValidationError = {
     _tag: "FilePathPatternError";
     pattern: string;
     message: string;
 };
-export type ValidationResult = Either.Either<Segment[], ValidationError>;
+export type ValidationResult = Either.Either<Array<Segment>, ValidationError>;
 export declare function validate(pattern: string): ValidationResult;
-export declare function format(segs: Segment[]): `/${string}`;
+export declare function format(segs: Array<Segment>): `/${string}`;
 export declare function toPathPattern(pattern: string): Either.Either<PathPattern.PathPattern, ValidationError>;

package/dist/FileRouter.d.ts

@@ -1,4 +1,4 @@
-import * as FileSystem from "@effect/platform/FileSystem";
+import * as FileSystem from "./FileSystem.ts";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as FilePathPattern from "./FilePathPattern.ts";
@@ -20,17 +20,14 @@ export type RouteModule = {
 };
 export type LazyRouteModule = () => Promise<RouteModule>;
 export type FileRoutes = {
-    [path: PathPattern.PathPattern]: [
-        LazyRouteModule,
-        ...LazyRouteModule[]
-    ];
+    [path: PathPattern.PathPattern]: [LazyRouteModule, ...LazyRouteModule[]];
 };
 export type Segment = FilePathPattern.Segment;
 export type FileRoute = {
     handle: "route" | "layer";
     modulePath: `/${string}`;
     routePath: `/${string}`;
-    segments: Segment[];
+    segments: Array<Segment>;
 };
 /**
  * Routes sorted by depth, with rest parameters at the end.
@@ -39,7 +36,7 @@ export type FileRoute = {
  * - users/[userId]/route.tsx
  * - [[rest]]/route.tsx
  */
-export type OrderedFileRoutes = FileRoute[];
+export type OrderedFileRoutes = Array<FileRoute>;
 export declare function parseRoute(path: string): FileRoute | null;
 /**
  * Generates a tree file that references all routes.
@@ -55,5 +52,5 @@ export declare function layer(options: {
 }): Layer.Layer<Route.Routes, FileRouterError, FileSystem.FileSystem>;
 export declare function fromFileRoutes(fileRoutes: FileRoutes): Effect.Effect<RouteTree.RouteTree>;
 export declare function walkRoutesDirectory(dir: string): Effect.Effect<OrderedFileRoutes, PlatformError.PlatformError | FileRouterError, FileSystem.FileSystem>;
-export declare function getFileRoutes(paths: string[]): Effect.Effect<OrderedFileRoutes, FileRouterError>;
+export declare function getFileRoutes(paths: Array<string>): Effect.Effect<OrderedFileRoutes, FileRouterError>;
 export {};

package/dist/FileRouter.js

@@ -1,4 +1,4 @@
-import * as FileSystem from "@effect/platform/FileSystem";
+import * as FileSystem from "./FileSystem.js";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Either from "effect/Either";
@@ -19,8 +19,7 @@ const ROUTE_PATH_REGEX = /^\/?(.*\/?)(?:route|layer)\.(jsx?|tsx?)$/;
 export function parseRoute(path) {
     const segs = FilePathPattern.segments(path);
     const lastSeg = segs.at(-1);
-    const handleMatch = lastSeg?._tag === "LiteralSegment"
-        && lastSeg.value.match(/^(route|layer)\.(tsx?|jsx?)$/);
+    const handleMatch = lastSeg?._tag === "LiteralSegment" && lastSeg.value.match(/^(route|layer)\.(tsx?|jsx?)$/);
     const handle = handleMatch ? handleMatch[1] : null;
     if (!handle) {
         return null;
@@ -73,7 +72,7 @@ export function layer(loadOrOptions) {
         const m = yield* importModule(options.load);
         const routeTree = yield* fromFileRoutes(m.default);
         // Watch for changes (only when Development service is available)
-        yield* Function.pipe(Development.stream(), Stream.filter(e => e._tag !== "Reload" && e.path.startsWith(relativeRoutesPath)), Stream.runForEach(() => FileRouterCodegen.update(routesPath, treeFilename)), Effect.fork);
+        yield* Function.pipe(Development.stream(), Stream.filter((e) => e._tag !== "Reload" && e.path.startsWith(relativeRoutesPath)), Stream.runForEach(() => FileRouterCodegen.update(routesPath, treeFilename)), Effect.fork);
         return routeTree;
     }));
 }
@@ -106,9 +105,9 @@ export function walkRoutesDirectory(dir) {
 export function getFileRoutes(paths) {
     return Effect.gen(function* () {
         const routes = paths
-            .map(f => f.match(ROUTE_PATH_REGEX))
+            .map((f) => f.match(ROUTE_PATH_REGEX))
             .filter(Boolean)
-            .map(v => {
+            .map((v) => {
             const path = v[0];
             try {
                 return parseRoute(path);
@@ -125,11 +124,11 @@ export function getFileRoutes(paths) {
             const bHasRest = b.segments.some((seg) => seg._tag === "RestSegment");
             return (
             // rest is a dominant factor (routes with rest come last)
-            (+aHasRest - +bHasRest) * 1000
+            (+aHasRest - +bHasRest) * 1000 +
                 // depth is reversed for rest
-                + (aDepth - bDepth) * (1 - 2 * +aHasRest)
+                (aDepth - bDepth) * (1 - 2 * +aHasRest) +
                 // lexicographic comparison as tiebreaker
-                + a.modulePath.localeCompare(b.modulePath) * 0.001);
+                a.modulePath.localeCompare(b.modulePath) * 0.001);
         });
         // Detect conflicting routes at the same path
         const routesByPath = new Map();
@@ -139,7 +138,7 @@ export function getFileRoutes(paths) {
             routesByPath.set(route.routePath, existing);
         }
         for (const [path, pathRoutes] of routesByPath) {
-            const routeHandles = pathRoutes.filter(h => h.handle === "route");
+            const routeHandles = pathRoutes.filter((h) => h.handle === "route");
             if (routeHandles.length > 1) {
                 yield* new FileRouterError({ reason: "Conflict", path });
             }

package/dist/FileRouterCodegen.d.ts

@@ -1,4 +1,4 @@
-import * as FileSystem from "@effect/platform/FileSystem";
+import * as FileSystem from "./FileSystem.ts";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 import * as FilePathPattern from "./FilePathPattern.ts";

package/dist/FileRouterCodegen.js

@@ -6,7 +6,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import * as FileSystem from "@effect/platform/FileSystem";
+import * as FileSystem from "./FileSystem.js";
 import * as Effect from "effect/Effect";
 import * as Either from "effect/Either";
 import * as Schema from "effect/Schema";
@@ -45,11 +45,13 @@ export function generatePathParamsSchema(segments) {
 export function validateRouteModules(path, routes) {
     return Effect.gen(function* () {
         const fs = yield* FileSystem.FileSystem;
-        const routeHandles = routes.filter(h => h.handle === "route");
+        const routeHandles = routes.filter((h) => h.handle === "route");
         for (const handle of routeHandles) {
             const routeModulePath = NPath.resolve(path, handle.modulePath);
             const expectedSchema = generatePathParamsSchema(handle.segments);
-            const fileExists = yield* fs.exists(routeModulePath).pipe(Effect.catchAll(() => Effect.succeed(false)));
+            const fileExists = yield* fs
+                .exists(routeModulePath)
+                .pipe(Effect.catchAll(() => Effect.succeed(false)));
             if (!fileExists) {
                 continue;
             }
@@ -68,9 +70,7 @@ export function validateRouteModules(path, routes) {
             const routeSet = module.default;
             // extract user schema
             const userSchema = undefined;
-            if (expectedSchema
-                && userSchema
-                && !SchemaExtra.schemaEqual(userSchema, expectedSchema)) {
+            if (expectedSchema && userSchema && !SchemaExtra.schemaEqual(userSchema, expectedSchema)) {
                 const relativeFilePath = NPath.relative(process.cwd(), routeModulePath);
                 yield* Effect.logError(`Route '${relativeFilePath}' has incorrect PathParams schema, expected schemaPathParams(${SchemaExtra.formatSchemaCode(expectedSchema)})`);
             }
@@ -108,7 +108,7 @@ export function generateCode(fileRoutes) {
         while (true) {
             const pathData = routesByPath.get(currentPath);
             if (pathData?.layers) {
-                const matchingLayers = pathData.layers.filter(layer => layerMatchesRoute(layer, route));
+                const matchingLayers = pathData.layers.filter((layer) => layerMatchesRoute(layer, route));
                 allLayers.unshift(...matchingLayers);
             }
             if (currentPath === "/")
@@ -125,7 +125,7 @@ export function generateCode(fileRoutes) {
         // Order: route first, then layers from innermost to outermost
         const loaders = [
             `() => import(".${route.modulePath}")`,
-            ...allLayers.reverse().map(layer => `() => import(".${layer.modulePath}")`),
+            ...allLayers.reverse().map((layer) => `() => import(".${layer.modulePath}")`),
         ];
         entries.push({ path: pathPattern, loaders });
     }
@@ -156,7 +156,11 @@ export function update(routesPath, treePath = "server.gen.ts") {
     return Effect.gen(function* () {
         treePath = NPath.resolve(routesPath, treePath);
         const fs = yield* FileSystem.FileSystem;
-        const files = yield* fs.readDirectory(routesPath, { recursive: true }).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: routesPath })));
+        const files = yield* fs.readDirectory(routesPath, { recursive: true }).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({
+            reason: "FileSystem",
+            cause,
+            path: routesPath,
+        })));
         const fileRoutes = yield* FileRouter.getFileRoutes(files);
         // Validate route modules
         yield* validateRouteModules(routesPath, fileRoutes);
@@ -172,7 +176,11 @@ export function update(routesPath, treePath = "server.gen.ts") {
                 const emptyCode = "export default {}\n";
                 if (existingCode !== emptyCode) {
                     yield* Effect.logDebug(`Clearing file routes tree: ${treePath}`);
-                    yield* fs.writeFileString(treePath, emptyCode).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: treePath })));
+                    yield* fs.writeFileString(treePath, emptyCode).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({
+                        reason: "FileSystem",
+                        cause,
+                        path: treePath,
+                    })));
                 }
             }
             return;
@@ -180,7 +188,11 @@ export function update(routesPath, treePath = "server.gen.ts") {
         // Write if content differs
         if (existingCode !== newCode) {
             yield* Effect.logDebug(`Updating file routes tree: ${treePath}`);
-            yield* fs.writeFileString(treePath, newCode).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: treePath })));
+            yield* fs.writeFileString(treePath, newCode).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({
+                reason: "FileSystem",
+                cause,
+                path: treePath,
+            })));
         }
         else {
             yield* Effect.logDebug(`File routes tree unchanged: ${treePath}`);
@@ -191,7 +203,11 @@ export function dump(routesPath, treePath = "server.gen.ts") {
     return Effect.gen(function* () {
         treePath = NPath.resolve(routesPath, treePath);
         const fs = yield* FileSystem.FileSystem;
-        const files = yield* fs.readDirectory(routesPath, { recursive: true }).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: routesPath })));
+        const files = yield* fs.readDirectory(routesPath, { recursive: true }).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({
+            reason: "FileSystem",
+            cause,
+            path: routesPath,
+        })));
         const fileRoutes = yield* FileRouter.getFileRoutes(files);
         // Validate route modules
         yield* validateRouteModules(routesPath, fileRoutes);
@@ -202,6 +218,10 @@ export function dump(routesPath, treePath = "server.gen.ts") {
             return;
         }
         yield* Effect.logDebug(`Generating file routes tree: ${treePath}`);
-        yield* fs.writeFileString(treePath, code).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: treePath })));
+        yield* fs.writeFileString(treePath, code).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({
+            reason: "FileSystem",
+            cause,
+            path: treePath,
+        })));
     });
 }

package/dist/FileSystem.d.ts

@@ -0,0 +1,158 @@
+import * as Brand from "effect/Brand";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Sink from "effect/Sink";
+import type * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+import * as PlatformError from "./PlatformError.ts";
+export interface FileSystem {
+    readonly access: (path: string, options?: AccessFileOptions) => Effect.Effect<void, PlatformError.PlatformError>;
+    readonly copy: (fromPath: string, toPath: string, options?: CopyOptions) => Effect.Effect<void, PlatformError.PlatformError>;
+    readonly copyFile: (fromPath: string, toPath: string) => Effect.Effect<void, PlatformError.PlatformError>;
+    readonly chmod: (path: string, mode: number) => Effect.Effect<void, PlatformError.PlatformError>;
+    readonly chown: (path: string, uid: number, gid: number) => Effect.Effect<void, PlatformError.PlatformError>;
+    readonly exists: (path: string) => Effect.Effect<boolean, PlatformError.PlatformError>;
+    readonly link: (fromPath: string, toPath: string) => Effect.Effect<void, PlatformError.PlatformError>;
+    readonly makeDirectory: (path: string, options?: MakeDirectoryOptions) => Effect.Effect<void, PlatformError.PlatformError>;
+    readonly makeTempDirectory: (options?: MakeTempDirectoryOptions) => Effect.Effect<string, PlatformError.PlatformError>;
+    readonly makeTempDirectoryScoped: (options?: MakeTempDirectoryOptions) => Effect.Effect<string, PlatformError.PlatformError, Scope.Scope>;
+    readonly makeTempFile: (options?: MakeTempFileOptions) => Effect.Effect<string, PlatformError.PlatformError>;
+    readonly makeTempFileScoped: (options?: MakeTempFileOptions) => Effect.Effect<string, PlatformError.PlatformError, Scope.Scope>;
+    readonly open: (path: string, options?: OpenFileOptions) => Effect.Effect<File, PlatformError.PlatformError, Scope.Scope>;
+    readonly readDirectory: (path: string, options?: ReadDirectoryOptions) => Effect.Effect<Array<string>, PlatformError.PlatformError>;
+    readonly readFile: (path: string) => Effect.Effect<Uint8Array, PlatformError.PlatformError>;
+    readonly readFileString: (path: string, encoding?: string) => Effect.Effect<string, PlatformError.PlatformError>;
+    readonly readLink: (path: string) => Effect.Effect<string, PlatformError.PlatformError>;
+    readonly realPath: (path: string) => Effect.Effect<string, PlatformError.PlatformError>;
+    readonly remove: (path: string, options?: RemoveOptions) => Effect.Effect<void, PlatformError.PlatformError>;
+    readonly rename: (oldPath: string, newPath: string) => Effect.Effect<void, PlatformError.PlatformError>;
+    readonly sink: (path: string, options?: SinkOptions) => Sink.Sink<void, Uint8Array, never, PlatformError.PlatformError>;
+    readonly stat: (path: string) => Effect.Effect<File.Info, PlatformError.PlatformError>;
+    readonly stream: (path: string, options?: StreamOptions) => Stream.Stream<Uint8Array, PlatformError.PlatformError>;
+    readonly symlink: (fromPath: string, toPath: string) => Effect.Effect<void, PlatformError.PlatformError>;
+    readonly truncate: (path: string, length?: SizeInput) => Effect.Effect<void, PlatformError.PlatformError>;
+    readonly utimes: (path: string, atime: Date | number, mtime: Date | number) => Effect.Effect<void, PlatformError.PlatformError>;
+    readonly watch: (path: string, options?: WatchOptions) => Stream.Stream<WatchEvent, PlatformError.PlatformError>;
+    readonly writeFile: (path: string, data: Uint8Array, options?: WriteFileOptions) => Effect.Effect<void, PlatformError.PlatformError>;
+    readonly writeFileString: (path: string, data: string, options?: WriteFileStringOptions) => Effect.Effect<void, PlatformError.PlatformError>;
+}
+export declare const FileSystem: Context.Tag<FileSystem, FileSystem>;
+export type Size = Brand.Branded<bigint, "Size">;
+export type SizeInput = bigint | number | Size;
+export declare const Size: (bytes: SizeInput) => Size;
+export type OpenFlag = "r" | "r+" | "w" | "wx" | "w+" | "wx+" | "a" | "ax" | "a+" | "ax+";
+export type SeekMode = "start" | "current";
+export interface AccessFileOptions {
+    readonly ok?: boolean;
+    readonly readable?: boolean;
+    readonly writable?: boolean;
+}
+export interface MakeDirectoryOptions {
+    readonly recursive?: boolean;
+    readonly mode?: number;
+}
+export interface CopyOptions {
+    readonly overwrite?: boolean;
+    readonly preserveTimestamps?: boolean;
+}
+export interface MakeTempDirectoryOptions {
+    readonly directory?: string;
+    readonly prefix?: string;
+}
+export interface MakeTempFileOptions {
+    readonly directory?: string;
+    readonly prefix?: string;
+    readonly suffix?: string;
+}
+export interface OpenFileOptions {
+    readonly flag?: OpenFlag;
+    readonly mode?: number;
+}
+export interface ReadDirectoryOptions {
+    readonly recursive?: boolean;
+}
+export interface RemoveOptions {
+    readonly recursive?: boolean;
+    readonly force?: boolean;
+}
+export interface SinkOptions extends OpenFileOptions {
+}
+export interface StreamOptions {
+    readonly bufferSize?: number;
+    readonly bytesToRead?: SizeInput;
+    readonly chunkSize?: SizeInput;
+    readonly offset?: SizeInput;
+}
+export interface WriteFileOptions {
+    readonly flag?: OpenFlag;
+    readonly mode?: number;
+}
+export interface WriteFileStringOptions {
+    readonly flag?: OpenFlag;
+    readonly mode?: number;
+}
+export interface WatchOptions {
+    readonly recursive?: boolean;
+}
+export declare const FileTypeId: unique symbol;
+export type FileTypeId = typeof FileTypeId;
+export interface File {
+    readonly [FileTypeId]: FileTypeId;
+    readonly fd: File.Descriptor;
+    readonly stat: Effect.Effect<File.Info, PlatformError.PlatformError>;
+    readonly seek: (offset: SizeInput, from: SeekMode) => Effect.Effect<void>;
+    readonly sync: Effect.Effect<void, PlatformError.PlatformError>;
+    readonly read: (buffer: Uint8Array) => Effect.Effect<Size, PlatformError.PlatformError>;
+    readonly readAlloc: (size: SizeInput) => Effect.Effect<Option.Option<Uint8Array>, PlatformError.PlatformError>;
+    readonly truncate: (length?: SizeInput) => Effect.Effect<void, PlatformError.PlatformError>;
+    readonly write: (buffer: Uint8Array) => Effect.Effect<Size, PlatformError.PlatformError>;
+    readonly writeAll: (buffer: Uint8Array) => Effect.Effect<void, PlatformError.PlatformError>;
+}
+export declare namespace File {
+    type Descriptor = Brand.Branded<number, "FileDescriptor">;
+    type Type = "File" | "Directory" | "SymbolicLink" | "BlockDevice" | "CharacterDevice" | "FIFO" | "Socket" | "Unknown";
+    interface Info {
+        readonly type: Type;
+        readonly mtime: Option.Option<Date>;
+        readonly atime: Option.Option<Date>;
+        readonly birthtime: Option.Option<Date>;
+        readonly dev: number;
+        readonly ino: Option.Option<number>;
+        readonly mode: number;
+        readonly nlink: Option.Option<number>;
+        readonly uid: Option.Option<number>;
+        readonly gid: Option.Option<number>;
+        readonly rdev: Option.Option<number>;
+        readonly size: Size;
+        readonly blksize: Option.Option<Size>;
+        readonly blocks: Option.Option<number>;
+    }
+}
+export declare const FileDescriptor: Brand.Brand.Constructor<File.Descriptor>;
+export type WatchEvent = WatchEvent.Create | WatchEvent.Update | WatchEvent.Remove;
+export declare namespace WatchEvent {
+    interface Create {
+        readonly _tag: "Create";
+        readonly path: string;
+    }
+    interface Update {
+        readonly _tag: "Update";
+        readonly path: string;
+    }
+    interface Remove {
+        readonly _tag: "Remove";
+        readonly path: string;
+    }
+}
+export declare const WatchEventCreate: Data.Case.Constructor<WatchEvent.Create, "_tag">;
+export declare const WatchEventUpdate: Data.Case.Constructor<WatchEvent.Update, "_tag">;
+export declare const WatchEventRemove: Data.Case.Constructor<WatchEvent.Remove, "_tag">;
+declare const WatchBackend_base: Context.TagClass<WatchBackend, "@effect/platform/FileSystem/WatchBackend", {
+    readonly register: (path: string, stat: File.Info, options?: WatchOptions) => Option.Option<Stream.Stream<WatchEvent, PlatformError.PlatformError>>;
+}>;
+export declare class WatchBackend extends WatchBackend_base {
+}
+export declare const make: (impl: Omit<FileSystem, "exists" | "readFileString" | "stream" | "sink" | "writeFileString">) => FileSystem;
+export {};

package/dist/FileSystem.js

@@ -1,131 +1,70 @@
 /*
  * Adapted from @effect/platform
  */
-import * as Brand from "effect/Brand"
-import * as Channel from "effect/Channel"
-import * as Chunk from "effect/Chunk"
-import * as Context from "effect/Context"
-import * as Data from "effect/Data"
-import * as Effect from "effect/Effect"
-import * as Function from "effect/Function"
-import * as Option from "effect/Option"
-import * as Sink from "effect/Sink"
-import * as Stream from "effect/Stream"
-import * as PlatformError from "./PlatformError.js"
-
-export const FileSystem = Context.GenericTag(
-  "@effect/platform/FileSystem",
-)
-
-export const Size = (bytes) =>
-  typeof bytes === "bigint" ? bytes : BigInt(bytes)
-
-export const FileTypeId = Symbol.for("@effect/platform/FileSystem/File")
-
-export const FileDescriptor = Brand.nominal()
-
-export const WatchEventCreate = Data.tagged(
-  "Create",
-)
-
-export const WatchEventUpdate = Data.tagged(
-  "Update",
-)
-
-export const WatchEventRemove = Data.tagged(
-  "Remove",
-)
-
-export class WatchBackend extends Context.Tag("@effect/platform/FileSystem/WatchBackend")() {}
-
-export const make = (
-  impl,
-) => {
-  return FileSystem.of({
-    ...impl,
-    exists: (path) =>
-      Function.pipe(
-        impl.access(path),
-        Effect.as(true),
-        Effect.catchTag("SystemError", (e) => e.reason === "NotFound" ? Effect.succeed(false) : Effect.fail(e)),
-      ),
-    readFileString: (path, encoding) =>
-      Effect.tryMap(impl.readFile(path), {
-        try: (_) => new TextDecoder(encoding).decode(_),
-        catch: (cause) =>
-          new PlatformError.BadArgument({
-            module: "FileSystem",
-            method: "readFileString",
-            description: "invalid encoding",
-            cause,
-          }),
-      }),
-    stream: (path, options) =>
-      Function.pipe(
-        impl.open(path, { flag: "r" }),
-        options?.offset
-          ? Effect.tap((file) => file.seek(options.offset, "start"))
-          : Function.identity,
-        Effect.map((file) => fileStream(file, options)),
-        Stream.unwrapScoped,
-      ),
-    sink: (path, options) =>
-      Function.pipe(
-        impl.open(path, { flag: "w", ...options }),
-        Effect.map((file) => Sink.forEach((_) => file.writeAll(_))),
-        Sink.unwrapScoped,
-      ),
-    writeFileString: (path, data, options) =>
-      Effect.flatMap(
-        Effect.try({
-          try: () => new TextEncoder().encode(data),
-          catch: (cause) =>
-            new PlatformError.BadArgument({
-              module: "FileSystem",
-              method: "writeFileString",
-              description: "could not encode string",
-              cause,
+import * as Brand from "effect/Brand";
+import * as Channel from "effect/Channel";
+import * as Chunk from "effect/Chunk";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Sink from "effect/Sink";
+import * as Stream from "effect/Stream";
+import * as PlatformError from "./PlatformError.js";
+export const FileSystem = Context.GenericTag("@effect/platform/FileSystem");
+export const Size = (bytes) => typeof bytes === "bigint" ? bytes : BigInt(bytes);
+export const FileTypeId = Symbol.for("@effect/platform/FileSystem/File");
+export const FileDescriptor = Brand.nominal();
+export const WatchEventCreate = Data.tagged("Create");
+export const WatchEventUpdate = Data.tagged("Update");
+export const WatchEventRemove = Data.tagged("Remove");
+export class WatchBackend extends Context.Tag("@effect/platform/FileSystem/WatchBackend")() {
+}
+export const make = (impl) => {
+    return FileSystem.of({
+        ...impl,
+        exists: (path) => Function.pipe(impl.access(path), Effect.as(true), Effect.catchTag("SystemError", (e) => e.reason === "NotFound" ? Effect.succeed(false) : Effect.fail(e))),
+        readFileString: (path, encoding) => Effect.tryMap(impl.readFile(path), {
+            try: (_) => new TextDecoder(encoding).decode(_),
+            catch: (cause) => new PlatformError.BadArgument({
+                module: "FileSystem",
+                method: "readFileString",
+                description: "invalid encoding",
+                cause,
             }),
         }),
-        (_) => impl.writeFile(path, _, options),
-      ),
-  })
-}
-
-const fileStream = (file, {
-  bufferSize = 16,
-  bytesToRead: bytesToRead_,
-  chunkSize: chunkSize_ = Size(64 * 1024),
-} = {}) => {
-  const bytesToRead = bytesToRead_ !== undefined ? Size(bytesToRead_) : undefined
-  const chunkSize = Size(chunkSize_)
-
-  function loop(
-    totalBytesRead,
-  ) {
-    if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
-      return Channel.void
+        stream: (path, options) => Function.pipe(impl.open(path, { flag: "r" }), options?.offset
+            ? Effect.tap((file) => file.seek(options.offset, "start"))
+            : Function.identity, Effect.map((file) => fileStream(file, options)), Stream.unwrapScoped),
+        sink: (path, options) => Function.pipe(impl.open(path, { flag: "w", ...options }), Effect.map((file) => Sink.forEach((_) => file.writeAll(_))), Sink.unwrapScoped),
+        writeFileString: (path, data, options) => Effect.flatMap(Effect.try({
+            try: () => new TextEncoder().encode(data),
+            catch: (cause) => new PlatformError.BadArgument({
+                module: "FileSystem",
+                method: "writeFileString",
+                description: "could not encode string",
+                cause,
+            }),
+        }), (_) => impl.writeFile(path, _, options)),
+    });
+};
+const fileStream = (file, { bufferSize = 16, bytesToRead: bytesToRead_, chunkSize: chunkSize_ = Size(64 * 1024), } = {}) => {
+    const bytesToRead = bytesToRead_ !== undefined ? Size(bytesToRead_) : undefined;
+    const chunkSize = Size(chunkSize_);
+    function loop(totalBytesRead) {
+        if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
+            return Channel.void;
+        }
+        const toRead = bytesToRead !== undefined && bytesToRead - totalBytesRead < chunkSize
+            ? bytesToRead - totalBytesRead
+            : chunkSize;
+        return Channel.flatMap(file.readAlloc(toRead), Option.match({
+            onNone: () => Channel.void,
+            onSome: (buf) => Channel.flatMap(Channel.write(Chunk.of(buf)), () => loop(totalBytesRead + BigInt(buf.length))),
+        }));
     }
-
-    const toRead = bytesToRead !== undefined && (bytesToRead - totalBytesRead) < chunkSize
-      ? bytesToRead - totalBytesRead
-      : chunkSize
-
-    return Channel.flatMap(
-      file.readAlloc(toRead),
-      Option.match({
-        onNone: () => Channel.void,
-        onSome: (buf) =>
-          Channel.flatMap(
-            Channel.write(Chunk.of(buf)),
-            () => loop(totalBytesRead + BigInt(buf.length)),
-          ),
-      }),
-    )
-  }
-
-  return Stream.bufferChunks(
-    Stream.fromChannel(loop(BigInt(0))),
-    { capacity: bufferSize },
-  )
-}
+    return Stream.bufferChunks(Stream.fromChannel(loop(BigInt(0))), {
+        capacity: bufferSize,
+    });
+};

package/dist/Http.js

@@ -1,8 +1,6 @@
 import * as Values from "./Values.js";
 export function fetch(handler, init) {
-    const url = "path" in init
-        ? `http://localhost${init.path}`
-        : init.url;
+    const url = "path" in init ? `http://localhost${init.path}` : init.url;
     const isPlain = Values.isPlainObject(init.body);
     const headers = new Headers(init.headers);
     if (isPlain && !headers.has("Content-Type")) {
@@ -17,9 +15,7 @@ export function fetch(handler, init) {
     return Promise.resolve(handler(request));
 }
 export function createAbortableRequest(init) {
-    const url = "path" in init
-        ? `http://localhost${init.path}`
-        : init.url;
+    const url = "path" in init ? `http://localhost${init.path}` : init.url;
     const controller = new AbortController();
     const request = new Request(url, { ...init, signal: controller.signal });
     return { request, abort: () => controller.abort() };