@fluojs/platform-nodejs 1.0.6 → 2.0.0

package/dist/node/json-logger.d.ts

@@ -0,0 +1,8 @@
+import type { ApplicationLogger } from '@fluojs/runtime';
+/**
+ * Create json application logger.
+ *
+ * @returns The create json application logger result.
+ */
+export declare function createJsonApplicationLogger(): ApplicationLogger;
+//# sourceMappingURL=json-logger.d.ts.map

package/dist/node/json-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-logger.d.ts","sourceRoot":"","sources":["../../src/node/json-logger.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAqCzD;;;;GAIG;AACH,wBAAgB,2BAA2B,IAAI,iBAAiB,CAe/D"}

package/dist/node/json-logger.js

@@ -0,0 +1,45 @@
+import { getCurrentRequestContext } from '@fluojs/http';
+function buildEntry(level, message, context, error) {
+  const entry = {
+    level,
+    message,
+    timestamp: new Date().toISOString()
+  };
+  const requestId = getCurrentRequestContext()?.requestId;
+  if (requestId) {
+    entry.requestId = requestId;
+  }
+  if (context) {
+    entry.context = context;
+  }
+  if (error instanceof Error) {
+    entry.error = {
+      message: error.message,
+      name: error.name,
+      stack: error.stack
+    };
+  }
+  return entry;
+}
+
+/**
+ * Create json application logger.
+ *
+ * @returns The create json application logger result.
+ */
+export function createJsonApplicationLogger() {
+  return {
+    debug(message, context) {
+      process.stdout.write(`${JSON.stringify(buildEntry('debug', message, context))}\n`);
+    },
+    error(message, error, context) {
+      process.stderr.write(`${JSON.stringify(buildEntry('error', message, context, error))}\n`);
+    },
+    log(message, context) {
+      process.stdout.write(`${JSON.stringify(buildEntry('log', message, context))}\n`);
+    },
+    warn(message, context) {
+      process.stderr.write(`${JSON.stringify(buildEntry('warn', message, context))}\n`);
+    }
+  };
+}

package/dist/node/logger.d.ts

@@ -0,0 +1,37 @@
+import type { ApplicationLogger } from '@fluojs/runtime';
+/** Severity threshold accepted by `createConsoleApplicationLogger(...)`. */
+export type ConsoleApplicationLoggerLevel = 'debug' | 'error' | 'log' | 'warn';
+/** Console formatting mode accepted by `createConsoleApplicationLogger(...)`. */
+export type ConsoleApplicationLoggerMode = 'minimal' | 'pretty' | 'silent';
+/** Options used to tune the Node console logger without replacing the runtime logger contract. */
+export interface ConsoleApplicationLoggerOptions {
+    /**
+     * Controls console formatting.
+     *
+     * - `pretty` keeps the historical timestamp, pid, level, context, and message format.
+     * - `minimal` writes only `[fluo] LEVEL [context] message`.
+     * - `silent` suppresses all logger methods.
+     */
+    mode?: ConsoleApplicationLoggerMode;
+    /** Lowest severity emitted by the logger. Defaults to `debug`, preserving existing output. */
+    level?: ConsoleApplicationLoggerLevel;
+    /** Override TTY-aware ANSI color detection. */
+    color?: boolean;
+    /** Explicit host color environment passed from the application/bootstrap boundary. */
+    environment?: ConsoleApplicationLoggerEnvironment;
+}
+/** Host color environment used by `createConsoleApplicationLogger(...)` without reading globals directly. */
+export interface ConsoleApplicationLoggerEnvironment {
+    /** Whether `NO_COLOR`-style color suppression is enabled. */
+    noColor?: boolean;
+    /** `FORCE_COLOR`-style value used to force ANSI color output when truthy. */
+    forceColor?: string;
+}
+/**
+ * Create console application logger.
+ *
+ * @param options Console logger mode, severity threshold, and color override.
+ * @returns The create console application logger result.
+ */
+export declare function createConsoleApplicationLogger(options?: ConsoleApplicationLoggerOptions): ApplicationLogger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/node/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/node/logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,4EAA4E;AAC5E,MAAM,MAAM,6BAA6B,GAAG,OAAO,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;AAC/E,iFAAiF;AACjF,MAAM,MAAM,4BAA4B,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE3E,kGAAkG;AAClG,MAAM,WAAW,+BAA+B;IAC9C;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,4BAA4B,CAAC;IACpC,8FAA8F;IAC9F,KAAK,CAAC,EAAE,6BAA6B,CAAC;IACtC,+CAA+C;IAC/C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,sFAAsF;IACtF,WAAW,CAAC,EAAE,mCAAmC,CAAC;CACnD;AAED,6GAA6G;AAC7G,MAAM,WAAW,mCAAmC;IAClD,6DAA6D;IAC7D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AA+DD;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,GAAE,+BAAoC,GAAG,iBAAiB,CA2C/G"}

package/dist/node/logger.js

@@ -0,0 +1,103 @@
+/** Severity threshold accepted by `createConsoleApplicationLogger(...)`. */
+
+/** Console formatting mode accepted by `createConsoleApplicationLogger(...)`. */
+
+/** Options used to tune the Node console logger without replacing the runtime logger contract. */
+
+/** Host color environment used by `createConsoleApplicationLogger(...)` without reading globals directly. */
+
+const RESET = '\u001B[0m';
+const BRIGHT_GREEN = '\u001B[32m';
+const BRIGHT_RED = '\u001B[31m';
+const BRIGHT_YELLOW = '\u001B[33m';
+const DIM = '\u001B[2m';
+const LEVEL_PRIORITY = {
+  debug: 10,
+  log: 20,
+  warn: 30,
+  error: 40
+};
+function colorize(value, color, enabled) {
+  return enabled ? `${color}${value}${RESET}` : value;
+}
+function formatLog(level, context, message, color) {
+  const prefix = colorize('[fluo]', BRIGHT_GREEN, color);
+  const pid = colorize(String(process.pid), BRIGHT_YELLOW, color);
+  const timestamp = colorize(new Date().toLocaleString('en-US'), DIM, color);
+  const levelColor = level === 'ERROR' || level === 'WARN' ? BRIGHT_RED : BRIGHT_GREEN;
+  const levelLabel = colorize(level, levelColor, color);
+  const contextLabel = colorize(`[${context}]`, BRIGHT_YELLOW, color);
+  return `${prefix} ${pid} - ${timestamp} ${levelLabel} ${contextLabel} ${message}`;
+}
+function formatMinimalLog(level, context, message, color) {
+  const prefix = colorize('[fluo]', BRIGHT_GREEN, color);
+  const levelColor = level === 'ERROR' || level === 'WARN' ? BRIGHT_RED : BRIGHT_GREEN;
+  const levelLabel = colorize(level, levelColor, color);
+  const contextLabel = colorize(`[${context}]`, BRIGHT_YELLOW, color);
+  return `${prefix} ${levelLabel} ${contextLabel} ${message}`;
+}
+function shouldLog(currentLevel, configuredLevel) {
+  return LEVEL_PRIORITY[currentLevel] >= LEVEL_PRIORITY[configuredLevel];
+}
+function isForceColorEnabled(value) {
+  return value !== undefined && value !== '' && value !== '0' && value !== 'false' && value !== 'no' && value !== 'off';
+}
+function shouldUseColor(stream, environment) {
+  if (environment.noColor === true) {
+    return false;
+  }
+  if (isForceColorEnabled(environment.forceColor)) {
+    return true;
+  }
+  if (typeof stream.hasColors === 'function') {
+    return stream.hasColors();
+  }
+  return Boolean(stream.isTTY);
+}
+
+/**
+ * Create console application logger.
+ *
+ * @param options Console logger mode, severity threshold, and color override.
+ * @returns The create console application logger result.
+ */
+export function createConsoleApplicationLogger(options = {}) {
+  const mode = options.mode ?? 'pretty';
+  const level = options.level ?? 'debug';
+  const environment = options.environment ?? {};
+  const format = mode === 'minimal' ? formatMinimalLog : formatLog;
+  if (mode === 'silent') {
+    return {
+      debug() {},
+      error() {},
+      log() {},
+      warn() {}
+    };
+  }
+  return {
+    debug(message, context = 'fluo') {
+      if (shouldLog('debug', level)) {
+        console.debug(format('DEBUG', context, message, options.color ?? shouldUseColor(process.stdout, environment)));
+      }
+    },
+    error(message, error, context = 'fluo') {
+      if (!shouldLog('error', level)) {
+        return;
+      }
+      console.error(format('ERROR', context, message, options.color ?? shouldUseColor(process.stderr, environment)));
+      if (error) {
+        console.error(error);
+      }
+    },
+    log(message, context = 'fluo') {
+      if (shouldLog('log', level)) {
+        console.log(format('LOG', context, message, options.color ?? shouldUseColor(process.stdout, environment)));
+      }
+    },
+    warn(message, context = 'fluo') {
+      if (shouldLog('warn', level)) {
+        console.warn(format('WARN', context, message, options.color ?? shouldUseColor(process.stderr, environment)));
+      }
+    }
+  };
+}

package/dist/node/node-compression.d.ts

@@ -0,0 +1,2 @@
+export { compressNodeResponse, createNodeResponseCompression, } from './internal-node-compression.js';
+//# sourceMappingURL=node-compression.d.ts.map

package/dist/node/node-compression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-compression.d.ts","sourceRoot":"","sources":["../../src/node/node-compression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,6BAA6B,GAC9B,MAAM,gCAAgC,CAAC"}

package/dist/node/node-compression.js

@@ -0,0 +1 @@
+export { compressNodeResponse, createNodeResponseCompression } from './internal-node-compression.js';

package/dist/node/node-request.d.ts

@@ -0,0 +1,2 @@
+export { createDeferredFrameworkRequest, createFrameworkRequest, createRequestSignal, materializeFrameworkRequestBody, resolveRequestIdFromHeaders, } from './internal-node-request.js';
+//# sourceMappingURL=node-request.d.ts.map

package/dist/node/node-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-request.d.ts","sourceRoot":"","sources":["../../src/node/node-request.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,8BAA8B,EAC9B,sBAAsB,EACtB,mBAAmB,EACnB,+BAA+B,EAC/B,2BAA2B,GAC5B,MAAM,4BAA4B,CAAC"}

package/dist/node/node-request.js

@@ -0,0 +1 @@
+export { createDeferredFrameworkRequest, createFrameworkRequest, createRequestSignal, materializeFrameworkRequestBody, resolveRequestIdFromHeaders } from './internal-node-request.js';

package/dist/node/node-response.d.ts

@@ -0,0 +1,2 @@
+export { createFrameworkResponse, type MutableFrameworkResponse, writeNodeAdapterErrorResponse, } from './internal-node-response.js';
+//# sourceMappingURL=node-response.d.ts.map

package/dist/node/node-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-response.d.ts","sourceRoot":"","sources":["../../src/node/node-response.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,KAAK,wBAAwB,EAC7B,6BAA6B,GAC9B,MAAM,6BAA6B,CAAC"}

package/dist/node/node-response.js

@@ -0,0 +1 @@
+export { createFrameworkResponse, writeNodeAdapterErrorResponse } from './internal-node-response.js';

package/dist/node/node-shutdown.d.ts

@@ -0,0 +1,2 @@
+export { createNodeShutdownSignalRegistration, defaultNodeShutdownSignals, registerShutdownSignals, } from './internal-node-shutdown.js';
+//# sourceMappingURL=node-shutdown.d.ts.map

package/dist/node/node-shutdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-shutdown.d.ts","sourceRoot":"","sources":["../../src/node/node-shutdown.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oCAAoC,EACpC,0BAA0B,EAC1B,uBAAuB,GACxB,MAAM,6BAA6B,CAAC"}

package/dist/node/node-shutdown.js

@@ -0,0 +1 @@
+export { createNodeShutdownSignalRegistration, defaultNodeShutdownSignals, registerShutdownSignals } from './internal-node-shutdown.js';

package/dist/node/node-static-assets.d.ts

@@ -0,0 +1,26 @@
+import type { StaticAssetSource } from '@fluojs/http';
+/** Precompressed representation policy for a Node filesystem asset source. */
+export type NodeFileSystemAssetPrecompression = boolean | {
+    /** Whether `.br` siblings may be selected. Defaults to `true`. */
+    readonly brotli?: boolean;
+    /** Whether `.gz` siblings may be selected. Defaults to `true`. */
+    readonly gzip?: boolean;
+};
+/** Configuration for a Node filesystem-backed static asset source. */
+export interface NodeFileSystemAssetSourceOptions {
+    /** Existing directory that contains all served asset files. */
+    readonly root: string;
+    /** Optional precompressed sibling selection policy. Defaults to `false`. */
+    readonly precompressed?: NodeFileSystemAssetPrecompression;
+}
+/**
+ * Creates a Node-only filesystem source for {@link StaticAssetSource}.
+ *
+ * @param options Existing root directory and optional precompressed sibling policy.
+ * @returns An explicit portable source that eagerly snapshots each verified
+ * selected file into memory, closes its `FileHandle`, and replays only that
+ * immutable byte snapshot through `StaticAsset.source`.
+ * @throws {TypeError} When the root is empty, missing, or not a directory.
+ */
+export declare function createNodeFileSystemAssetSource(options: NodeFileSystemAssetSourceOptions): StaticAssetSource;
+//# sourceMappingURL=node-static-assets.d.ts.map

package/dist/node/node-static-assets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-static-assets.d.ts","sourceRoot":"","sources":["../../src/node/node-static-assets.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAIV,iBAAiB,EAClB,MAAM,cAAc,CAAC;AA0BtB,8EAA8E;AAC9E,MAAM,MAAM,iCAAiC,GAAG,OAAO,GAAG;IACxD,kEAAkE;IAClE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,kEAAkE;IAClE,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,sEAAsE;AACtE,MAAM,WAAW,gCAAgC;IAC/C,+DAA+D;IAC/D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4EAA4E;IAC5E,QAAQ,CAAC,aAAa,CAAC,EAAE,iCAAiC,CAAC;CAC5D;AAED;;;;;;;;GAQG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,gCAAgC,GACxC,iBAAiB,CAoCnB"}

package/dist/node/node-static-assets.js

@@ -0,0 +1,244 @@
+import { createHash } from 'node:crypto';
+import { constants, realpathSync, statSync } from 'node:fs';
+import { open, realpath, stat } from 'node:fs/promises';
+import { extname, isAbsolute, relative, resolve } from 'node:path';
+const mimeTypes = {
+  '.avif': 'image/avif',
+  '.css': 'text/css; charset=utf-8',
+  '.gif': 'image/gif',
+  '.htm': 'text/html; charset=utf-8',
+  '.html': 'text/html; charset=utf-8',
+  '.ico': 'image/x-icon',
+  '.jpeg': 'image/jpeg',
+  '.jpg': 'image/jpeg',
+  '.js': 'application/javascript',
+  '.json': 'application/json',
+  '.map': 'application/json',
+  '.mjs': 'application/javascript',
+  '.pdf': 'application/pdf',
+  '.png': 'image/png',
+  '.svg': 'image/svg+xml',
+  '.txt': 'text/plain; charset=utf-8',
+  '.wasm': 'application/wasm',
+  '.webp': 'image/webp',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.xml': 'application/xml'
+};
+
+/** Precompressed representation policy for a Node filesystem asset source. */
+
+/** Configuration for a Node filesystem-backed static asset source. */
+
+/**
+ * Creates a Node-only filesystem source for {@link StaticAssetSource}.
+ *
+ * @param options Existing root directory and optional precompressed sibling policy.
+ * @returns An explicit portable source that eagerly snapshots each verified
+ * selected file into memory, closes its `FileHandle`, and replays only that
+ * immutable byte snapshot through `StaticAsset.source`.
+ * @throws {TypeError} When the root is empty, missing, or not a directory.
+ */
+export function createNodeFileSystemAssetSource(options) {
+  const root = resolveNodeAssetRoot(options);
+  const precompressed = resolvePrecompression(options.precompressed);
+  return {
+    async resolve(path, context) {
+      const logicalPath = resolveRelativeAssetPath(root, path);
+      if (!logicalPath) {
+        return undefined;
+      }
+      const selected = await selectRepresentation(root, logicalPath, context.acceptedEncodings, precompressed);
+      if (!selected) {
+        return (await hasExistingRepresentation(root, logicalPath, precompressed)) ? {
+          notAcceptable: true
+        } : undefined;
+      }
+      return {
+        contentEncoding: selected.representation.encoding,
+        contentType: mimeTypes[extname(logicalPath)] ?? 'application/octet-stream',
+        source: () => createSnapshotStream(selected.bytes),
+        size: selected.metadata.size,
+        validators: {
+          etag: {
+            opaqueValue: createAssetEtag(selected.bytes),
+            strength: 'strong'
+          },
+          lastModified: selected.metadata.lastModified
+        },
+        variesByEncoding: selected.variesByEncoding
+      };
+    }
+  };
+}
+function resolveNodeAssetRoot(options) {
+  if (!options || typeof options !== 'object' || typeof options.root !== 'string' || options.root.trim() === '') {
+    throw new TypeError('Node filesystem static asset root must be a non-empty string.');
+  }
+  let root;
+  try {
+    root = realpathSync(resolve(options.root));
+  } catch {
+    throw new TypeError('Node filesystem static asset root must be an existing directory.');
+  }
+  const metadata = statSync(root, {
+    bigint: true
+  });
+  if (!metadata.isDirectory()) {
+    throw new TypeError('Node filesystem static asset root must be a directory.');
+  }
+  return {
+    device: metadata.dev,
+    inode: metadata.ino,
+    path: root
+  };
+}
+function resolvePrecompression(value) {
+  if (value === undefined || value === false) {
+    return {
+      brotli: false,
+      gzip: false
+    };
+  }
+  if (value === true) {
+    return {
+      brotli: true,
+      gzip: true
+    };
+  }
+  if (typeof value !== 'object') {
+    throw new TypeError('Node filesystem static asset precompressed must be a boolean or an object.');
+  }
+  return {
+    brotli: value.brotli ?? true,
+    gzip: value.gzip ?? true
+  };
+}
+function resolveRelativeAssetPath(root, path) {
+  if (typeof path !== 'string' || path === '' || path.includes('\0') || isAbsolute(path) || path.split('/').some(segment => segment === '' || segment === '.' || segment === '..' || segment.includes('\\'))) {
+    return undefined;
+  }
+  const candidate = resolve(root.path, ...path.split('/'));
+  return isWithinRoot(root.path, candidate) ? path : undefined;
+}
+async function selectRepresentation(root, logicalPath, acceptedEncodings, precompressed) {
+  for (const encoding of acceptedEncodings) {
+    if (encoding === 'br' && !precompressed.brotli || encoding === 'gzip' && !precompressed.gzip) {
+      continue;
+    }
+    const extension = encoding === 'br' ? '.br' : encoding === 'gzip' ? '.gz' : '';
+    const candidate = `${logicalPath}${extension}`;
+    const opened = await openContainedAsset(root, candidate);
+    if (opened) {
+      return {
+        ...opened,
+        representation: extension === '' ? {
+          path: candidate
+        } : {
+          encoding: encoding === 'identity' ? undefined : encoding,
+          path: candidate
+        },
+        variesByEncoding: await hasPrecompressedRepresentation(root, logicalPath, precompressed)
+      };
+    }
+  }
+  return undefined;
+}
+async function hasExistingRepresentation(root, logicalPath, precompressed) {
+  for (const representation of supportedRepresentations(logicalPath, precompressed)) {
+    const opened = await openContainedAsset(root, representation.path);
+    if (opened) {
+      return true;
+    }
+  }
+  return false;
+}
+async function hasPrecompressedRepresentation(root, logicalPath, precompressed) {
+  return (await hasExistingRepresentation(root, logicalPath, {
+    brotli: precompressed.brotli,
+    gzip: precompressed.gzip
+  })) && (precompressed.brotli && (await representationExists(root, `${logicalPath}.br`)) || precompressed.gzip && (await representationExists(root, `${logicalPath}.gz`)));
+}
+function supportedRepresentations(logicalPath, precompressed) {
+  return [...(precompressed.brotli ? [{
+    encoding: 'br',
+    path: `${logicalPath}.br`
+  }] : []), ...(precompressed.gzip ? [{
+    encoding: 'gzip',
+    path: `${logicalPath}.gz`
+  }] : []), {
+    path: logicalPath
+  }];
+}
+async function representationExists(root, logicalPath) {
+  const opened = await openContainedAsset(root, logicalPath);
+  return opened !== undefined;
+}
+async function openContainedAsset(root, path) {
+  try {
+    const resolvedPath = await realpath(resolve(root.path, path));
+    if (!isWithinRoot(root.path, resolvedPath)) {
+      return undefined;
+    }
+    const expected = await stat(resolvedPath, {
+      bigint: true
+    });
+    if (!expected.isFile()) {
+      return undefined;
+    }
+    const handle = await open(resolvedPath, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+      const metadata = await readAssetMetadata(handle);
+      if (!metadata || metadata.device !== expected.dev || metadata.inode !== expected.ino) {
+        return undefined;
+      }
+      const bytes = new Uint8Array(await handle.readFile());
+      return {
+        bytes,
+        metadata: {
+          ...metadata,
+          size: bytes.byteLength
+        }
+      };
+    } finally {
+      await handle.close();
+    }
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return undefined;
+    }
+    throw error;
+  }
+}
+async function readAssetMetadata(handle) {
+  const metadata = await handle.stat({
+    bigint: true
+  });
+  if (!metadata.isFile() || metadata.size > BigInt(Number.MAX_SAFE_INTEGER)) {
+    return undefined;
+  }
+  return {
+    device: metadata.dev,
+    inode: metadata.ino,
+    lastModified: new Date(Number(metadata.mtimeMs)),
+    size: Number(metadata.size)
+  };
+}
+function createSnapshotStream(bytes) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(bytes);
+      controller.close();
+    }
+  });
+}
+function createAssetEtag(bytes) {
+  return createHash('sha256').update(bytes).digest('base64url');
+}
+function isWithinRoot(root, target) {
+  const pathFromRoot = relative(root, target);
+  return pathFromRoot === '' || !pathFromRoot.startsWith('..') && !isAbsolute(pathFromRoot);
+}
+function isMissingFileError(error) {
+  return error instanceof Error && 'code' in error && (error.code === 'ELOOP' || error.code === 'ENOENT' || error.code === 'ENOTDIR');
+}

package/dist/node/node.d.ts

@@ -0,0 +1,2 @@
+export * from './internal-node.js';
+//# sourceMappingURL=node.d.ts.map

package/dist/node/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/node/node.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dist/node/node.js

@@ -0,0 +1 @@
+export * from './internal-node.js';

package/package.json

@@ -9,7 +9,7 @@
     "platform",
     "server"
   ],
-  "version": "1.0.6",
+  "version": "2.0.0",
   "private": false,
   "license": "MIT",
   "repository": {
@@ -18,7 +18,7 @@
     "directory": "packages/platform-nodejs"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=24.0.0 <27"
   },
   "publishConfig": {
     "access": "public"
@@ -28,23 +28,34 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "import": "./dist/internal.js"
     }
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "internal": [
+        "./dist/internal.d.ts"
+      ]
+    }
+  },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@fluojs/http": "^2.0.1",
-    "@fluojs/runtime": "^2.0.1"
+    "@fluojs/http": "^3.0.0",
+    "@fluojs/runtime": "^3.0.0"
   },
   "devDependencies": {
-    "vitest": "^3.2.4"
+    "vitest": "^4.1.11"
   },
   "scripts": {
     "prebuild": "node ../../tooling/scripts/clean-dist.mjs",
-    "build": "pnpm exec babel src --extensions .ts --ignore 'src/**/*.test.ts' --out-dir dist --config-file ../../tooling/babel/babel.config.cjs && pnpm exec tsc -p tsconfig.build.json",
+    "build": "pnpm exec babel src --extensions .ts --ignore 'src/**/*.test.ts','src/**/*.test-fixture.ts' --out-dir dist --config-file ../../tooling/babel/babel.config.cjs && pnpm exec tsc -p tsconfig.build.json",
     "typecheck": "pnpm exec tsc -p tsconfig.json --noEmit",
     "test": "pnpm exec vitest run -c vitest.config.ts",
     "test:watch": "pnpm exec vitest -c vitest.config.ts"