@effect/language-service 0.61.0 → 0.62.0

package/cli.js

@@ -21014,14 +21014,14 @@ var foldChunksReader = (s, contFn, f) => {
 };
 var foldLeftChunks = (s, f) => foldChunks(s, constTrue, f);
 var forEach9 = (f) => {
-  const process2 = readWithCause({
+  const process3 = readWithCause({
     onInput: (input) => pipe(fromEffect4(forEach8(input, (v) => f(v), {
       discard: true
-    })), flatMap12(() => process2)),
+    })), flatMap12(() => process3)),
     onFailure: failCause8,
     onDone: () => void_5
   });
-  return new SinkImpl(process2);
+  return new SinkImpl(process3);
 };
 var fromChannel = (channel) => new SinkImpl(channel);
 var fromEffect6 = (effect3) => new SinkImpl(fromEffect4(effect3));
@@ -21279,12 +21279,12 @@ var bufferChunks = /* @__PURE__ */ dual(2, (self, options3) => {
   }
   const queue = toQueue(self, options3);
   return new StreamImpl(unwrapScoped2(map17(queue, (queue2) => {
-    const process2 = pipe(fromEffect4(take3(queue2)), flatMap12(match16({
+    const process3 = pipe(fromEffect4(take3(queue2)), flatMap12(match16({
       onEnd: () => void_5,
       onFailure: failCause8,
-      onSuccess: (value5) => pipe(write(value5), flatMap12(() => process2))
+      onSuccess: (value5) => pipe(write(value5), flatMap12(() => process3))
     })));
-    return process2;
+    return process3;
   })));
 });
 var bufferChunksDropping = /* @__PURE__ */ dual(2, (self, capacity3) => {
@@ -21305,12 +21305,12 @@ var bufferSignal = (scoped6, bufferChannel) => {
     });
   };
   const consumer = (queue) => {
-    const process2 = pipe(fromEffect4(take3(queue)), flatMap12(([take6, deferred]) => zipRight4(fromEffect4(succeed6(deferred, void 0)), match16(take6, {
+    const process3 = pipe(fromEffect4(take3(queue)), flatMap12(([take6, deferred]) => zipRight4(fromEffect4(succeed6(deferred, void 0)), match16(take6, {
       onEnd: () => void_5,
       onFailure: failCause8,
-      onSuccess: (value5) => pipe(write(value5), flatMap12(() => process2))
+      onSuccess: (value5) => pipe(write(value5), flatMap12(() => process3))
     }))));
-    return process2;
+    return process3;
   };
   return unwrapScoped2(pipe(scoped6, flatMap9((queue) => pipe(make38(), tap2((start4) => succeed6(start4, void 0)), flatMap9((start4) => pipe(make25(start4), flatMap9((ref) => pipe(bufferChannel, pipeTo(producer(queue, ref)), runScoped, forkScoped2)), as4(consumer(queue))))))));
 };
@@ -23772,9 +23772,9 @@ var resolve = function resolve2() {
     if (i >= 0) {
       path2 = arguments[i];
     } else {
-      const process2 = globalThis.process;
-      if (cwd === void 0 && "process" in globalThis && typeof process2 === "object" && process2 !== null && typeof process2.cwd === "function") {
-        cwd = process2.cwd();
+      const process3 = globalThis.process;
+      if (cwd === void 0 && "process" in globalThis && typeof process3 === "object" && process3 !== null && typeof process3.cwd === "function") {
+        cwd = process3.cwd();
       }
       path2 = cwd;
     }
@@ -28305,7 +28305,7 @@ var ExitCode = /* @__PURE__ */ nominal();
 var ProcessId = /* @__PURE__ */ nominal();
 var CommandExecutor = /* @__PURE__ */ GenericTag("@effect/platform/CommandExecutor");
 var makeExecutor = (start4) => {
-  const stream3 = (command) => unwrapScoped6(map17(start4(command), (process2) => process2.stdout));
+  const stream3 = (command) => unwrapScoped6(map17(start4(command), (process3) => process3.stdout));
   const streamLines2 = (command, encoding) => {
     const decoder2 = new TextDecoder(encoding);
     return splitLines3(mapChunks2(stream3(command), map5((bytes) => decoder2.decode(bytes))));
@@ -28313,11 +28313,11 @@ var makeExecutor = (start4) => {
   return {
     [TypeId24]: TypeId24,
     start: start4,
-    exitCode: (command) => scoped2(flatMap9(start4(command), (process2) => process2.exitCode)),
+    exitCode: (command) => scoped2(flatMap9(start4(command), (process3) => process3.exitCode)),
     stream: stream3,
     string: (command, encoding = "utf-8") => {
       const decoder2 = new TextDecoder(encoding);
-      return pipe(start4(command), flatMap9((process2) => run4(process2.stdout, collectUint8Array)), map17((bytes) => decoder2.decode(bytes)), scoped2);
+      return pipe(start4(command), flatMap9((process3) => run4(process3.stdout, collectUint8Array)), map17((bytes) => decoder2.decode(bytes)), scoped2);
     },
     lines: (command, encoding = "utf-8") => {
       return pipe(streamLines2(command, encoding), runCollect3, map17(toArray2));
@@ -28662,7 +28662,7 @@ var runCommand = (fileSystem) => (command) => {
             stdout: stdout2
           });
         }),
-        typeof command.stdin === "string" ? identity : tap2((process2) => forkDaemon2(run4(command.stdin, process2.stdin)))
+        typeof command.stdin === "string" ? identity : tap2((process3) => forkDaemon2(run4(command.stdin, process3.stdin)))
       );
     }
     case "PipedCommand": {
@@ -28674,7 +28674,7 @@ var runCommand = (fileSystem) => (command) => {
       const tail = flattened2.slice(1);
       const initial = tail.slice(0, tail.length - 1);
       const last5 = tail[tail.length - 1];
-      const stream3 = initial.reduce((stdin3, command2) => pipe(stdin2(command2, stdin3), runCommand(fileSystem), map17((process2) => process2.stdout), unwrapScoped6), pipe(runCommand(fileSystem)(head5), map17((process2) => process2.stdout), unwrapScoped6));
+      const stream3 = initial.reduce((stdin3, command2) => pipe(stdin2(command2, stdin3), runCommand(fileSystem), map17((process3) => process3.stdout), unwrapScoped6), pipe(runCommand(fileSystem)(head5), map17((process3) => process3.stdout), unwrapScoped6));
       return pipe(stdin2(last5, stream3), runCommand(fileSystem));
     }
   }
@@ -31677,6 +31677,9 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
   function isThisTypeParameter(type2) {
     return !!(type2.flags & ts.TypeFlags.TypeParameter && type2.isThisType);
   }
+  function isMissingIntrinsicType(type2) {
+    return (type2.flags & ts.TypeFlags.Undefined) !== 0 && "debugIntrinsicName" in type2 && type2.debugIntrinsicName === "missing";
+  }
   function getTypeParameterAtPosition(signature, pos) {
     const type2 = typeChecker.getParameterType(signature, pos);
     if (isIndexType(type2) && isThisTypeParameter(type2.type)) {
@@ -31981,6 +31984,7 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
   }
   return {
     isUnion: isUnion4,
+    isMissingIntrinsicType,
     getTypeParameterAtPosition,
     getMissingTypeEntriesInTargetType,
     unrollUnionMembers,
@@ -33537,8 +33541,662 @@ var annotate3 = createCodegen({
   })
 });
 
+// src/utils/StructuralSchemaGen.ts
+var UnsupportedTypeError = class {
+  constructor(type2, reason) {
+    this.type = type2;
+    this.reason = reason;
+  }
+  _tag = "@effect/language-service/UnsupportedTypeError";
+  toString() {
+    return `Unsupported type: ${this.reason}`;
+  }
+};
+var StructuralSchemaGenContext = Tag4("StructuralSchemaGenContext");
+var makeStructuralSchemaGenContext = fn2("StructuralSchemaGen.makeContext")(
+  function* (sourceFile, schemaIdentifier) {
+    const ts = yield* service2(TypeScriptApi);
+    const program = yield* service2(TypeScriptProgram);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const typeCheckerUtils = yield* service2(TypeCheckerUtils);
+    const effectSchemaIdentifier = schemaIdentifier || "Schema";
+    return identity({
+      ts,
+      program,
+      typeChecker,
+      typeCheckerUtils,
+      sourceFile,
+      createApiPropertyAccess: (apiName) => ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(effectSchemaIdentifier),
+        apiName
+      ),
+      createApiCall: (apiName, args3) => ts.factory.createCallExpression(
+        ts.factory.createPropertyAccessExpression(
+          ts.factory.createIdentifier(effectSchemaIdentifier),
+          apiName
+        ),
+        [],
+        args3
+      ),
+      hoistedSchemas: /* @__PURE__ */ new Map(),
+      typeToStatementIndex: /* @__PURE__ */ new Map(),
+      nameToType: /* @__PURE__ */ new Map(),
+      usedGlobalIdentifiers: /* @__PURE__ */ new Map(),
+      schemaStatements: [],
+      rangesToDelete: []
+    });
+  }
+);
+var pushHoistedStatement = fn2("StructuralSchemaGen.pushHoistedStatement")(
+  function* (ctx, name, type2, statement, createReference) {
+    ctx.usedGlobalIdentifiers.set(name, (ctx.usedGlobalIdentifiers.get(name) || 0) + 1);
+    ctx.schemaStatements.push(statement);
+    ctx.typeToStatementIndex.set(type2, ctx.schemaStatements.length - 1);
+    ctx.hoistedSchemas.set(type2, createReference);
+  }
+);
+var pushHoistedVariableStatement = fn2("StructuralSchemaGen.pushHoistedVariableStatement")(
+  function* (ts, ctx, name, type2, result) {
+    return yield* pushHoistedStatement(
+      ctx,
+      name,
+      type2,
+      ts.factory.createVariableStatement(
+        void 0,
+        ts.factory.createVariableDeclarationList(
+          [ts.factory.createVariableDeclaration(ts.factory.createIdentifier(name), void 0, void 0, result)],
+          ts.NodeFlags.Const
+        )
+      ),
+      () => ts.factory.createIdentifier(name)
+    );
+  }
+);
+var createProcessingContext = (maxDepth = 200) => ({
+  depth: 0,
+  maxDepth,
+  hoistName: void 0
+});
+var processType = fn2(
+  "StructuralSchemaGen.processType"
+)(
+  function* (type2, context7) {
+    const processingContext = context7 || createProcessingContext();
+    const { hoistedSchemas, nameToType, ts, typeChecker, usedGlobalIdentifiers } = yield* service2(
+      StructuralSchemaGenContext
+    );
+    if (processingContext.depth >= processingContext.maxDepth) {
+      return yield* fail18(new UnsupportedTypeError(type2, "Maximum depth exceeded"));
+    }
+    let hoistName = fromIterable(nameToType.entries()).find(([_, existingType]) => existingType === type2)?.[0];
+    if (!hoistName && type2 && type2.symbol && type2.symbol.declarations && type2.symbol.declarations.length === 1) {
+      const declaration = type2.symbol.declarations[0];
+      if (ts.isInterfaceDeclaration(declaration)) {
+        hoistName = ts.idText(declaration.name);
+      } else if (declaration.parent && ts.isTypeAliasDeclaration(declaration.parent)) {
+        hoistName = ts.idText(declaration.parent.name);
+      }
+      if (hoistName) {
+        const existingType = nameToType.get(hoistName);
+        const isSame = existingType && typeChecker.isTypeAssignableTo(type2, existingType) && typeChecker.isTypeAssignableTo(existingType, type2);
+        if (!isSame) {
+          const usedCount = usedGlobalIdentifiers.get(hoistName) || 0;
+          hoistName = usedCount > 0 ? hoistName + "_" + usedCount : hoistName;
+        }
+      }
+    }
+    const nestedContext = {
+      ...processingContext,
+      depth: processingContext.depth + 1,
+      hoistName
+    };
+    for (const [hoistedType, hoistedSchema] of hoistedSchemas.entries()) {
+      if (hoistedType === type2 || typeChecker.isTypeAssignableTo(type2, hoistedType) && typeChecker.isTypeAssignableTo(hoistedType, type2)) {
+        return hoistedSchema();
+      }
+    }
+    const [schemaExpr, skipHoisting] = yield* processTypeImpl(type2, nestedContext);
+    if (!skipHoisting && hoistName) {
+      const ctx = yield* service2(StructuralSchemaGenContext);
+      yield* pushHoistedVariableStatement(ts, ctx, hoistName, type2, schemaExpr);
+      return ctx.hoistedSchemas.get(type2)();
+    }
+    return schemaExpr;
+  }
+);
+var processTypeImpl = fn2(
+  "StructuralSchemaGen.processTypeImpl"
+)(
+  function* (type2, context7) {
+    const { createApiCall, createApiPropertyAccess, ts, typeChecker, typeCheckerUtils } = yield* service2(
+      StructuralSchemaGenContext
+    );
+    if (type2.flags & ts.TypeFlags.String) {
+      return [createApiPropertyAccess("String"), true];
+    }
+    if (type2.flags & ts.TypeFlags.Number) {
+      return [createApiPropertyAccess("Number"), true];
+    }
+    if (type2.flags & ts.TypeFlags.Boolean) {
+      return [createApiPropertyAccess("Boolean"), true];
+    }
+    if (type2.flags & ts.TypeFlags.BigInt) {
+      return [createApiPropertyAccess("BigInt"), true];
+    }
+    if (type2.flags & ts.TypeFlags.Void) {
+      return [createApiPropertyAccess("Void"), true];
+    }
+    if (type2.flags & ts.TypeFlags.Undefined) {
+      return [createApiPropertyAccess("Undefined"), true];
+    }
+    if (type2.flags & ts.TypeFlags.Null) {
+      return [createApiPropertyAccess("Null"), true];
+    }
+    if (type2.flags & ts.TypeFlags.Never) {
+      return [createApiPropertyAccess("Never"), true];
+    }
+    if (type2.flags & ts.TypeFlags.Any) {
+      return [createApiPropertyAccess("Any"), true];
+    }
+    if (type2.flags & ts.TypeFlags.Unknown) {
+      return [createApiPropertyAccess("Unknown"), true];
+    }
+    if (type2.flags & ts.TypeFlags.StringLiteral) {
+      const literalType = type2;
+      return [createApiCall("Literal", [ts.factory.createStringLiteral(literalType.value)]), true];
+    }
+    if (type2.flags & ts.TypeFlags.NumberLiteral) {
+      const literalType = type2;
+      return [createApiCall("Literal", [ts.factory.createNumericLiteral(literalType.value)]), true];
+    }
+    if (type2.flags & ts.TypeFlags.BooleanLiteral) {
+      const value5 = type2.intrinsicName === "true";
+      return [createApiCall("Literal", [value5 ? ts.factory.createTrue() : ts.factory.createFalse()]), true];
+    }
+    if (typeCheckerUtils.isUnion(type2)) {
+      return yield* processUnionType(type2.types, context7);
+    }
+    if (type2.flags & ts.TypeFlags.Intersection) {
+      return yield* processIntersectionType(type2, context7);
+    }
+    if (typeChecker.isArrayType(type2)) {
+      return yield* processArrayType(type2, context7);
+    }
+    if (typeChecker.isTupleType(type2)) {
+      return yield* processTupleType(type2, context7);
+    }
+    if (type2.flags & ts.TypeFlags.Object) {
+      const symbol3 = type2.symbol || type2.aliasSymbol;
+      if (symbol3) {
+        const typeName = typeChecker.symbolToString(symbol3);
+        if (typeName === "Date") {
+          return [createApiPropertyAccess("Date"), false];
+        }
+        if (typeName === "ReadonlyArray" || typeName === "Array") {
+          return yield* processArrayType(type2, context7);
+        }
+      }
+      const objectType = type2;
+      return yield* processObjectType(objectType, context7);
+    }
+    return yield* fail18(
+      new UnsupportedTypeError(
+        type2,
+        `Type with flags ${type2.flags} is not supported`
+      )
+    );
+  }
+);
+var processUnionType = fn2(
+  "StructuralSchemaGen.processUnionType"
+)(
+  function* (types, context7) {
+    const { createApiCall, ts } = yield* service2(StructuralSchemaGenContext);
+    const allLiterals = types.every(
+      (t) => t.flags & ts.TypeFlags.StringLiteral || t.flags & ts.TypeFlags.NumberLiteral || t.flags & ts.TypeFlags.BooleanLiteral
+    );
+    if (allLiterals) {
+      const literals = yield* all9(
+        ...types.map((t) => processType(t, context7))
+      );
+      const literalValues = literals.map((expr) => {
+        if (ts.isCallExpression(expr) && expr.arguments.length > 0) {
+          return expr.arguments[0];
+        }
+        return expr;
+      }).filter((arg) => arg !== void 0);
+      return [createApiCall("Literal", literalValues), false];
+    }
+    const members = yield* all9(
+      ...types.map((t) => processType(t, context7))
+    );
+    if (members.length === 1) {
+      return [members[0], false];
+    }
+    return [createApiCall("Union", members), false];
+  }
+);
+var processIntersectionType = fn2(
+  "StructuralSchemaGen.processIntersectionType"
+)(
+  function* (type2, context7) {
+    const { createApiCall, ts } = yield* service2(StructuralSchemaGenContext);
+    const [firstSchema, ...otherSchemas] = yield* all9(
+      ...type2.types.map((t) => processType(t, context7))
+    );
+    if (otherSchemas.length === 0) {
+      return [firstSchema, false];
+    }
+    return [
+      ts.factory.createCallExpression(
+        ts.factory.createPropertyAccessExpression(
+          firstSchema,
+          "pipe"
+        ),
+        [],
+        otherSchemas.map((schema) => createApiCall("extend", [schema]))
+      ),
+      false
+    ];
+  }
+);
+var processArrayType = fn2(
+  "StructuralSchemaGen.processArrayType"
+)(
+  function* (type2, context7) {
+    const { createApiCall, typeChecker } = yield* service2(StructuralSchemaGenContext);
+    const typeArgs = typeChecker.getTypeArguments(type2);
+    if (typeArgs.length === 0) {
+      return yield* fail18(new UnsupportedTypeError(type2, "Array type has no type arguments"));
+    }
+    const elementSchema = yield* processType(typeArgs[0], context7);
+    return [createApiCall("Array", [elementSchema]), false];
+  }
+);
+var processTupleType = fn2(
+  "StructuralSchemaGen.processTupleType"
+)(
+  function* (type2, context7) {
+    const { createApiCall, typeChecker } = yield* service2(StructuralSchemaGenContext);
+    const typeArgs = typeChecker.getTypeArguments(type2);
+    const elementSchemas = yield* all9(
+      ...typeArgs.map((t) => processType(t, context7))
+    );
+    return [createApiCall("Tuple", elementSchemas), false];
+  }
+);
+var processObjectType = fn2(
+  "StructuralSchemaGen.processObjectType"
+)(
+  function* (type2, context7) {
+    const {
+      createApiCall,
+      createApiPropertyAccess,
+      program,
+      ts,
+      typeChecker,
+      typeCheckerUtils
+    } = yield* service2(
+      StructuralSchemaGenContext
+    );
+    let hasRecords = false;
+    const properties = typeChecker.getPropertiesOfType(type2);
+    const propertyAssignments = [];
+    for (const property of properties) {
+      const propertyName = typeChecker.symbolToString(property);
+      const propertyType = typeChecker.getTypeOfSymbol(property);
+      const isOptional = (property.flags & ts.SymbolFlags.Optional) !== 0;
+      let schemaExpr;
+      if (isOptional) {
+        if (program.getCompilerOptions().exactOptionalPropertyTypes) {
+          if (typeCheckerUtils.isUnion(propertyType)) {
+            const typeWithoutMissing = propertyType.types.filter((t) => !typeCheckerUtils.isMissingIntrinsicType(t));
+            const [result, _] = yield* processUnionType(typeWithoutMissing, context7);
+            schemaExpr = createApiCall("optionalWith", [
+              result,
+              ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment("exact", ts.factory.createTrue())
+              ])
+            ]);
+          }
+        } else {
+          schemaExpr = yield* processType(propertyType, context7);
+          schemaExpr = createApiCall("optional", [schemaExpr]);
+        }
+      }
+      if (!schemaExpr) {
+        schemaExpr = yield* processType(propertyType, context7);
+      }
+      const propertyNameNode = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(propertyName) ? ts.factory.createIdentifier(propertyName) : ts.factory.createStringLiteral(propertyName);
+      propertyAssignments.push(
+        ts.factory.createPropertyAssignment(
+          propertyNameNode,
+          schemaExpr
+        )
+      );
+    }
+    const indexInfos = typeChecker.getIndexInfosOfType(type2);
+    const args3 = [
+      ts.factory.createObjectLiteralExpression(propertyAssignments, propertyAssignments.length > 0)
+    ];
+    for (const indexInfo of indexInfos) {
+      hasRecords = true;
+      const keyType = indexInfo.keyType;
+      const valueType = indexInfo.type;
+      const keySchema = yield* processType(keyType, context7);
+      const valueSchema = yield* processType(valueType, context7);
+      args3.push(
+        ts.factory.createObjectLiteralExpression([
+          ts.factory.createPropertyAssignment("key", keySchema),
+          ts.factory.createPropertyAssignment("value", valueSchema)
+        ])
+      );
+    }
+    if (!hasRecords && context7.hoistName) {
+      const ctx = yield* service2(StructuralSchemaGenContext);
+      yield* pushHoistedStatement(
+        ctx,
+        context7.hoistName,
+        type2,
+        ts.factory.createClassDeclaration(
+          void 0,
+          ts.factory.createIdentifier(context7.hoistName),
+          [],
+          [ts.factory.createHeritageClause(
+            ts.SyntaxKind.ExtendsKeyword,
+            [
+              ts.factory.createExpressionWithTypeArguments(
+                ts.factory.createCallExpression(
+                  ts.factory.createCallExpression(
+                    createApiPropertyAccess("Class"),
+                    [ts.factory.createTypeReferenceNode(
+                      context7.hoistName
+                    )],
+                    [ts.factory.createStringLiteral(context7.hoistName)]
+                  ),
+                  [],
+                  args3
+                ),
+                []
+              )
+            ]
+          )],
+          []
+        ),
+        () => ts.factory.createIdentifier(context7.hoistName)
+      );
+      return [ctx.hoistedSchemas.get(type2)(), true];
+    }
+    return [createApiCall("Struct", args3), propertyAssignments.length === 0];
+  }
+);
+var findNodeToProcess = fn2("StructuralSchemaGen.findNodeToProcess")(
+  function* (sourceFile, textRange) {
+    const ts = yield* service2(TypeScriptApi);
+    const tsUtils = yield* service2(TypeScriptUtils);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    return pipe(
+      tsUtils.getAncestorNodesInRange(sourceFile, textRange),
+      filter2((node) => ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)),
+      filter2((node) => tsUtils.isNodeInRange(textRange)(node.name)),
+      filter2((node) => (node.typeParameters || []).length === 0),
+      map4((node) => ({
+        node,
+        identifier: node.name,
+        type: typeChecker.getTypeAtLocation(node.name),
+        isExported: node.modifiers ? (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export) !== 0 : false
+      })),
+      filter2(({ type: type2 }) => !!type2),
+      head
+    );
+  }
+);
+var process2 = fn2("StructuralSchemaGen.process")(
+  function* (sourceFile, scope4, typeMap, isExported, handleCodegeneratedComments) {
+    const ts = yield* service2(TypeScriptApi);
+    const tsUtils = yield* service2(TypeScriptUtils);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const typeParser = yield* service2(TypeParser);
+    const schemaIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Schema") || "Schema";
+    const ctx = yield* makeStructuralSchemaGenContext(sourceFile, schemaIdentifier);
+    for (const [name, type2] of typeMap.entries()) {
+      ctx.nameToType.set(name, type2);
+    }
+    if (handleCodegeneratedComments) {
+      for (const declaration of sourceFile.statements) {
+        const nodeText = sourceFile.text.slice(declaration.pos, declaration.end);
+        if (!nodeText.toLowerCase().includes("@effect-schema-codegenerated")) continue;
+        const interleavingRange = ctx.rangesToDelete.find(
+          (range3) => range3.pos < declaration.end && range3.end > declaration.pos
+        );
+        if (interleavingRange) {
+          interleavingRange.pos = Math.min(interleavingRange.pos, declaration.pos);
+          interleavingRange.end = Math.max(interleavingRange.end, declaration.end);
+        } else {
+          ctx.rangesToDelete.push({
+            pos: declaration.pos,
+            end: declaration.end
+          });
+        }
+      }
+    }
+    for (const symbol3 of typeChecker.getSymbolsInScope(scope4, ts.SymbolFlags.Value)) {
+      const name = typeChecker.symbolToString(symbol3);
+      ctx.usedGlobalIdentifiers.set(name, 1);
+      const type2 = typeChecker.getTypeOfSymbolAtLocation(symbol3, sourceFile);
+      if (type2) {
+        const schemaType = yield* pipe(
+          typeParser.effectSchemaType(type2, scope4),
+          orElse14(() => void_8)
+        );
+        if (schemaType) {
+          ctx.hoistedSchemas.set(
+            schemaType.A,
+            () => {
+              const expression = typeChecker.symbolToExpression(
+                symbol3,
+                ts.SymbolFlags.Value,
+                scope4,
+                ts.NodeBuilderFlags.NoTruncation
+              );
+              if (expression) {
+                return expression;
+              }
+              return ts.factory.createIdentifier(name);
+            }
+          );
+        }
+      }
+    }
+    const results = yield* pipe(
+      all9(
+        ...fromIterable(ctx.nameToType.entries()).map(
+          ([name, type2]) => pipe(
+            processType(type2),
+            orElse14(
+              (error4) => succeed17(ts.addSyntheticLeadingComment(
+                ts.factory.createIdentifier(""),
+                ts.SyntaxKind.MultiLineCommentTrivia,
+                " " + String(error4) + " ",
+                true
+              ))
+            ),
+            map34((_) => ({ requestedName: name, type: type2, result: _ }))
+          )
+        )
+      ),
+      provideService7(StructuralSchemaGenContext, ctx)
+    );
+    for (const { requestedName, result, type: type2 } of results) {
+      const statementIndex = ctx.typeToStatementIndex.get(type2);
+      if (statementIndex !== void 0) continue;
+      ctx.schemaStatements.push(ts.factory.createVariableStatement(
+        [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+        ts.factory.createVariableDeclarationList(
+          [ts.factory.createVariableDeclaration(
+            ts.factory.createIdentifier(requestedName),
+            void 0,
+            void 0,
+            result
+          )],
+          ts.NodeFlags.Const
+        )
+      ));
+      ctx.typeToStatementIndex.set(type2, ctx.schemaStatements.length - 1);
+    }
+    if (isExported) {
+      const statementsToExport = pipe(
+        fromIterable(ctx.nameToType),
+        map4(([_, type2]) => ctx.typeToStatementIndex.get(type2)),
+        filter2((index) => index !== void 0),
+        dedupe
+      );
+      for (let i = 0; i < ctx.schemaStatements.length; i++) {
+        if (!statementsToExport.includes(i)) continue;
+        const statement = ctx.schemaStatements[i];
+        if (ts.isVariableStatement(statement)) {
+          ctx.schemaStatements[i] = ts.factory.updateVariableStatement(
+            statement,
+            ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export),
+            statement.declarationList
+          );
+        } else if (ts.isClassDeclaration(statement)) {
+          ctx.schemaStatements[i] = ts.factory.updateClassDeclaration(
+            statement,
+            ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export),
+            statement.name,
+            statement.typeParameters,
+            statement.heritageClauses,
+            statement.members
+          );
+        }
+      }
+    }
+    if (handleCodegeneratedComments) {
+      for (let i = 0; i < ctx.schemaStatements.length; i++) {
+        const statement = ctx.schemaStatements[i];
+        ctx.schemaStatements[i] = ts.addSyntheticLeadingComment(
+          statement,
+          ts.SyntaxKind.SingleLineCommentTrivia,
+          " @effect-schema-codegenerated: This schema will be re-generated by the effect-schema-codegens command, remove this comment to disable re-generation.",
+          true
+        );
+      }
+    }
+    return ctx;
+  }
+);
+var applyAtNode = fn2("StructuralSchemaGen.applyAtNode")(
+  function* (sourceFile, node, identifier2, type2, isExported) {
+    const changeTracker = yield* service2(ChangeTracker);
+    const ts = yield* service2(TypeScriptApi);
+    const ctx = yield* process2(sourceFile, node, /* @__PURE__ */ new Map([[ts.idText(identifier2), type2]]), isExported, false);
+    for (const statement of ctx.schemaStatements) {
+      changeTracker.insertNodeAt(sourceFile, node.pos, statement, { prefix: "\n", suffix: "\n" });
+    }
+  }
+);
+
+// src/codegens/typeToSchema.ts
+var typeToSchema = createCodegen({
+  name: "typeToSchema",
+  apply: fn2("typeToSchema.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service2(TypeScriptApi);
+    const tsUtils = yield* service2(TypeScriptUtils);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const typeCheckerUtils = yield* service2(TypeCheckerUtils);
+    const typeParser = yield* service2(TypeParser);
+    const program = yield* service2(TypeScriptProgram);
+    const inThisFile = yield* getCodegensForSourceFile([typeToSchema], sourceFile);
+    if (inThisFile.length > 1) {
+      return yield* fail18(
+        new CodegenNotApplicableError("the typeToSchema codegen can be used only once per file")
+      );
+    }
+    const parse6 = (node) => gen3(function* () {
+      if (!ts.isTypeAliasDeclaration(node)) {
+        return yield* fail18(
+          new CodegenNotApplicableError(
+            "this codegen is applicable only to a type alias where each object member is a schema to generate. e.g. `type ToGenerate = { UserSchema: User, TodoSchema: Todo}`"
+          )
+        );
+      }
+      const type2 = typeChecker.getTypeAtLocation(node.name);
+      if (!type2) {
+        return yield* fail18(
+          new CodegenNotApplicableError(
+            "error getting the type to process"
+          )
+        );
+      }
+      const nameToType = /* @__PURE__ */ new Map();
+      const typeProperties = typeChecker.getPropertiesOfType(type2);
+      for (const symProp of typeProperties) {
+        const symName = ts.symbolName(symProp);
+        const propType = typeChecker.getTypeOfSymbolAtLocation(symProp, node);
+        if (propType) nameToType.set(symName, propType);
+      }
+      const hash2 = pipe(
+        fromIterable(nameToType),
+        map4(([name, type3]) => {
+          const typeString = typeChecker.typeToString(
+            type3,
+            node,
+            ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseStructuralFallback
+          );
+          return name + ": " + typeString;
+        }),
+        join("\n"),
+        cyrb53
+      );
+      return {
+        hash: hash2,
+        nameToType
+      };
+    });
+    const nodeAndCommentRange = tsUtils.findNodeWithLeadingCommentAtPosition(sourceFile, textRange.pos);
+    if (!nodeAndCommentRange) {
+      return yield* fail18(new CodegenNotApplicableError("no node and comment range affected"));
+    }
+    return yield* pipe(
+      parse6(nodeAndCommentRange.node),
+      map34(
+        (_) => ({
+          hash: _.hash,
+          description: "Generate Schemas from types",
+          apply: pipe(
+            gen3(function* () {
+              const changeTracker = yield* service2(ChangeTracker);
+              const ctx = yield* process2(
+                sourceFile,
+                nodeAndCommentRange.node,
+                _.nameToType,
+                true,
+                true
+              );
+              const pos = sourceFile.end;
+              for (const range3 of ctx.rangesToDelete) {
+                changeTracker.deleteRange(sourceFile, range3);
+              }
+              for (const statement of ctx.schemaStatements) {
+                changeTracker.insertNodeAt(sourceFile, pos, statement, { prefix: "\n", suffix: "\n" });
+              }
+            }),
+            provideService7(TypeScriptApi, ts),
+            provideService7(TypeScriptUtils, tsUtils),
+            provideService7(TypeCheckerApi, typeChecker),
+            provideService7(TypeCheckerUtils, typeCheckerUtils),
+            provideService7(TypeParser, typeParser),
+            provideService7(TypeScriptProgram, program)
+          )
+        })
+      )
+    );
+  })
+});
+
 // src/codegens.ts
-var codegens = [accessors, annotate3];
+var codegens = [accessors, annotate3, typeToSchema];
 
 // src/cli/codegen.ts
 var NoFilesToCodegenError = class extends TaggedError("NoFilesToCodegenError") {