@react-router/node 0.0.0-experimental-f7761f1cd → 0.0.0-experimental-63fd291ad

package/dist/index.d.mts

@@ -0,0 +1,48 @@
+import { RequestListener } from 'node:http';
+import { ServerBuild, UNSAFE_MiddlewareEnabled, RouterContextProvider, AppLoadContext, SessionData, SessionIdStorageStrategy, SessionStorage } from 'react-router';
+import { ClientAddress } from '@mjackson/node-fetch-server';
+import { Readable, Writable } from 'node:stream';
+
+type MaybePromise<T> = T | Promise<T>;
+interface RequestListenerOptions {
+    build: ServerBuild | (() => ServerBuild | Promise<ServerBuild>);
+    getLoadContext?: (request: Request, client: ClientAddress) => UNSAFE_MiddlewareEnabled extends true ? MaybePromise<RouterContextProvider> : MaybePromise<AppLoadContext>;
+    mode?: string;
+}
+/**
+ * Creates a request listener that handles requests using Node's built-in HTTP server.
+ *
+ * @param options Options for creating a request listener.
+ * @returns A request listener that can be used with `http.createServer`.
+ */
+declare function createRequestListener(options: RequestListenerOptions): RequestListener;
+
+interface FileSessionStorageOptions {
+    /**
+     * The Cookie used to store the session id on the client, or options used
+     * to automatically create one.
+     */
+    cookie?: SessionIdStorageStrategy["cookie"];
+    /**
+     * The directory to use to store session files.
+     */
+    dir: string;
+}
+/**
+ * Creates a SessionStorage that stores session data on a filesystem.
+ *
+ * The advantage of using this instead of cookie session storage is that
+ * files may contain much more data than cookies.
+ *
+ * @see https://api.reactrouter.com/v7/functions/_react-router_node.createFileSessionStorage
+ */
+declare function createFileSessionStorage<Data = SessionData, FlashData = Data>({ cookie, dir, }: FileSessionStorageOptions): SessionStorage<Data, FlashData>;
+
+declare function writeReadableStreamToWritable(stream: ReadableStream, writable: Writable): Promise<void>;
+declare function writeAsyncIterableToWritable(iterable: AsyncIterable<Uint8Array>, writable: Writable): Promise<void>;
+declare function readableStreamToString(stream: ReadableStream<Uint8Array>, encoding?: BufferEncoding): Promise<string>;
+declare const createReadableStreamFromReadable: (source: Readable & {
+    readableHighWaterMark?: number;
+}) => ReadableStream<Uint8Array>;
+
+export { type RequestListenerOptions, createFileSessionStorage, createReadableStreamFromReadable, createRequestListener, readableStreamToString, writeAsyncIterableToWritable, writeReadableStreamToWritable };

package/dist/index.d.ts

@@ -1,15 +1,13 @@
+import { RequestListener } from 'node:http';
+import { ServerBuild, UNSAFE_MiddlewareEnabled, RouterContextProvider, AppLoadContext, SessionData, SessionIdStorageStrategy, SessionStorage } from 'react-router';
+import { ClientAddress } from '@mjackson/node-fetch-server';
+import { Readable, Writable } from 'node:stream';
 
-import { ClientAddress } from "@remix-run/node-fetch-server";
-import { RouterContextProvider, ServerBuild, SessionData, SessionIdStorageStrategy, SessionStorage } from "react-router";
-import { Readable, Writable } from "node:stream";
-import { RequestListener } from "node:http";
-
-//#region server.d.ts
 type MaybePromise<T> = T | Promise<T>;
 interface RequestListenerOptions {
-  build: ServerBuild | (() => ServerBuild | Promise<ServerBuild>);
-  getLoadContext?: (request: Request, client: ClientAddress) => MaybePromise<RouterContextProvider>;
-  mode?: string;
+    build: ServerBuild | (() => ServerBuild | Promise<ServerBuild>);
+    getLoadContext?: (request: Request, client: ClientAddress) => UNSAFE_MiddlewareEnabled extends true ? MaybePromise<RouterContextProvider> : MaybePromise<AppLoadContext>;
+    mode?: string;
 }
 /**
  * Creates a request listener that handles requests using Node's built-in HTTP server.
@@ -18,18 +16,17 @@ interface RequestListenerOptions {
  * @returns A request listener that can be used with `http.createServer`.
  */
 declare function createRequestListener(options: RequestListenerOptions): RequestListener;
-//#endregion
-//#region sessions/fileStorage.d.ts
+
 interface FileSessionStorageOptions {
-  /**
-   * The Cookie used to store the session id on the client, or options used
-   * to automatically create one.
-   */
-  cookie?: SessionIdStorageStrategy["cookie"];
-  /**
-   * The directory to use to store session files.
-   */
-  dir: string;
+    /**
+     * The Cookie used to store the session id on the client, or options used
+     * to automatically create one.
+     */
+    cookie?: SessionIdStorageStrategy["cookie"];
+    /**
+     * The directory to use to store session files.
+     */
+    dir: string;
 }
 /**
  * Creates a SessionStorage that stores session data on a filesystem.
@@ -39,17 +36,13 @@ interface FileSessionStorageOptions {
  *
  * @see https://api.reactrouter.com/v7/functions/_react-router_node.createFileSessionStorage
  */
-declare function createFileSessionStorage<Data = SessionData, FlashData = Data>({
-  cookie,
-  dir
-}: FileSessionStorageOptions): SessionStorage<Data, FlashData>;
-//#endregion
-//#region stream.d.ts
+declare function createFileSessionStorage<Data = SessionData, FlashData = Data>({ cookie, dir, }: FileSessionStorageOptions): SessionStorage<Data, FlashData>;
+
 declare function writeReadableStreamToWritable(stream: ReadableStream, writable: Writable): Promise<void>;
 declare function writeAsyncIterableToWritable(iterable: AsyncIterable<Uint8Array>, writable: Writable): Promise<void>;
 declare function readableStreamToString(stream: ReadableStream<Uint8Array>, encoding?: BufferEncoding): Promise<string>;
 declare const createReadableStreamFromReadable: (source: Readable & {
-  readableHighWaterMark?: number;
-}) => ReadableStream<Uint8Array<ArrayBufferLike>>;
-//#endregion
-export { type RequestListenerOptions, createFileSessionStorage, createReadableStreamFromReadable, createRequestListener, readableStreamToString, writeAsyncIterableToWritable, writeReadableStreamToWritable };
+    readableHighWaterMark?: number;
+}) => ReadableStream<Uint8Array>;
+
+export { type RequestListenerOptions, createFileSessionStorage, createReadableStreamFromReadable, createRequestListener, readableStreamToString, writeAsyncIterableToWritable, writeReadableStreamToWritable };

package/dist/index.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/node v0.0.0-experimental-f7761f1cd
+ * @react-router/node v0.0.0-experimental-63fd291ad
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -8,286 +8,371 @@
  *
  * @license MIT
  */
-import { createRequestListener as createRequestListener$1 } from "@remix-run/node-fetch-server";
-import { createRequestHandler, createSessionStorage } from "react-router";
-import { promises } from "node:fs";
-import * as path from "node:path";
-import { Stream } from "node:stream";
-//#region server.ts
-/**
-* Creates a request listener that handles requests using Node's built-in HTTP server.
-*
-* @param options Options for creating a request listener.
-* @returns A request listener that can be used with `http.createServer`.
-*/
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  createFileSessionStorage: () => createFileSessionStorage,
+  createReadableStreamFromReadable: () => createReadableStreamFromReadable,
+  createRequestListener: () => createRequestListener,
+  readableStreamToString: () => readableStreamToString,
+  writeAsyncIterableToWritable: () => writeAsyncIterableToWritable,
+  writeReadableStreamToWritable: () => writeReadableStreamToWritable
+});
+module.exports = __toCommonJS(index_exports);
+
+// server.ts
+var import_react_router = require("react-router");
+var import_node_fetch_server = require("@mjackson/node-fetch-server");
 function createRequestListener(options) {
-	let handleRequest = createRequestHandler(options.build, options.mode);
-	return createRequestListener$1(async (request, client) => {
-		return handleRequest(request, await options.getLoadContext?.(request, client));
-	});
+  let handleRequest = (0, import_react_router.createRequestHandler)(options.build, options.mode);
+  return (0, import_node_fetch_server.createRequestListener)(async (request, client) => {
+    let loadContext = await options.getLoadContext?.(request, client);
+    return handleRequest(request, loadContext);
+  });
 }
-//#endregion
-//#region sessions/fileStorage.ts
-/**
-* Creates a SessionStorage that stores session data on a filesystem.
-*
-* The advantage of using this instead of cookie session storage is that
-* files may contain much more data than cookies.
-*
-* @see https://api.reactrouter.com/v7/functions/_react-router_node.createFileSessionStorage
-*/
-function createFileSessionStorage({ cookie, dir }) {
-	return createSessionStorage({
-		cookie,
-		async createData(data, expires) {
-			let content = JSON.stringify({
-				data,
-				expires
-			});
-			while (true) {
-				let randomBytes = crypto.getRandomValues(new Uint8Array(8));
-				let id = Buffer.from(randomBytes).toString("hex");
-				try {
-					let file = getFile(dir, id);
-					if (!file) throw new Error("Error generating session");
-					await promises.mkdir(path.dirname(file), { recursive: true });
-					await promises.writeFile(file, content, {
-						encoding: "utf-8",
-						flag: "wx"
-					});
-					return id;
-				} catch (error) {
-					if (error.code !== "EEXIST") throw error;
-				}
-			}
-		},
-		async readData(id) {
-			try {
-				let file = getFile(dir, id);
-				if (!file) return null;
-				let content = JSON.parse(await promises.readFile(file, "utf-8"));
-				let data = content.data;
-				let expires = typeof content.expires === "string" ? new Date(content.expires) : null;
-				if (!expires || expires > /* @__PURE__ */ new Date()) return data;
-				if (expires) await promises.unlink(file);
-				return null;
-			} catch (error) {
-				if (error.code !== "ENOENT") throw error;
-				return null;
-			}
-		},
-		async updateData(id, data, expires) {
-			let content = JSON.stringify({
-				data,
-				expires
-			});
-			let file = getFile(dir, id);
-			if (!file) return;
-			await promises.mkdir(path.dirname(file), { recursive: true });
-			await promises.writeFile(file, content, "utf-8");
-		},
-		async deleteData(id) {
-			if (!id) return;
-			let file = getFile(dir, id);
-			if (!file) return;
-			try {
-				await promises.unlink(file);
-			} catch (error) {
-				if (error.code !== "ENOENT") throw error;
-			}
-		}
-	});
+
+// sessions/fileStorage.ts
+var import_node_fs = require("fs");
+var path = __toESM(require("path"));
+var import_react_router2 = require("react-router");
+function createFileSessionStorage({
+  cookie,
+  dir
+}) {
+  return (0, import_react_router2.createSessionStorage)({
+    cookie,
+    async createData(data, expires) {
+      let content = JSON.stringify({ data, expires });
+      while (true) {
+        let randomBytes = crypto.getRandomValues(new Uint8Array(8));
+        let id = Buffer.from(randomBytes).toString("hex");
+        try {
+          let file = getFile(dir, id);
+          if (!file) {
+            throw new Error("Error generating session");
+          }
+          await import_node_fs.promises.mkdir(path.dirname(file), { recursive: true });
+          await import_node_fs.promises.writeFile(file, content, { encoding: "utf-8", flag: "wx" });
+          return id;
+        } catch (error) {
+          if (error.code !== "EEXIST") throw error;
+        }
+      }
+    },
+    async readData(id) {
+      try {
+        let file = getFile(dir, id);
+        if (!file) {
+          return null;
+        }
+        let content = JSON.parse(await import_node_fs.promises.readFile(file, "utf-8"));
+        let data = content.data;
+        let expires = typeof content.expires === "string" ? new Date(content.expires) : null;
+        if (!expires || expires > /* @__PURE__ */ new Date()) {
+          return data;
+        }
+        if (expires) await import_node_fs.promises.unlink(file);
+        return null;
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+        return null;
+      }
+    },
+    async updateData(id, data, expires) {
+      let content = JSON.stringify({ data, expires });
+      let file = getFile(dir, id);
+      if (!file) {
+        return;
+      }
+      await import_node_fs.promises.mkdir(path.dirname(file), { recursive: true });
+      await import_node_fs.promises.writeFile(file, content, "utf-8");
+    },
+    async deleteData(id) {
+      if (!id) {
+        return;
+      }
+      let file = getFile(dir, id);
+      if (!file) {
+        return;
+      }
+      try {
+        await import_node_fs.promises.unlink(file);
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+    }
+  });
 }
 function getFile(dir, id) {
-	if (!/^[0-9a-f]{16}$/i.test(id)) return null;
-	return path.join(dir, id.slice(0, 4), id.slice(4));
+  if (!/^[0-9a-f]{16}$/i.test(id)) {
+    return null;
+  }
+  return path.join(dir, id.slice(0, 4), id.slice(4));
 }
-//#endregion
-//#region stream.ts
+
+// stream.ts
+var import_node_stream = require("stream");
 async function writeReadableStreamToWritable(stream, writable) {
-	let reader = stream.getReader();
-	let flushable = writable;
-	let writableError = monitorWritableError(writable);
-	try {
-		while (true) {
-			writableError.throwIfClosed();
-			let { done, value } = await writableError.race(reader.read());
-			if (done) {
-				writable.end();
-				break;
-			}
-			writableError.throwIfClosed();
-			let canContinueWriting = writable.write(value);
-			if (typeof flushable.flush === "function") flushable.flush();
-			if (!canContinueWriting) await waitForDrain(writable, writableError);
-		}
-	} catch (error) {
-		try {
-			reader.cancel(error).catch(() => {});
-		} catch {}
-		writable.destroy(error);
-		throw error;
-	} finally {
-		writableError.cleanup();
-		try {
-			reader.releaseLock();
-		} catch {}
-	}
+  let reader = stream.getReader();
+  let flushable = writable;
+  let writableError = monitorWritableError(writable);
+  try {
+    while (true) {
+      writableError.throwIfClosed();
+      let { done, value } = await writableError.race(reader.read());
+      if (done) {
+        writable.end();
+        break;
+      }
+      writableError.throwIfClosed();
+      let canContinueWriting = writable.write(value);
+      if (typeof flushable.flush === "function") {
+        flushable.flush();
+      }
+      if (!canContinueWriting) {
+        await waitForDrain(writable, writableError);
+      }
+    }
+  } catch (error) {
+    try {
+      reader.cancel(error).catch(() => {
+      });
+    } catch {
+    }
+    writable.destroy(error);
+    throw error;
+  } finally {
+    writableError.cleanup();
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
 }
 function monitorWritableError(writable) {
-	let settled = false;
-	let writableError;
-	let rejectWritableError;
-	let writableErrorPromise = new Promise((_, reject) => {
-		rejectWritableError = reject;
-	});
-	writableErrorPromise.catch(() => {});
-	function cleanup() {
-		writable.off("error", onError);
-		writable.off("close", onClose);
-	}
-	function reject(error) {
-		if (settled) return;
-		settled = true;
-		writableError = error;
-		cleanup();
-		rejectWritableError(error);
-	}
-	function onError(error) {
-		reject(error);
-	}
-	function onClose() {
-		reject(/* @__PURE__ */ new Error("Writable closed before stream finished"));
-	}
-	writable.once("error", onError);
-	writable.once("close", onClose);
-	return {
-		cleanup,
-		race(promise) {
-			return Promise.race([promise, writableErrorPromise]);
-		},
-		throwIfClosed() {
-			if (writableError) throw writableError;
-			if (writable.destroyed || writable.writableEnded) throw new Error("Cannot write to a destroyed or ended writable stream");
-		}
-	};
+  let settled = false;
+  let writableError;
+  let rejectWritableError;
+  let writableErrorPromise = new Promise((_, reject2) => {
+    rejectWritableError = reject2;
+  });
+  writableErrorPromise.catch(() => {
+  });
+  function cleanup() {
+    writable.off("error", onError);
+    writable.off("close", onClose);
+  }
+  function reject(error) {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    writableError = error;
+    cleanup();
+    rejectWritableError(error);
+  }
+  function onError(error) {
+    reject(error);
+  }
+  function onClose() {
+    reject(new Error("Writable closed before stream finished"));
+  }
+  writable.once("error", onError);
+  writable.once("close", onClose);
+  return {
+    cleanup,
+    race(promise) {
+      return Promise.race([promise, writableErrorPromise]);
+    },
+    throwIfClosed() {
+      if (writableError) {
+        throw writableError;
+      }
+      if (writable.destroyed || writable.writableEnded) {
+        throw new Error("Cannot write to a destroyed or ended writable stream");
+      }
+    }
+  };
 }
 function waitForDrain(writable, writableError) {
-	let cleanup = () => {};
-	let drainPromise = new Promise((resolve) => {
-		function onDrain() {
-			cleanup();
-			resolve();
-		}
-		cleanup = function cleanup() {
-			writable.off("drain", onDrain);
-		};
-		writable.once("drain", onDrain);
-	});
-	return writableError.race(drainPromise).finally(cleanup);
+  let cleanup = () => {
+  };
+  let drainPromise = new Promise((resolve) => {
+    function onDrain() {
+      cleanup();
+      resolve();
+    }
+    cleanup = function cleanup2() {
+      writable.off("drain", onDrain);
+    };
+    writable.once("drain", onDrain);
+  });
+  return writableError.race(drainPromise).finally(cleanup);
 }
 async function writeAsyncIterableToWritable(iterable, writable) {
-	let writableError = monitorWritableError(writable);
-	let iterator = iterable[Symbol.asyncIterator]();
-	let completed = false;
-	try {
-		while (true) {
-			writableError.throwIfClosed();
-			let { done, value: chunk } = await writableError.race(iterator.next());
-			if (done) {
-				completed = true;
-				break;
-			}
-			writableError.throwIfClosed();
-			if (!writable.write(chunk)) await waitForDrain(writable, writableError);
-		}
-		writable.end();
-	} catch (error) {
-		if (!completed) try {
-			Promise.resolve(iterator.return?.()).catch(() => {});
-		} catch {}
-		writable.destroy(error);
-		throw error;
-	} finally {
-		writableError.cleanup();
-	}
+  let writableError = monitorWritableError(writable);
+  let iterator = iterable[Symbol.asyncIterator]();
+  let completed = false;
+  try {
+    while (true) {
+      writableError.throwIfClosed();
+      let { done, value: chunk } = await writableError.race(iterator.next());
+      if (done) {
+        completed = true;
+        break;
+      }
+      writableError.throwIfClosed();
+      let canContinueWriting = writable.write(chunk);
+      if (!canContinueWriting) {
+        await waitForDrain(writable, writableError);
+      }
+    }
+    writable.end();
+  } catch (error) {
+    if (!completed) {
+      try {
+        Promise.resolve(iterator.return?.()).catch(() => {
+        });
+      } catch {
+      }
+    }
+    writable.destroy(error);
+    throw error;
+  } finally {
+    writableError.cleanup();
+  }
 }
 async function readableStreamToString(stream, encoding) {
-	let reader = stream.getReader();
-	let chunks = [];
-	while (true) {
-		let { done, value } = await reader.read();
-		if (done) break;
-		if (value) chunks.push(value);
-	}
-	return Buffer.concat(chunks).toString(encoding);
+  let reader = stream.getReader();
+  let chunks = [];
+  while (true) {
+    let { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    if (value) {
+      chunks.push(value);
+    }
+  }
+  return Buffer.concat(chunks).toString(encoding);
 }
-const createReadableStreamFromReadable = (source) => {
-	let pump = new StreamPump(source);
-	return new ReadableStream(pump, pump);
+var createReadableStreamFromReadable = (source) => {
+  let pump = new StreamPump(source);
+  let stream = new ReadableStream(pump, pump);
+  return stream;
 };
 var StreamPump = class {
-	highWaterMark;
-	accumulatedSize;
-	stream;
-	controller;
-	constructor(stream) {
-		this.highWaterMark = stream.readableHighWaterMark || new Stream.Readable().readableHighWaterMark;
-		this.accumulatedSize = 0;
-		this.stream = stream;
-		this.enqueue = this.enqueue.bind(this);
-		this.error = this.error.bind(this);
-		this.close = this.close.bind(this);
-	}
-	size(chunk) {
-		return chunk?.byteLength || 0;
-	}
-	start(controller) {
-		this.controller = controller;
-		this.stream.on("data", this.enqueue);
-		this.stream.once("error", this.error);
-		this.stream.once("end", this.close);
-		this.stream.once("close", this.close);
-	}
-	pull() {
-		this.resume();
-	}
-	cancel(reason) {
-		if (this.stream.destroy) this.stream.destroy(reason);
-		this.stream.off("data", this.enqueue);
-		this.stream.off("error", this.error);
-		this.stream.off("end", this.close);
-		this.stream.off("close", this.close);
-	}
-	enqueue(chunk) {
-		if (this.controller) try {
-			let bytes = typeof chunk === "string" ? Buffer.from(chunk) : new Uint8Array(chunk);
-			let available = (this.controller.desiredSize || 0) - bytes.byteLength;
-			this.controller.enqueue(bytes);
-			if (available <= 0) this.pause();
-		} catch (e) {
-			this.controller.error(/* @__PURE__ */ new Error("Could not create Buffer, chunk must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object"));
-			this.cancel();
-		}
-	}
-	pause() {
-		if (this.stream.pause) this.stream.pause();
-	}
-	resume() {
-		if (this.stream.readable && this.stream.resume) this.stream.resume();
-	}
-	close() {
-		if (this.controller) {
-			this.controller.close();
-			delete this.controller;
-		}
-	}
-	error(error) {
-		if (this.controller) {
-			this.controller.error(error);
-			delete this.controller;
-		}
-	}
+  highWaterMark;
+  accumulatedSize;
+  stream;
+  controller;
+  constructor(stream) {
+    this.highWaterMark = stream.readableHighWaterMark || new import_node_stream.Stream.Readable().readableHighWaterMark;
+    this.accumulatedSize = 0;
+    this.stream = stream;
+    this.enqueue = this.enqueue.bind(this);
+    this.error = this.error.bind(this);
+    this.close = this.close.bind(this);
+  }
+  size(chunk) {
+    return chunk?.byteLength || 0;
+  }
+  start(controller) {
+    this.controller = controller;
+    this.stream.on("data", this.enqueue);
+    this.stream.once("error", this.error);
+    this.stream.once("end", this.close);
+    this.stream.once("close", this.close);
+  }
+  pull() {
+    this.resume();
+  }
+  cancel(reason) {
+    if (this.stream.destroy) {
+      this.stream.destroy(reason);
+    }
+    this.stream.off("data", this.enqueue);
+    this.stream.off("error", this.error);
+    this.stream.off("end", this.close);
+    this.stream.off("close", this.close);
+  }
+  enqueue(chunk) {
+    if (this.controller) {
+      try {
+        let bytes = chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
+        let available = (this.controller.desiredSize || 0) - bytes.byteLength;
+        this.controller.enqueue(bytes);
+        if (available <= 0) {
+          this.pause();
+        }
+      } catch (e) {
+        this.controller.error(
+          new Error(
+            "Could not create Buffer, chunk must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object"
+          )
+        );
+        this.cancel();
+      }
+    }
+  }
+  pause() {
+    if (this.stream.pause) {
+      this.stream.pause();
+    }
+  }
+  resume() {
+    if (this.stream.readable && this.stream.resume) {
+      this.stream.resume();
+    }
+  }
+  close() {
+    if (this.controller) {
+      this.controller.close();
+      delete this.controller;
+    }
+  }
+  error(error) {
+    if (this.controller) {
+      this.controller.error(error);
+      delete this.controller;
+    }
+  }
 };
-//#endregion
-export { createFileSessionStorage, createReadableStreamFromReadable, createRequestListener, readableStreamToString, writeAsyncIterableToWritable, writeReadableStreamToWritable };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFileSessionStorage,
+  createReadableStreamFromReadable,
+  createRequestListener,
+  readableStreamToString,
+  writeAsyncIterableToWritable,
+  writeReadableStreamToWritable
+});

package/dist/index.mjs

@@ -0,0 +1,337 @@
+/**
+ * @react-router/node v0.0.0-experimental-63fd291ad
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+
+// server.ts
+import { createRequestHandler } from "react-router";
+import { createRequestListener as createRequestListener_ } from "@mjackson/node-fetch-server";
+function createRequestListener(options) {
+  let handleRequest = createRequestHandler(options.build, options.mode);
+  return createRequestListener_(async (request, client) => {
+    let loadContext = await options.getLoadContext?.(request, client);
+    return handleRequest(request, loadContext);
+  });
+}
+
+// sessions/fileStorage.ts
+import { promises as fsp } from "fs";
+import * as path from "path";
+import { createSessionStorage } from "react-router";
+function createFileSessionStorage({
+  cookie,
+  dir
+}) {
+  return createSessionStorage({
+    cookie,
+    async createData(data, expires) {
+      let content = JSON.stringify({ data, expires });
+      while (true) {
+        let randomBytes = crypto.getRandomValues(new Uint8Array(8));
+        let id = Buffer.from(randomBytes).toString("hex");
+        try {
+          let file = getFile(dir, id);
+          if (!file) {
+            throw new Error("Error generating session");
+          }
+          await fsp.mkdir(path.dirname(file), { recursive: true });
+          await fsp.writeFile(file, content, { encoding: "utf-8", flag: "wx" });
+          return id;
+        } catch (error) {
+          if (error.code !== "EEXIST") throw error;
+        }
+      }
+    },
+    async readData(id) {
+      try {
+        let file = getFile(dir, id);
+        if (!file) {
+          return null;
+        }
+        let content = JSON.parse(await fsp.readFile(file, "utf-8"));
+        let data = content.data;
+        let expires = typeof content.expires === "string" ? new Date(content.expires) : null;
+        if (!expires || expires > /* @__PURE__ */ new Date()) {
+          return data;
+        }
+        if (expires) await fsp.unlink(file);
+        return null;
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+        return null;
+      }
+    },
+    async updateData(id, data, expires) {
+      let content = JSON.stringify({ data, expires });
+      let file = getFile(dir, id);
+      if (!file) {
+        return;
+      }
+      await fsp.mkdir(path.dirname(file), { recursive: true });
+      await fsp.writeFile(file, content, "utf-8");
+    },
+    async deleteData(id) {
+      if (!id) {
+        return;
+      }
+      let file = getFile(dir, id);
+      if (!file) {
+        return;
+      }
+      try {
+        await fsp.unlink(file);
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+    }
+  });
+}
+function getFile(dir, id) {
+  if (!/^[0-9a-f]{16}$/i.test(id)) {
+    return null;
+  }
+  return path.join(dir, id.slice(0, 4), id.slice(4));
+}
+
+// stream.ts
+import { Stream } from "stream";
+async function writeReadableStreamToWritable(stream, writable) {
+  let reader = stream.getReader();
+  let flushable = writable;
+  let writableError = monitorWritableError(writable);
+  try {
+    while (true) {
+      writableError.throwIfClosed();
+      let { done, value } = await writableError.race(reader.read());
+      if (done) {
+        writable.end();
+        break;
+      }
+      writableError.throwIfClosed();
+      let canContinueWriting = writable.write(value);
+      if (typeof flushable.flush === "function") {
+        flushable.flush();
+      }
+      if (!canContinueWriting) {
+        await waitForDrain(writable, writableError);
+      }
+    }
+  } catch (error) {
+    try {
+      reader.cancel(error).catch(() => {
+      });
+    } catch {
+    }
+    writable.destroy(error);
+    throw error;
+  } finally {
+    writableError.cleanup();
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+function monitorWritableError(writable) {
+  let settled = false;
+  let writableError;
+  let rejectWritableError;
+  let writableErrorPromise = new Promise((_, reject2) => {
+    rejectWritableError = reject2;
+  });
+  writableErrorPromise.catch(() => {
+  });
+  function cleanup() {
+    writable.off("error", onError);
+    writable.off("close", onClose);
+  }
+  function reject(error) {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    writableError = error;
+    cleanup();
+    rejectWritableError(error);
+  }
+  function onError(error) {
+    reject(error);
+  }
+  function onClose() {
+    reject(new Error("Writable closed before stream finished"));
+  }
+  writable.once("error", onError);
+  writable.once("close", onClose);
+  return {
+    cleanup,
+    race(promise) {
+      return Promise.race([promise, writableErrorPromise]);
+    },
+    throwIfClosed() {
+      if (writableError) {
+        throw writableError;
+      }
+      if (writable.destroyed || writable.writableEnded) {
+        throw new Error("Cannot write to a destroyed or ended writable stream");
+      }
+    }
+  };
+}
+function waitForDrain(writable, writableError) {
+  let cleanup = () => {
+  };
+  let drainPromise = new Promise((resolve) => {
+    function onDrain() {
+      cleanup();
+      resolve();
+    }
+    cleanup = function cleanup2() {
+      writable.off("drain", onDrain);
+    };
+    writable.once("drain", onDrain);
+  });
+  return writableError.race(drainPromise).finally(cleanup);
+}
+async function writeAsyncIterableToWritable(iterable, writable) {
+  let writableError = monitorWritableError(writable);
+  let iterator = iterable[Symbol.asyncIterator]();
+  let completed = false;
+  try {
+    while (true) {
+      writableError.throwIfClosed();
+      let { done, value: chunk } = await writableError.race(iterator.next());
+      if (done) {
+        completed = true;
+        break;
+      }
+      writableError.throwIfClosed();
+      let canContinueWriting = writable.write(chunk);
+      if (!canContinueWriting) {
+        await waitForDrain(writable, writableError);
+      }
+    }
+    writable.end();
+  } catch (error) {
+    if (!completed) {
+      try {
+        Promise.resolve(iterator.return?.()).catch(() => {
+        });
+      } catch {
+      }
+    }
+    writable.destroy(error);
+    throw error;
+  } finally {
+    writableError.cleanup();
+  }
+}
+async function readableStreamToString(stream, encoding) {
+  let reader = stream.getReader();
+  let chunks = [];
+  while (true) {
+    let { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    if (value) {
+      chunks.push(value);
+    }
+  }
+  return Buffer.concat(chunks).toString(encoding);
+}
+var createReadableStreamFromReadable = (source) => {
+  let pump = new StreamPump(source);
+  let stream = new ReadableStream(pump, pump);
+  return stream;
+};
+var StreamPump = class {
+  highWaterMark;
+  accumulatedSize;
+  stream;
+  controller;
+  constructor(stream) {
+    this.highWaterMark = stream.readableHighWaterMark || new Stream.Readable().readableHighWaterMark;
+    this.accumulatedSize = 0;
+    this.stream = stream;
+    this.enqueue = this.enqueue.bind(this);
+    this.error = this.error.bind(this);
+    this.close = this.close.bind(this);
+  }
+  size(chunk) {
+    return chunk?.byteLength || 0;
+  }
+  start(controller) {
+    this.controller = controller;
+    this.stream.on("data", this.enqueue);
+    this.stream.once("error", this.error);
+    this.stream.once("end", this.close);
+    this.stream.once("close", this.close);
+  }
+  pull() {
+    this.resume();
+  }
+  cancel(reason) {
+    if (this.stream.destroy) {
+      this.stream.destroy(reason);
+    }
+    this.stream.off("data", this.enqueue);
+    this.stream.off("error", this.error);
+    this.stream.off("end", this.close);
+    this.stream.off("close", this.close);
+  }
+  enqueue(chunk) {
+    if (this.controller) {
+      try {
+        let bytes = chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
+        let available = (this.controller.desiredSize || 0) - bytes.byteLength;
+        this.controller.enqueue(bytes);
+        if (available <= 0) {
+          this.pause();
+        }
+      } catch (e) {
+        this.controller.error(
+          new Error(
+            "Could not create Buffer, chunk must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object"
+          )
+        );
+        this.cancel();
+      }
+    }
+  }
+  pause() {
+    if (this.stream.pause) {
+      this.stream.pause();
+    }
+  }
+  resume() {
+    if (this.stream.readable && this.stream.resume) {
+      this.stream.resume();
+    }
+  }
+  close() {
+    if (this.controller) {
+      this.controller.close();
+      delete this.controller;
+    }
+  }
+  error(error) {
+    if (this.controller) {
+      this.controller.error(error);
+      delete this.controller;
+    }
+  }
+};
+export {
+  createFileSessionStorage,
+  createReadableStreamFromReadable,
+  createRequestListener,
+  readableStreamToString,
+  writeAsyncIterableToWritable,
+  writeReadableStreamToWritable
+};

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@react-router/node",
-  "type": "module",
-  "version": "0.0.0-experimental-f7761f1cd",
+  "version": "0.0.0-experimental-63fd291ad",
   "description": "Node.js platform abstractions for React Router",
   "bugs": {
     "url": "https://github.com/remix-run/react-router/issues"
@@ -16,15 +15,25 @@
   "main": "dist/index.js",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "module-sync": "./dist/index.js",
-      "default": "./dist/index.js"
+      "node": {
+        "types": "./dist/index.d.ts",
+        "module-sync": "./dist/index.mjs",
+        "default": "./dist/index.js"
+      },
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "default": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
     },
     "./package.json": "./package.json"
   },
   "wireit": {
     "build": {
-      "command": "tsdown",
+      "command": "tsup",
       "files": [
         "../../pnpm-workspace.yaml",
         "sessions/**",
@@ -38,18 +47,17 @@
     }
   },
   "dependencies": {
-    "@remix-run/node-fetch-server": "^0.13.3"
+    "@mjackson/node-fetch-server": "^0.2.0"
   },
   "devDependencies": {
-    "@types/node": "^22.19.19",
-    "tsdown": "^0.22.0",
-    "typescript": "^6.0.3",
-    "wireit": "0.14.12",
-    "react-router": "0.0.0-experimental-f7761f1cd"
+    "tsup": "^8.3.0",
+    "typescript": "^5.4.5",
+    "wireit": "0.14.9",
+    "react-router": "0.0.0-experimental-63fd291ad"
   },
   "peerDependencies": {
     "typescript": "^5.1.0 || ^6.0.0",
-    "react-router": "0.0.0-experimental-f7761f1cd"
+    "react-router": "0.0.0-experimental-63fd291ad"
   },
   "peerDependenciesMeta": {
     "typescript": {
@@ -57,7 +65,7 @@
     }
   },
   "engines": {
-    "node": ">=22.12.0"
+    "node": ">=20.0.0"
   },
   "files": [
     "dist/",