@@ -13,6 +13,10 @@ const isGeneratorSchemaDocumentDecodeError = Schema.is(
   Generator.GeneratorSchemaDocumentDecodeError,
 );
 const isGeneratorFormatExitError = Schema.is(Generator.GeneratorFormatExitError);
+const isGeneratorSchemaNameParseError = Schema.is(Generator.GeneratorSchemaNameParseError);
+const isGeneratorSchemaValueDeclarationMissingError = Schema.is(
+  Generator.GeneratorSchemaValueDeclarationMissingError,
+);
 
 const httpClient = (response: Response) =>
   HttpClient.make((request) => Effect.succeed(HttpClientResponse.fromWeb(request, response)));
@@ -56,7 +60,10 @@ describe("Codex schema generator errors", () => {
       expect(error.stage).toBe("request");
       expect(error.cause).toBeDefined();
       const { cause: _, ...directDiagnostics } = error;
-      expect(JSON.stringify(directDiagnostics)).not.toMatch(
+      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/,
       );
     }),
@@ -132,4 +139,29 @@ describe("Codex schema generator errors", () => {
       expect(spawned?.args).toEqual(["fmt", generatedDir, "--write"]);
     }).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(isGeneratorSchemaValueDeclarationMissingError(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(isGeneratorSchemaNameParseError(nameParseError));
+      expect(nameParseError).toMatchObject({
+        lineIndex: 0,
+        typeDeclarationLength: 23,
+      });
+      expect(nameParseError).not.toHaveProperty("typeDeclaration");
+    }),
+  );
 });
@@ -149,19 +149,27 @@ export class GeneratorFormatExitError extends Schema.TaggedErrorClass<GeneratorF
 
 export class GeneratorSchemaValueDeclarationMissingError extends Schema.TaggedErrorClass<GeneratorSchemaValueDeclarationMissingError>()(
   "GeneratorSchemaValueDeclarationMissingError",
-  { typeDeclaration: Schema.String },
+  {
+    lineIndex: Schema.Number,
+    typeDeclarationLength: Schema.Number,
+    nextLinePresent: Schema.Boolean,
+    nextLineLength: Schema.optional(Schema.Number),
+  },
 ) {
   override get message(): string {
-    return `Generated schema type declaration has no following value declaration: ${this.typeDeclaration}`;
+    return `Generated schema type declaration at line ${this.lineIndex + 1} has no following value declaration.`;
   }
 }
 
 export class GeneratorSchemaNameParseError extends Schema.TaggedErrorClass<GeneratorSchemaNameParseError>()(
   "GeneratorSchemaNameParseError",
-  { typeDeclaration: Schema.String },
+  {
+    lineIndex: Schema.Number,
+    typeDeclarationLength: Schema.Number,
+  },
 ) {
   override get message(): string {
-    return `Could not extract a schema name from generated declaration: ${this.typeDeclaration}`;
+    return `Could not extract a schema name from generated declaration at line ${this.lineIndex + 1}.`;
   }
 }
 
@@ -383,9 +391,7 @@ export const formatGeneratedFiles = Effect.fn("formatGeneratedFiles")(function*
   }
 });
 
-function collectSchemaEntries(
-  chunk: string,
-): ReadonlyArray<{ readonly name: string; readonly code: string }> {
+export const collectSchemaEntries = Effect.fn("collectSchemaEntries")(function* (chunk: string) {
   const lines = chunk
     .split("\n")
     .map((line) => line.trim())
@@ -400,12 +406,20 @@ function collectSchemaEntries(
 
     const constLine = lines[index + 1];
     if (!constLine?.startsWith("export const ")) {
-      throw new GeneratorSchemaValueDeclarationMissingError({ typeDeclaration: typeLine });
+      return yield* new GeneratorSchemaValueDeclarationMissingError({
+        lineIndex: index,
+        typeDeclarationLength: typeLine.length,
+        nextLinePresent: constLine !== undefined,
+        ...(constLine === undefined ? {} : { nextLineLength: constLine.length }),
+      });
     }
 
     const match = /^export type ([A-Za-z0-9_]+)/.exec(typeLine);
     if (!match?.[1]) {
-      throw new GeneratorSchemaNameParseError({ typeDeclaration: typeLine });
+      return yield* new GeneratorSchemaNameParseError({
+        lineIndex: index,
+        typeDeclarationLength: typeLine.length,
+      });
     }
 
     entries.push({
@@ -416,7 +430,7 @@ function collectSchemaEntries(
   }
 
   return entries;
-}
+});
 
 function normalizeNullableTypes(value: Schema.Json): Schema.Json {
   if (Array.isArray(value)) {
@@ -811,7 +825,8 @@ const generateFiles = Effect.fn("generateFiles")(function* () {
   const generatedEntries = new Map<string, string>();
   const output = generator.generate("openapi-3.1", aggregateSchemas as never, false).trim();
   if (output.length > 0) {
-    for (const entry of collectSchemaEntries(output)) {
+    const schemaEntries = yield* collectSchemaEntries(output);
+    for (const entry of schemaEntries) {
       if (!generatedEntries.has(entry.name)) {
         generatedEntries.set(entry.name, entry.code);
       }