import {  HostProcessArchitecture,  HostProcessEnvironment,  HostProcessPlatform,} from "@t3tools/shared/hostProcess";import * as Context from "effect/Context";import * as Effect from "effect/Effect";import * as FileSystem from "effect/FileSystem";import * as Layer from "effect/Layer";import * as Option from "effect/Option";import * as Path from "effect/Path";import * as Schema from "effect/Schema"; import { ServerConfig } from "../config.ts"; export class ResourceMonitorBinaryUnsupported extends Schema.TaggedError<ResourceMonitorBinaryUnsupported>()(  "ResourceMonitorBinaryUnsupported",  {    platform: Schema.String,    architecture: Schema.String,  },) {  override get message(): string {    return `Resource monitoring is unsupported on ${this.platform}/${this.architecture}.`;  }} export class ResourceMonitorBinaryNotFound extends Schema.TaggedError<ResourceMonitorBinaryNotFound>()(  "ResourceMonitorBinaryNotFound",  {    platform: Schema.String,    architecture: Schema.String,    candidates: Schema.Array(Schema.String),  },) {  override get message(): string {    return `Resource monitor binary was not found for ${this.platform}/${this.architecture}.`;  }} export class ResourceMonitorBinaryNotExecutable extends Schema.TaggedError<ResourceMonitorBinaryNotExecutable>()(  "ResourceMonitorBinaryNotExecutable",  {    path: Schema.String,    mode: Schema.Number,  },) {  override get message(): string {    return `Resource monitor binary at '${this.path}' is not executable.`;  }} export type ResourceMonitorBinaryError =  | ResourceMonitorBinaryUnsupported  | ResourceMonitorBinaryNotFound  | ResourceMonitorBinaryNotExecutable; export class ResourceMonitorBinary extends Context.Service<  ResourceMonitorBinary,  {    readonly resolve: Effect.Effect<string, ResourceMonitorBinaryError>;  }>()("t3/resourceTelemetry/ResourceMonitorBinary") {} function binaryName(platform: NodeJS.Platform): string {  return platform === "win32" ? "t3-resource-monitor.exe" : "t3-resource-monitor";} export type ResourceMonitorLinuxLibc = "gnu" | "musl"; function detectResourceMonitorLinuxLibc(): ResourceMonitorLinuxLibc {  try {    const report = process.report?.getReport() as      | {          readonly header?: {            readonly glibcVersionRuntime?: unknown;          };        }      | undefined;    return typeof report?.header?.glibcVersionRuntime === "string" ? "gnu" : "musl";  } catch {    return "musl";  }} export const ResourceMonitorHostLinuxLibc = Context.Reference<ResourceMonitorLinuxLibc>(  "t3/resourceTelemetry/ResourceMonitorHostLinuxLibc",  {    defaultValue: detectResourceMonitorLinuxLibc,  },); function resourceMonitorPlatformKey(  platform: NodeJS.Platform,  architecture: NodeJS.Architecture,): string | undefined {  if (    (platform !== "darwin" && platform !== "linux" && platform !== "win32") ||    (architecture !== "arm64" && architecture !== "x64")  ) {    return undefined;  }  return `${platform}-${architecture}`;} function resourceMonitorRustTarget(  platform: NodeJS.Platform,  architecture: NodeJS.Architecture,  linuxLibc?: ResourceMonitorLinuxLibc,): string | undefined {  if (platform === "darwin") {    return architecture === "arm64"      ? "aarch64-apple-darwin"      : architecture === "x64"        ? "x86_64-apple-darwin"        : undefined;  }  if (platform === "linux") {    if (linuxLibc !== "gnu") {      return undefined;    }    return architecture === "arm64"      ? "aarch64-unknown-linux-gnu"      : architecture === "x64"        ? "x86_64-unknown-linux-gnu"        : undefined;  }  if (platform === "win32") {    return architecture === "arm64"      ? "aarch64-pc-windows-msvc"      : architecture === "x64"        ? "x86_64-pc-windows-msvc"        : undefined;  }  return undefined;} export const make = Effect.fn("resourceTelemetry.resourceMonitorBinary.make")(function* () {  const config = yield* ServerConfig;  const fileSystem = yield* FileSystem.FileSystem;  const path = yield* Path.Path;  const platform = yield* HostProcessPlatform;  const architecture = yield* HostProcessArchitecture;  const environment = yield* HostProcessEnvironment;  const linuxLibc = platform === "linux" ? yield* ResourceMonitorHostLinuxLibc : undefined;  const executableName = binaryName(platform);  const platformKey = resourceMonitorPlatformKey(platform, architecture);  const rustTarget = resourceMonitorRustTarget(platform, architecture, linuxLibc);  const overrideCandidates = [    environment.T3CODE_RESOURCE_MONITOR_PATH,    config.resourceMonitorPath,  ].filter((candidate): candidate is string => Boolean(candidate));  const bundledCandidates =    platformKey === undefined || rustTarget === undefined      ? []      : [          path.resolve(import.meta.dirname, "resource-monitor", platformKey, executableName),          path.resolve(import.meta.dirname, "resource-monitor", executableName),          path.resolve(import.meta.dirname, "../resource-monitor", executableName),          path.resolve(            import.meta.dirname,            "../../../../native/resource-monitor/target",            rustTarget,            "release",            executableName,          ),          path.resolve(            import.meta.dirname,            "../../../native/resource-monitor/target",            rustTarget,            "release",            executableName,          ),          path.resolve(            import.meta.dirname,            "../../../../native/resource-monitor/target/release",            executableName,          ),          path.resolve(            import.meta.dirname,            "../../../../native/resource-monitor/target/debug",            executableName,          ),        ];  if (overrideCandidates.length === 0 && bundledCandidates.length === 0) {    return ResourceMonitorBinary.of({      resolve: Effect.fail(        new ResourceMonitorBinaryUnsupported({          platform,          architecture,        }),      ),    });  }   const candidates = [...overrideCandidates, ...bundledCandidates];   const resolve: ResourceMonitorBinary["Service"]["resolve"] = Effect.gen(function* () {    for (const candidate of candidates) {      const exists = yield* fileSystem.exists(candidate).pipe(Effect.orElseSucceed(() => false));      if (!exists) continue;       if (platform !== "win32") {        const stat = yield* fileSystem.stat(candidate).pipe(Effect.option);        if (Option.isSome(stat) && (stat.value.mode & 0o111) === 0) {          return yield* new ResourceMonitorBinaryNotExecutable({            path: candidate,            mode: stat.value.mode,          });        }      }       return candidate;    }     return yield* new ResourceMonitorBinaryNotFound({      platform,      architecture,      candidates,    });  });   return ResourceMonitorBinary.of({ resolve });}); export const layer = Layer.effect(ResourceMonitorBinary, make());