elit 3.6.6 → 3.6.8

package/dist/path.mjs

@@ -1,6 +1,6 @@
 import {createRequire as __createRequire} from 'module';const require = __createRequire(import.meta.url);
 
-// src/runtime.ts
+// src/shares/runtime.ts
 var runtime = (() => {
   if (typeof Deno !== "undefined") return "deno";
   if (typeof Bun !== "undefined") return "bun";
@@ -10,37 +10,35 @@ var isNode = runtime === "node";
 var isBun = runtime === "bun";
 var isDeno = runtime === "deno";
 
-// src/path.ts
+// src/server/path/platform.ts
 function getSeparator(isWin) {
   return isWin ? "\\" : "/";
 }
 function getCwd() {
   if (isNode || isBun) {
     return process.cwd();
-  } else if (isDeno) {
+  }
+  if (isDeno) {
     return Deno.cwd();
   }
   return "/";
 }
+var isWindows = (() => {
+  if (isNode) {
+    return process.platform === "win32";
+  }
+  if (isDeno) {
+    return Deno.build.os === "windows";
+  }
+  return typeof process !== "undefined" && process.platform === "win32";
+})();
+var sep = isWindows ? "\\" : "/";
+var delimiter = isWindows ? ";" : ":";
+
+// src/server/path/operations.ts
 function findLastSeparator(path) {
   return Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
 }
-function createPathOps(isWin) {
-  return {
-    sep: getSeparator(isWin),
-    delimiter: isWin ? ";" : ":",
-    normalize: (path) => normalizePath(path, isWin),
-    join: (...paths) => joinPaths(paths, isWin),
-    resolve: (...paths) => resolvePaths(paths, isWin),
-    isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
-    relative: (from, to) => relativePath(from, to, isWin),
-    dirname: (path) => getDirname(path, isWin),
-    basename: (path, ext) => getBasename(path, ext, isWin),
-    extname: (path) => getExtname(path),
-    parse: (path) => parsePath(path, isWin),
-    format: (pathObject) => formatPath(pathObject, isWin)
-  };
-}
 function isAbsolutePosix(path) {
   return path.length > 0 && path[0] === "/";
 }
@@ -61,30 +59,18 @@ function isAbsoluteWin(path) {
   }
   return false;
 }
-var isWindows = (() => {
-  if (isNode) {
-    return process.platform === "win32";
-  } else if (isDeno) {
-    return Deno.build.os === "windows";
-  }
-  return typeof process !== "undefined" && process.platform === "win32";
-})();
-var sep = isWindows ? "\\" : "/";
-var delimiter = isWindows ? ";" : ":";
-var posix = createPathOps(false);
-var win32 = createPathOps(true);
 function normalizePath(path, isWin) {
   if (path.length === 0) return ".";
   const separator = getSeparator(isWin);
   const isAbsolute2 = isWin ? isAbsoluteWin(path) : isAbsolutePosix(path);
   const trailingSeparator = path[path.length - 1] === separator || isWin && path[path.length - 1] === "/";
-  let normalized = path.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
+  const normalized = path.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
   const parts = normalized.split(separator);
   const result = [];
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
+  for (let index = 0; index < parts.length; index++) {
+    const part = parts[index];
     if (part === "" || part === ".") {
-      if (i === 0 && isAbsolute2) result.push("");
+      if (index === 0 && isAbsolute2) result.push("");
       continue;
     }
     if (part === "..") {
@@ -99,21 +85,21 @@ function normalizePath(path, isWin) {
       result.push(part);
     }
   }
-  let final = result.join(separator);
-  if (final.length === 0) {
+  let finalPath = result.join(separator);
+  if (finalPath.length === 0) {
     return isAbsolute2 ? separator : ".";
   }
-  if (trailingSeparator && final[final.length - 1] !== separator) {
-    final += separator;
+  if (trailingSeparator && finalPath[finalPath.length - 1] !== separator) {
+    finalPath += separator;
   }
-  return final;
+  return finalPath;
 }
 function joinPaths(paths, isWin) {
   if (paths.length === 0) return ".";
   const separator = getSeparator(isWin);
   let joined = "";
-  for (let i = 0; i < paths.length; i++) {
-    const path = paths[i];
+  for (let index = 0; index < paths.length; index++) {
+    const path = paths[index];
     if (path && path.length > 0) {
       if (joined.length === 0) {
         joined = path;
@@ -128,43 +114,43 @@ function joinPaths(paths, isWin) {
 function resolvePaths(paths, isWin) {
   const separator = getSeparator(isWin);
   let resolved = "";
-  let isAbsolute2 = false;
-  for (let i = paths.length - 1; i >= 0 && !isAbsolute2; i--) {
-    const path = paths[i];
+  let absolute = false;
+  for (let index = paths.length - 1; index >= 0 && !absolute; index--) {
+    const path = paths[index];
     if (path && path.length > 0) {
       resolved = path + (resolved.length > 0 ? separator + resolved : "");
-      isAbsolute2 = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
+      absolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
     }
   }
-  if (!isAbsolute2) {
+  if (!absolute) {
     const cwd = getCwd();
     resolved = cwd + (resolved.length > 0 ? separator + resolved : "");
   }
   return normalizePath(resolved, isWin);
 }
 function relativePath(from, to, isWin) {
-  from = resolvePaths([from], isWin);
-  to = resolvePaths([to], isWin);
-  if (from === to) return "";
+  const resolvedFrom = resolvePaths([from], isWin);
+  const resolvedTo = resolvePaths([to], isWin);
+  if (resolvedFrom === resolvedTo) return "";
   const separator = getSeparator(isWin);
-  const fromParts = from.split(separator).filter((p) => p.length > 0);
-  const toParts = to.split(separator).filter((p) => p.length > 0);
-  let commonLength = 0;
+  const fromParts = resolvedFrom.split(separator).filter((part) => part.length > 0);
+  const toParts = resolvedTo.split(separator).filter((part) => part.length > 0);
   const minLength = Math.min(fromParts.length, toParts.length);
-  for (let i = 0; i < minLength; i++) {
-    if (fromParts[i] === toParts[i]) {
+  let commonLength = 0;
+  for (let index = 0; index < minLength; index++) {
+    if (fromParts[index] === toParts[index]) {
       commonLength++;
     } else {
       break;
     }
   }
-  const upCount = fromParts.length - commonLength;
   const result = [];
-  for (let i = 0; i < upCount; i++) {
+  const upCount = fromParts.length - commonLength;
+  for (let index = 0; index < upCount; index++) {
     result.push("..");
   }
-  for (let i = commonLength; i < toParts.length; i++) {
-    result.push(toParts[i]);
+  for (let index = commonLength; index < toParts.length; index++) {
+    result.push(toParts[index]);
   }
   return result.join(separator) || ".";
 }
@@ -172,15 +158,15 @@ function getDirname(path, isWin) {
   if (path.length === 0) return ".";
   const separator = getSeparator(isWin);
   const normalized = normalizePath(path, isWin);
-  const lastSepIndex = normalized.lastIndexOf(separator);
-  if (lastSepIndex === -1) return ".";
-  if (lastSepIndex === 0) return separator;
-  return normalized.slice(0, lastSepIndex);
+  const lastSeparatorIndex = normalized.lastIndexOf(separator);
+  if (lastSeparatorIndex === -1) return ".";
+  if (lastSeparatorIndex === 0) return separator;
+  return normalized.slice(0, lastSeparatorIndex);
 }
 function getBasename(path, ext, isWin) {
   if (path.length === 0) return "";
-  const lastSepIndex = isWin ? findLastSeparator(path) : path.lastIndexOf("/");
-  let base = lastSepIndex === -1 ? path : path.slice(lastSepIndex + 1);
+  const lastSeparatorIndex = isWin ? findLastSeparator(path) : path.lastIndexOf("/");
+  let base = lastSeparatorIndex === -1 ? path : path.slice(lastSeparatorIndex + 1);
   if (ext && base.endsWith(ext)) {
     base = base.slice(0, base.length - ext.length);
   }
@@ -188,8 +174,8 @@ function getBasename(path, ext, isWin) {
 }
 function getExtname(path) {
   const lastDotIndex = path.lastIndexOf(".");
-  const lastSepIndex = findLastSeparator(path);
-  if (lastDotIndex === -1 || lastDotIndex < lastSepIndex || lastDotIndex === path.length - 1) {
+  const lastSeparatorIndex = findLastSeparator(path);
+  if (lastDotIndex === -1 || lastDotIndex < lastSeparatorIndex || lastDotIndex === path.length - 1) {
     return "";
   }
   return path.slice(lastDotIndex);
@@ -205,10 +191,8 @@ function parsePath(path, isWin) {
     } else if (path[0] === "\\" || path[0] === "/") {
       root = "\\";
     }
-  } else {
-    if (path[0] === "/") {
-      root = "/";
-    }
+  } else if (path[0] === "/") {
+    root = "/";
   }
   const dir = getDirname(path, isWin);
   const base = getBasename(path, void 0, isWin);
@@ -224,6 +208,31 @@ function formatPath(pathObject, isWin) {
   if (dir === pathObject.root) return dir + base;
   return dir + separator + base;
 }
+function createPathOps(isWin) {
+  return {
+    sep: getSeparator(isWin),
+    delimiter: isWin ? ";" : ":",
+    normalize: (path) => normalizePath(path, isWin),
+    join: (...paths) => joinPaths(paths, isWin),
+    resolve: (...paths) => resolvePaths(paths, isWin),
+    isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
+    relative: (from, to) => relativePath(from, to, isWin),
+    dirname: (path) => getDirname(path, isWin),
+    basename: (path, ext) => getBasename(path, ext, isWin),
+    extname: (path) => getExtname(path),
+    parse: (path) => parsePath(path, isWin),
+    format: (pathObject) => formatPath(pathObject, isWin)
+  };
+}
+
+// src/server/path/runtime.ts
+function getRuntime() {
+  return runtime;
+}
+
+// src/server/path/index.ts
+var posix = createPathOps(false);
+var win32 = createPathOps(true);
 function normalize(path) {
   return normalizePath(path, isWindows);
 }
@@ -234,7 +243,7 @@ function resolve(...paths) {
   return resolvePaths(paths, isWindows);
 }
 function isAbsolute(path) {
-  return isWindows ? win32.isAbsolute(path) : posix.isAbsolute(path);
+  return isWindows ? isAbsoluteWin(path) : isAbsolutePosix(path);
 }
 function relative(from, to) {
   return relativePath(from, to, isWindows);
@@ -256,7 +265,7 @@ function format(pathObject) {
 }
 function toNamespacedPath(path) {
   if (!isWindows || path.length === 0) return path;
-  const resolved = resolve(path);
+  const resolved = resolvePaths([path], true);
   if (resolved.length >= 3) {
     if (resolved[0] === "\\") {
       if (resolved[1] === "\\" && resolved[2] !== "?") {
@@ -268,9 +277,6 @@ function toNamespacedPath(path) {
   }
   return path;
 }
-function getRuntime() {
-  return runtime;
-}
 var path_default = {
   sep,
   delimiter,

package/dist/pm-node-shared-listener-bootstrap.cjs

@@ -0,0 +1,75 @@
+const net = require('node:net');
+
+const mode = process.env.ELIT_PM_LISTEN_MODE;
+const publicPort = Number.parseInt(process.env.ELIT_PM_PUBLIC_PORT ?? '', 10);
+const originalListen = net.Server.prototype.listen;
+const state = {
+  handle: null,
+  waiters: [],
+};
+
+function sendMessage(message) {
+  if (typeof process.send === 'function') {
+    process.send(message);
+  }
+}
+
+function wantsSharedListener(args) {
+  if (mode !== 'ipc' || !Number.isInteger(publicPort)) {
+    return false;
+  }
+
+  const firstArg = args[0];
+  if (typeof firstArg === 'number') {
+    return firstArg === publicPort;
+  }
+
+  if (firstArg && typeof firstArg === 'object') {
+    if (typeof firstArg.fd === 'number') {
+      return false;
+    }
+
+    const requestedPort = typeof firstArg.port === 'number' ? firstArg.port : publicPort;
+    return requestedPort === publicPort;
+  }
+
+  return false;
+}
+
+function attachSharedHandle(server, args, handle) {
+  const callback = typeof args[args.length - 1] === 'function' ? args[args.length - 1] : undefined;
+  originalListen.call(server, handle, () => {
+    if (callback) {
+      callback();
+    }
+    sendMessage({ type: 'elit:pm:listener-ready' });
+  });
+}
+
+net.Server.prototype.listen = function patchedListen(...args) {
+  if (!wantsSharedListener(args)) {
+    return originalListen.apply(this, args);
+  }
+
+  if (state.handle) {
+    attachSharedHandle(this, args, state.handle);
+  } else {
+    state.waiters.push((handle) => attachSharedHandle(this, args, handle));
+  }
+
+  return this;
+};
+
+process.on('message', (message, handle) => {
+  if (!message || message.type !== 'elit:pm:listen-handle' || !handle) {
+    return;
+  }
+
+  state.handle = handle;
+  const waiters = state.waiters.splice(0);
+  for (const waiter of waiters) {
+    waiter(handle);
+  }
+});
+
+sendMessage({ type: 'elit:pm:bootstrap-ready' });