@effect/language-service 0.59.0 → 0.61.0

package/index.js

@@ -3526,7 +3526,8 @@ var defaults = {
   }],
   extendedKeyDetection: false,
   pipeableMinArgCount: 1,
-  layerGraphFollowDepth: 0
+  layerGraphFollowDepth: 0,
+  mermaidProvider: "mermaid.live"
 };
 function parseKeyPatterns(patterns) {
   const result = [];
@@ -3564,7 +3565,8 @@ function parse(config) {
     keyPatterns: isObject(config) && hasProperty(config, "keyPatterns") && isArray(config.keyPatterns) ? parseKeyPatterns(config.keyPatterns) : defaults.keyPatterns,
     extendedKeyDetection: isObject(config) && hasProperty(config, "extendedKeyDetection") && isBoolean(config.extendedKeyDetection) ? config.extendedKeyDetection : defaults.extendedKeyDetection,
     pipeableMinArgCount: isObject(config) && hasProperty(config, "pipeableMinArgCount") && isNumber(config.pipeableMinArgCount) ? config.pipeableMinArgCount : defaults.pipeableMinArgCount,
-    layerGraphFollowDepth: isObject(config) && hasProperty(config, "layerGraphFollowDepth") && isNumber(config.layerGraphFollowDepth) ? config.layerGraphFollowDepth : defaults.layerGraphFollowDepth
+    layerGraphFollowDepth: isObject(config) && hasProperty(config, "layerGraphFollowDepth") && isNumber(config.layerGraphFollowDepth) ? config.layerGraphFollowDepth : defaults.layerGraphFollowDepth,
+    mermaidProvider: isObject(config) && hasProperty(config, "mermaidProvider") && isString(config.mermaidProvider) ? config.mermaidProvider : defaults.mermaidProvider
   };
 }
 
@@ -4476,7 +4478,11 @@ var getEditsForCodegen = fn("LSP.getEditsForCodegen")(function* (codegens2, sour
     service(ChangeTracker),
     map8((changeTracker) => {
       changeTracker.deleteRange(sourceFile, range);
-      changeTracker.insertText(sourceFile, range.pos, `${codegen.name}:${edit.hash}`);
+      changeTracker.insertText(
+        sourceFile,
+        range.pos,
+        edit.hash.length > 0 ? `${codegen.name}:${edit.hash}` : codegen.name
+      );
     })
   );
   return {
@@ -15311,13 +15317,19 @@ var formatLayerProvidersAndRequirersInfo = fn("formatLayerProvidersAndRequirersI
 );
 
 // src/quickinfo/layerInfo.ts
-function generateMarmaidUri(code) {
+function generateMarmaidUri(code, mermaidProvider) {
   return gen(function* () {
     const state = JSON.stringify({ code });
     const data = new TextEncoder().encode(state);
     const compressed = deflate_1(data, { level: 9 });
     const pakoString = "pako:" + encodeBase64Url(compressed);
-    return "https://www.mermaidchart.com/play#" + pakoString;
+    if (mermaidProvider === "mermaid.com") {
+      return "https://www.mermaidchart.com/play#" + pakoString;
+    } else if (mermaidProvider === "mermaid.live") {
+      return "https://mermaid.live/edit#" + pakoString;
+    } else {
+      return mermaidProvider + "/edit#" + pakoString;
+    }
   });
 }
 function getAdjustedNode(sourceFile, position) {
@@ -15388,8 +15400,8 @@ function layerInfo(sourceFile, position, quickInfo2) {
           ({ nestedGraphMermaid, outlineGraphMermaid, providersAndRequirersTextualExplanation }) => gen(function* () {
             const linkParts = [];
             if (!options.noExternal) {
-              const mermaidUri = yield* generateMarmaidUri(nestedGraphMermaid);
-              const outlineMermaidUri = yield* generateMarmaidUri(outlineGraphMermaid);
+              const mermaidUri = yield* generateMarmaidUri(nestedGraphMermaid, options.mermaidProvider);
+              const outlineMermaidUri = yield* generateMarmaidUri(outlineGraphMermaid, options.mermaidProvider);
               linkParts.push({ kind: "space", text: "\n" });
               linkParts.push({ kind: "link", text: "{@link " });
               linkParts.push({ kind: "linkText", text: mermaidUri + " Show full Layer graph" });
@@ -16502,6 +16514,536 @@ var removeUnnecessaryEffectGen = createRefactor({
   })
 });
 
+// src/utils/StructuralSchemaGen.ts
+var UnsupportedTypeError = class {
+  constructor(type, reason) {
+    this.type = type;
+    this.reason = reason;
+  }
+  _tag = "@effect/language-service/UnsupportedTypeError";
+  toString() {
+    return `Unsupported type: ${this.reason}`;
+  }
+};
+var StructuralSchemaGenContext = Tag("StructuralSchemaGenContext");
+var makeStructuralSchemaGenContext = fn("StructuralSchemaGen.makeContext")(
+  function* (sourceFile, schemaIdentifier) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const effectSchemaIdentifier = schemaIdentifier || "Schema";
+    return identity({
+      ts,
+      typeChecker,
+      typeCheckerUtils,
+      sourceFile,
+      createApiPropertyAccess: (apiName) => ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(effectSchemaIdentifier),
+        apiName
+      ),
+      createApiCall: (apiName, args2) => ts.factory.createCallExpression(
+        ts.factory.createPropertyAccessExpression(
+          ts.factory.createIdentifier(effectSchemaIdentifier),
+          apiName
+        ),
+        [],
+        args2
+      ),
+      hoistedSchemas: /* @__PURE__ */ new Map(),
+      typeToStatementIndex: /* @__PURE__ */ new Map(),
+      nameToType: /* @__PURE__ */ new Map(),
+      usedGlobalIdentifiers: /* @__PURE__ */ new Map(),
+      schemaStatements: []
+    });
+  }
+);
+var pushHoistedStatement = fn("StructuralSchemaGen.pushHoistedStatement")(
+  function* (ctx, name, type, statement, createReference) {
+    ctx.usedGlobalIdentifiers.set(name, (ctx.usedGlobalIdentifiers.get(name) || 0) + 1);
+    ctx.schemaStatements.push(statement);
+    ctx.typeToStatementIndex.set(type, ctx.schemaStatements.length - 1);
+    ctx.hoistedSchemas.set(type, createReference);
+  }
+);
+var pushHoistedVariableStatement = fn("StructuralSchemaGen.pushHoistedVariableStatement")(
+  function* (ts, ctx, name, type, result) {
+    return yield* pushHoistedStatement(
+      ctx,
+      name,
+      type,
+      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 = fn(
+  "StructuralSchemaGen.processType"
+)(
+  function* (type, context) {
+    const processingContext = context || createProcessingContext();
+    const { hoistedSchemas, nameToType, ts, typeChecker, usedGlobalIdentifiers } = yield* service(
+      StructuralSchemaGenContext
+    );
+    if (processingContext.depth >= processingContext.maxDepth) {
+      return yield* fail3(new UnsupportedTypeError(type, "Maximum depth exceeded"));
+    }
+    let hoistName = fromIterable(nameToType.entries()).find(([_, existingType]) => existingType === type)?.[0];
+    if (!hoistName && type && type.symbol && type.symbol.declarations && type.symbol.declarations.length === 1) {
+      const declaration = type.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(type, existingType) && typeChecker.isTypeAssignableTo(existingType, type);
+        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 === type || typeChecker.isTypeAssignableTo(type, hoistedType) && typeChecker.isTypeAssignableTo(hoistedType, type)) {
+        return hoistedSchema();
+      }
+    }
+    const [schemaExpr, skipHoisting] = yield* processTypeImpl(type, nestedContext);
+    if (!skipHoisting && hoistName) {
+      const ctx = yield* service(StructuralSchemaGenContext);
+      yield* pushHoistedVariableStatement(ts, ctx, hoistName, type, schemaExpr);
+      return ctx.hoistedSchemas.get(type)();
+    }
+    return schemaExpr;
+  }
+);
+var processTypeImpl = fn(
+  "StructuralSchemaGen.processTypeImpl"
+)(
+  function* (type, context) {
+    const { createApiCall, createApiPropertyAccess, ts, typeChecker, typeCheckerUtils } = yield* service(
+      StructuralSchemaGenContext
+    );
+    if (type.flags & ts.TypeFlags.String) {
+      return [createApiPropertyAccess("String"), true];
+    }
+    if (type.flags & ts.TypeFlags.Number) {
+      return [createApiPropertyAccess("Number"), true];
+    }
+    if (type.flags & ts.TypeFlags.Boolean) {
+      return [createApiPropertyAccess("Boolean"), true];
+    }
+    if (type.flags & ts.TypeFlags.BigInt) {
+      return [createApiPropertyAccess("BigInt"), true];
+    }
+    if (type.flags & ts.TypeFlags.Void) {
+      return [createApiPropertyAccess("Void"), true];
+    }
+    if (type.flags & ts.TypeFlags.Undefined) {
+      return [createApiPropertyAccess("Undefined"), true];
+    }
+    if (type.flags & ts.TypeFlags.Null) {
+      return [createApiPropertyAccess("Null"), true];
+    }
+    if (type.flags & ts.TypeFlags.Never) {
+      return [createApiPropertyAccess("Never"), true];
+    }
+    if (type.flags & ts.TypeFlags.Any) {
+      return [createApiPropertyAccess("Any"), true];
+    }
+    if (type.flags & ts.TypeFlags.Unknown) {
+      return [createApiPropertyAccess("Unknown"), true];
+    }
+    if (type.flags & ts.TypeFlags.StringLiteral) {
+      const literalType = type;
+      return [createApiCall("Literal", [ts.factory.createStringLiteral(literalType.value)]), true];
+    }
+    if (type.flags & ts.TypeFlags.NumberLiteral) {
+      const literalType = type;
+      return [createApiCall("Literal", [ts.factory.createNumericLiteral(literalType.value)]), true];
+    }
+    if (type.flags & ts.TypeFlags.BooleanLiteral) {
+      const value = type.intrinsicName === "true";
+      return [createApiCall("Literal", [value ? ts.factory.createTrue() : ts.factory.createFalse()]), true];
+    }
+    if (typeCheckerUtils.isUnion(type)) {
+      return yield* processUnionType(type, context);
+    }
+    if (type.flags & ts.TypeFlags.Intersection) {
+      return yield* processIntersectionType(type, context);
+    }
+    if (typeChecker.isArrayType(type)) {
+      return yield* processArrayType(type, context);
+    }
+    if (typeChecker.isTupleType(type)) {
+      return yield* processTupleType(type, context);
+    }
+    if (type.flags & ts.TypeFlags.Object) {
+      const symbol3 = type.symbol || type.aliasSymbol;
+      if (symbol3) {
+        const typeName = typeChecker.symbolToString(symbol3);
+        if (typeName === "Date") {
+          return [createApiPropertyAccess("Date"), false];
+        }
+        if (typeName === "ReadonlyArray" || typeName === "Array") {
+          return yield* processArrayType(type, context);
+        }
+      }
+      const objectType = type;
+      return yield* processObjectType(objectType, context);
+    }
+    return yield* fail3(
+      new UnsupportedTypeError(
+        type,
+        `Type with flags ${type.flags} is not supported`
+      )
+    );
+  }
+);
+var processUnionType = fn(
+  "StructuralSchemaGen.processUnionType"
+)(
+  function* (type, context) {
+    const { createApiCall, ts } = yield* service(StructuralSchemaGenContext);
+    const allLiterals = type.types.every(
+      (t) => t.flags & ts.TypeFlags.StringLiteral || t.flags & ts.TypeFlags.NumberLiteral || t.flags & ts.TypeFlags.BooleanLiteral
+    );
+    if (allLiterals) {
+      const literals = yield* all(
+        ...type.types.map((t) => processType(t, context))
+      );
+      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* all(
+      ...type.types.map((t) => processType(t, context))
+    );
+    return [createApiCall("Union", members), false];
+  }
+);
+var processIntersectionType = fn(
+  "StructuralSchemaGen.processIntersectionType"
+)(
+  function* (type, context) {
+    const { createApiCall, ts } = yield* service(StructuralSchemaGenContext);
+    const [firstSchema, ...otherSchemas] = yield* all(
+      ...type.types.map((t) => processType(t, context))
+    );
+    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 = fn(
+  "StructuralSchemaGen.processArrayType"
+)(
+  function* (type, context) {
+    const { createApiCall, typeChecker } = yield* service(StructuralSchemaGenContext);
+    const typeArgs = typeChecker.getTypeArguments(type);
+    if (typeArgs.length === 0) {
+      return yield* fail3(new UnsupportedTypeError(type, "Array type has no type arguments"));
+    }
+    const elementSchema = yield* processType(typeArgs[0], context);
+    return [createApiCall("Array", [elementSchema]), false];
+  }
+);
+var processTupleType = fn(
+  "StructuralSchemaGen.processTupleType"
+)(
+  function* (type, context) {
+    const { createApiCall, typeChecker } = yield* service(StructuralSchemaGenContext);
+    const typeArgs = typeChecker.getTypeArguments(type);
+    const elementSchemas = yield* all(
+      ...typeArgs.map((t) => processType(t, context))
+    );
+    return [createApiCall("Tuple", elementSchemas), false];
+  }
+);
+var processObjectType = fn(
+  "StructuralSchemaGen.processObjectType"
+)(
+  function* (type, context) {
+    const {
+      createApiCall,
+      createApiPropertyAccess,
+      ts,
+      typeChecker
+    } = yield* service(
+      StructuralSchemaGenContext
+    );
+    let hasRecords = false;
+    const properties = typeChecker.getPropertiesOfType(type);
+    const propertyAssignments = [];
+    for (const property of properties) {
+      const propertyName = typeChecker.symbolToString(property);
+      const propertyType = typeChecker.getTypeOfSymbol(property);
+      const propertySchema = yield* processType(propertyType, context);
+      const isOptional = (property.flags & ts.SymbolFlags.Optional) !== 0;
+      const schemaExpr = isOptional ? createApiCall("optional", [propertySchema]) : propertySchema;
+      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(type);
+    const args2 = [
+      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, context);
+      const valueSchema = yield* processType(valueType, context);
+      args2.push(
+        ts.factory.createObjectLiteralExpression([
+          ts.factory.createPropertyAssignment("key", keySchema),
+          ts.factory.createPropertyAssignment("value", valueSchema)
+        ])
+      );
+    }
+    if (!hasRecords && context.hoistName) {
+      const ctx = yield* service(StructuralSchemaGenContext);
+      yield* pushHoistedStatement(
+        ctx,
+        context.hoistName,
+        type,
+        ts.factory.createClassDeclaration(
+          void 0,
+          ts.factory.createIdentifier(context.hoistName),
+          [],
+          [ts.factory.createHeritageClause(
+            ts.SyntaxKind.ExtendsKeyword,
+            [
+              ts.factory.createExpressionWithTypeArguments(
+                ts.factory.createCallExpression(
+                  ts.factory.createCallExpression(
+                    createApiPropertyAccess("Class"),
+                    [ts.factory.createTypeReferenceNode(
+                      context.hoistName
+                    )],
+                    [ts.factory.createStringLiteral(context.hoistName)]
+                  ),
+                  [],
+                  args2
+                ),
+                []
+              )
+            ]
+          )],
+          []
+        ),
+        () => ts.factory.createIdentifier(context.hoistName)
+      );
+      return [ctx.hoistedSchemas.get(type)(), true];
+    }
+    return [createApiCall("Struct", args2), propertyAssignments.length === 0];
+  }
+);
+var findNodeToProcess = fn("StructuralSchemaGen.findNodeToProcess")(
+  function* (sourceFile, textRange) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeChecker = yield* service(TypeCheckerApi);
+    return pipe(
+      tsUtils.getAncestorNodesInRange(sourceFile, textRange),
+      filter((node) => ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)),
+      filter((node) => tsUtils.isNodeInRange(textRange)(node.name)),
+      filter((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
+      })),
+      filter(({ type }) => !!type),
+      head
+    );
+  }
+);
+var process = fn("StructuralSchemaGen.process")(
+  function* (sourceFile, scope, typeMap, isExported) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const schemaIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Schema") || "Schema";
+    const ctx = yield* makeStructuralSchemaGenContext(sourceFile, schemaIdentifier);
+    for (const [name, type] of typeMap.entries()) {
+      ctx.nameToType.set(name, type);
+    }
+    for (const symbol3 of typeChecker.getSymbolsInScope(scope, ts.SymbolFlags.Value)) {
+      const name = typeChecker.symbolToString(symbol3);
+      ctx.usedGlobalIdentifiers.set(name, 1);
+      const type = typeChecker.getTypeOfSymbol(symbol3);
+      if (type) {
+        const schemaType = yield* pipe(
+          typeParser.effectSchemaType(type, scope),
+          orElse2(() => void_)
+        );
+        if (schemaType) {
+          ctx.hoistedSchemas.set(
+            schemaType.A,
+            () => {
+              const expression = typeChecker.symbolToExpression(
+                symbol3,
+                ts.SymbolFlags.Value,
+                scope,
+                ts.NodeBuilderFlags.NoTruncation
+              );
+              if (expression) {
+                return expression;
+              }
+              return ts.factory.createIdentifier(name);
+            }
+          );
+        }
+      }
+    }
+    const results = yield* pipe(
+      all(
+        ...fromIterable(ctx.nameToType.entries()).map(
+          ([name, type]) => pipe(
+            processType(type),
+            orElse2(
+              (error) => succeed(ts.addSyntheticLeadingComment(
+                ts.factory.createIdentifier(""),
+                ts.SyntaxKind.MultiLineCommentTrivia,
+                " " + String(error) + " ",
+                true
+              ))
+            ),
+            map8((_) => ({ requestedName: name, type, result: _ }))
+          )
+        )
+      ),
+      provideService(StructuralSchemaGenContext, ctx)
+    );
+    for (const { requestedName, result, type } of results) {
+      const statementIndex = ctx.typeToStatementIndex.get(type);
+      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(type, ctx.schemaStatements.length - 1);
+    }
+    if (isExported) {
+      const statementsToExport = pipe(
+        fromIterable(ctx.nameToType),
+        map4(([_, type]) => ctx.typeToStatementIndex.get(type)),
+        filter((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
+          );
+        }
+      }
+    }
+    return ctx;
+  }
+);
+var applyAtNode = fn("StructuralSchemaGen.applyAtNode")(
+  function* (sourceFile, node, identifier, type, isExported) {
+    const changeTracker = yield* service(ChangeTracker);
+    const ts = yield* service(TypeScriptApi);
+    const ctx = yield* process(sourceFile, node, /* @__PURE__ */ new Map([[ts.idText(identifier), type]]), isExported);
+    for (const statement of ctx.schemaStatements) {
+      changeTracker.insertNodeAt(sourceFile, node.pos, statement, { prefix: "\n", suffix: "\n" });
+    }
+  }
+);
+
+// src/refactors/structuralTypeToSchema.ts
+var structuralTypeToSchema = createRefactor({
+  name: "structuralTypeToSchema",
+  description: "Refactor to Schema (Structural)",
+  apply: fn("structuralTypeToSchema.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const typeParser = yield* service(TypeParser);
+    const maybeNode = yield* findNodeToProcess(sourceFile, textRange);
+    if (isNone2(maybeNode)) {
+      return yield* fail3(new RefactorNotApplicableError());
+    }
+    const { identifier, isExported, node, type } = maybeNode.value;
+    return {
+      kind: "refactor.rewrite.effect.structuralTypeToSchema",
+      description: "Refactor to Schema (Recursive Structural)",
+      apply: pipe(
+        applyAtNode(sourceFile, node, identifier, type, isExported),
+        provideService(TypeCheckerApi, typeChecker),
+        provideService(TypeScriptUtils, tsUtils),
+        provideService(TypeScriptApi, ts),
+        provideService(TypeCheckerUtils, typeCheckerUtils),
+        provideService(TypeParser, typeParser)
+      )
+    };
+  })
+});
+
 // src/refactors/toggleLazyConst.ts
 var toggleLazyConst = createRefactor({
   name: "toggleLazyConst",
@@ -17153,7 +17695,7 @@ var createExportSchemaClassDeclaration = fn("SchemaGen.createExportSchemaClassDe
     );
   }
 );
-var process = fn("SchemaGen.process")(
+var process2 = fn("SchemaGen.process")(
   function* (sourceFile, node, preferClass) {
     const ctx = yield* makeSchemaGenContext(sourceFile);
     const ts = yield* service(TypeScriptApi);
@@ -17163,7 +17705,7 @@ var process = fn("SchemaGen.process")(
     );
   }
 );
-var findNodeToProcess = fn("SchemaGen.findNodeToProcess")(
+var findNodeToProcess2 = fn("SchemaGen.findNodeToProcess")(
   function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const tsUtils = yield* service(TypeScriptUtils);
@@ -17176,12 +17718,12 @@ var findNodeToProcess = fn("SchemaGen.findNodeToProcess")(
     );
   }
 );
-var applyAtNode = fn("SchemaGen.applyAtNode")(
+var applyAtNode2 = fn("SchemaGen.applyAtNode")(
   function* (sourceFile, node, preferClass) {
     const ts = yield* service(TypeScriptApi);
     const changeTracker = yield* service(ChangeTracker);
     const newNode = yield* pipe(
-      process(sourceFile, node, preferClass),
+      process2(sourceFile, node, preferClass),
       orElse2(
         (error) => succeed(ts.addSyntheticLeadingComment(
           ts.factory.createIdentifier(""),
@@ -17206,14 +17748,14 @@ var typeToEffectSchema = createRefactor({
     const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
-    const maybeNode = yield* findNodeToProcess(sourceFile, textRange);
+    const maybeNode = yield* findNodeToProcess2(sourceFile, textRange);
     if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
     const node = maybeNode.value;
     return {
       kind: "refactor.rewrite.effect.typeToEffectSchema",
       description: "Refactor to Schema",
       apply: pipe(
-        applyAtNode(sourceFile, node, false),
+        applyAtNode2(sourceFile, node, false),
         provideService(TypeCheckerApi, typeChecker),
         provideService(TypeScriptUtils, tsUtils),
         provideService(TypeScriptApi, ts),
@@ -17232,14 +17774,14 @@ var typeToEffectSchemaClass = createRefactor({
     const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
-    const maybeNode = yield* findNodeToProcess(sourceFile, textRange);
+    const maybeNode = yield* findNodeToProcess2(sourceFile, textRange);
     if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
     const node = maybeNode.value;
     return {
       kind: "refactor.rewrite.effect.typeToEffectSchemaClass",
       description: "Refactor to Schema.Class",
       apply: pipe(
-        applyAtNode(sourceFile, node, true),
+        applyAtNode2(sourceFile, node, true),
         provideService(TypeCheckerApi, typeChecker),
         provideService(TypeScriptUtils, tsUtils),
         provideService(TypeScriptApi, ts),
@@ -17330,6 +17872,7 @@ var refactors = [
   functionToArrow,
   typeToEffectSchema,
   typeToEffectSchemaClass,
+  structuralTypeToSchema,
   makeSchemaOpaque,
   makeSchemaOpaqueWithNs,
   pipeableToDatafirst,