import * as NodeServices from "@effect/platform-node/NodeServices";import { assert, describe, expect, it } from "@effect/vitest";import * as Effect from "effect/Effect";import * as FileSystem from "effect/FileSystem";import * as Schema from "effect/Schema";import * as Sink from "effect/Sink";import * as Stream from "effect/Stream";import { HttpClient, HttpClientResponse } from "effect/unstable/http";import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";import * as Generator from "./generate.ts"; const isDownloadError = Schema.is(Generator.AcpGeneratorDownloadError);const isDownloadFileError = Schema.is(Generator.AcpGeneratorDownloadFileError);const isDocumentDecodeError = Schema.is(Generator.AcpGeneratorDocumentDecodeError);const isFormatExitError = Schema.is(Generator.AcpGeneratorFormatExitError);const isSchemaNameParseError = Schema.is(Generator.AcpGeneratorSchemaNameParseError);const isSchemaValueDeclarationMissingError = Schema.is(  Generator.AcpGeneratorSchemaValueDeclarationMissingError,); const httpClient = (response: Response) =>  HttpClient.make((request) => Effect.succeed(HttpClientResponse.fromWeb(request, response))); function processHandle(exitCode: number) {  return ChildProcessSpawner.makeHandle({    pid: ChildProcessSpawner.ProcessId(1),    exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(exitCode)),    isRunning: Effect.succeed(false),    kill: () => Effect.void,    unref: Effect.succeed(Effect.void),    stdin: Sink.drain,    stdout: Stream.empty,    stderr: Stream.empty,    all: Stream.empty,    getInputFd: () => Sink.drain,    getOutputFd: () => Stream.empty,  });} describe("ACP schema generator errors", () => {  it.effect("retains safe URL diagnostics, output path, and HTTP cause when a download fails", () =>    Effect.gen(function* () {      const fs = yield* FileSystem.FileSystem;      const directory = yield* fs.makeTempDirectoryScoped({ prefix: "acp-generator-test-" });      const url =        "https://generator-user:generator-password@example.test/private/schema.json?token=generator-secret#fragment";      const outputPath = `${directory}/schema.json`;      const error = yield* Generator.downloadFile(url, outputPath).pipe(        Effect.provideService(          HttpClient.HttpClient,          httpClient(new Response("unavailable", { status: 503 })),        ),        Effect.flip,      );       assert(isDownloadError(error));      expect(error).toMatchObject({        urlInputLength: url.length,        urlProtocol: "https:",        urlHostname: "example.test",      });      expect(error).not.toHaveProperty("url");      expect(error.outputPath).toBe(outputPath);      expect(error.stage).toBe("request");      expect(error.cause).toBeDefined();      expect(error.message).toContain(outputPath);      const { cause: _, ...directDiagnostics } = error;      expect(directDiagnostics).not.toHaveProperty("url");      expect(directDiagnostics.urlProtocol).toBe("https:");      expect(directDiagnostics.urlHostname).toBe("example.test");      expect(error.message).not.toMatch(        /generator-user|generator-password|private|token|generator-secret|fragment/,      );    }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),  );   it.effect("retains download context when the response cannot be written", () =>    Effect.gen(function* () {      const fs = yield* FileSystem.FileSystem;      const outputPath = yield* fs.makeTempDirectoryScoped({ prefix: "acp-generator-test-" });      const url = "https://example.test/schema.json";      const error = yield* Generator.downloadFile(url, outputPath).pipe(        Effect.provideService(          HttpClient.HttpClient,          httpClient(new Response("{}", { status: 200 })),        ),        Effect.flip,      );       assert(isDownloadFileError(error));      expect(error).toMatchObject({        urlInputLength: url.length,        urlProtocol: "https:",        urlHostname: "example.test",      });      expect(error).not.toHaveProperty("url");      expect(error.outputPath).toBe(outputPath);      expect(error.stage).toBe("write-file");      expect(error.cause).toBeDefined();    }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),  );   it.effect("adds source file context to upstream document decode failures", () =>    Effect.gen(function* () {      const schemaPath = "/tmp/upstream-schema.json";      const schemaError = yield* Generator.decodeUpstreamSchemaDocument(        "not-json",        schemaPath,      ).pipe(Effect.flip);      assert(isDocumentDecodeError(schemaError));      expect(schemaError.document).toBe("schema");      expect(schemaError.filePath).toBe(schemaPath);      expect(schemaError.cause).toBeDefined();       const metadataPath = "/tmp/upstream-meta.json";      const metadataError = yield* Generator.decodeMetaDocument("not-json", metadataPath).pipe(        Effect.flip,      );      assert(isDocumentDecodeError(metadataError));      expect(metadataError.document).toBe("metadata");      expect(metadataError.filePath).toBe(metadataPath);      expect(metadataError.cause).toBeDefined();    }),  );   it.effect("reports formatter commands and nonzero exit codes structurally", () => {    let spawned: ChildProcess.StandardCommand | undefined;    const spawner = ChildProcessSpawner.make((command) => {      if (ChildProcess.isStandardCommand(command)) {        spawned = command;      }      return Effect.succeed(processHandle(23));    });     return Effect.gen(function* () {      const generatedDir = "/tmp/acp-generated";      const error = yield* Generator.formatGeneratedFiles(generatedDir).pipe(Effect.flip);       assert(isFormatExitError(error));      expect(error.command).toBe("bun");      expect(error.argumentCount).toBe(2);      expect(error).not.toHaveProperty("args");      expect(error.generatedDir).toBe(generatedDir);      expect(error.exitCode).toBe(23);      expect(error.message).toContain("23");      expect(spawned?.command).toBe("bun");      expect(spawned?.args).toEqual(["oxfmt", generatedDir]);    }).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner));  });   it.effect("returns malformed generated schema declarations as typed failures", () =>    Effect.gen(function* () {      const missingValueError = yield* Generator.collectSchemaEntries(        "export type Session = string;",      ).pipe(Effect.flip);      assert(isSchemaValueDeclarationMissingError(missingValueError));      expect(missingValueError).toMatchObject({        lineIndex: 0,        typeDeclarationLength: 29,        nextLinePresent: false,      });      expect(missingValueError).not.toHaveProperty("typeDeclaration");       const nameParseError = yield* Generator.collectSchemaEntries(        "export type @ = string;\nexport const invalid = Schema.String;",      ).pipe(Effect.flip);      assert(isSchemaNameParseError(nameParseError));      expect(nameParseError).toMatchObject({        lineIndex: 0,        typeDeclarationLength: 23,      });      expect(nameParseError).not.toHaveProperty("typeDeclaration");    }),  );});