@effect/language-service 0.73.1 → 0.75.0

package/index.js

@@ -5750,6 +5750,28 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     `TypeParser.isNodeReferenceToEffectParseResultModuleApi(${memberName})`,
     (node) => node
   );
+  const isEffectSchemaParserSourceFile = cachedBy(
+    fn("TypeParser.isEffectSchemaParserSourceFile")(function* (sourceFile) {
+      const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return yield* typeParserIssue("Node has no symbol", void 0, sourceFile);
+      const parseIssueSymbol = typeChecker.tryGetMemberInModuleExports("Parser", moduleSymbol);
+      if (!parseIssueSymbol) return yield* typeParserIssue("ParseIssue type not found", void 0, sourceFile);
+      const decodeSyncSymbol = typeChecker.tryGetMemberInModuleExports("decodeEffect", moduleSymbol);
+      if (!decodeSyncSymbol) return yield* typeParserIssue("decodeSync not found", void 0, sourceFile);
+      const encodeSyncSymbol = typeChecker.tryGetMemberInModuleExports("encodeEffect", moduleSymbol);
+      if (!encodeSyncSymbol) return yield* typeParserIssue("encodeSync not found", void 0, sourceFile);
+      return sourceFile;
+    }),
+    "TypeParser.isEffectSchemaParserSourceFile",
+    (sourceFile) => sourceFile
+  );
+  const isNodeReferenceToEffectSchemaParserModuleApi = (memberName) => cachedBy(
+    fn("TypeParser.isNodeReferenceToEffectSchemaParserModuleApi")(function* (node) {
+      return yield* isNodeReferenceToExportOfPackageModule(node, "effect", isEffectSchemaParserSourceFile, memberName);
+    }),
+    `TypeParser.isNodeReferenceToEffectSchemaParserModuleApi(${memberName})`,
+    (node) => node
+  );
   const contextTagVarianceStruct = (type, atLocation) => map8(
     all(
       varianceStructInvariantType(type, atLocation, "_Identifier"),
@@ -5757,6 +5779,31 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     ),
     ([Identifier, Service]) => ({ Identifier, Service })
   );
+  const serviceVarianceStruct = (type, atLocation) => map8(
+    all(
+      varianceStructInvariantType(type, atLocation, "_Identifier"),
+      varianceStructInvariantType(type, atLocation, "_Service")
+    ),
+    ([Identifier, Service]) => ({ Identifier, Service })
+  );
+  const serviceType = cachedBy(
+    fn("TypeParser.serviceType")(function* (type, atLocation) {
+      yield* pipeableType(type, atLocation);
+      const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration
+      );
+      if (propertiesSymbols.length === 0) {
+        return yield* typeParserIssue("Type has no tag variance struct", type, atLocation);
+      }
+      propertiesSymbols.sort((a, b) => ts.symbolName(b).indexOf("TypeId") - ts.symbolName(a).indexOf("TypeId"));
+      return yield* firstSuccessOf(propertiesSymbols.map((propertySymbol) => {
+        const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+        return serviceVarianceStruct(propertyType, atLocation);
+      }));
+    }),
+    "TypeParser.serviceType",
+    (type) => type
+  );
   const contextTag = cachedBy(
     fn("TypeParser.contextTag")(function* (type, atLocation) {
       yield* pipeableType(type, atLocation);
@@ -5838,14 +5885,22 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   );
   const scopeType = cachedBy(
     fn("TypeParser.scopeType")(function* (type, atLocation) {
-      yield* pipeableType(type, atLocation);
-      const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration
-      );
-      if (propertiesSymbols.some((s) => ts.symbolName(s).indexOf("ScopeTypeId") !== -1)) {
-        return type;
+      if (supportedEffect() === "v4") {
+        const typeIdSymbol = typeChecker.getPropertyOfType(type, "~effect/Scope");
+        if (typeIdSymbol) {
+          return type;
+        }
+        return yield* typeParserIssue("Type is not an effect", type, atLocation);
+      } else {
+        yield* pipeableType(type, atLocation);
+        const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
+          (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration
+        );
+        if (propertiesSymbols.some((s) => ts.symbolName(s).indexOf("ScopeTypeId") !== -1)) {
+          return type;
+        }
+        return yield* typeParserIssue("Type has no scope type id", type, atLocation);
       }
-      return yield* typeParserIssue("Type has no scope type id", type, atLocation);
     }),
     "TypeParser.scopeType",
     (type) => type
@@ -6327,6 +6382,55 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     "TypeParser.extendsEffectService",
     (atLocation) => atLocation
   );
+  const extendsServiceMapService = cachedBy(
+    fn("TypeParser.extendsServiceMapService")(function* (atLocation) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const heritageClauses = atLocation.heritageClauses;
+      if (!heritageClauses) {
+        return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
+      }
+      for (const heritageClause of heritageClauses) {
+        for (const typeX of heritageClause.types) {
+          if (ts.isExpressionWithTypeArguments(typeX)) {
+            const wholeCall = typeX.expression;
+            if (ts.isCallExpression(wholeCall)) {
+              const serviceMapServiceCall = wholeCall.expression;
+              if (ts.isCallExpression(serviceMapServiceCall) && serviceMapServiceCall.typeArguments && serviceMapServiceCall.typeArguments.length > 0) {
+                const serviceMapServiceIdentifier = serviceMapServiceCall.expression;
+                const selfTypeNode = serviceMapServiceCall.typeArguments[0];
+                const isServiceMapService = yield* pipe(
+                  isNodeReferenceToServiceMapModuleApi("Service")(serviceMapServiceIdentifier),
+                  orUndefined
+                );
+                if (isServiceMapService) {
+                  const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
+                  if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
+                  const type = typeChecker.getTypeOfSymbol(classSym);
+                  const parsedServiceType = yield* pipe(
+                    serviceType(type, atLocation),
+                    orUndefined
+                  );
+                  if (parsedServiceType) {
+                    return {
+                      ...parsedServiceType,
+                      className: atLocation.name,
+                      selfTypeNode,
+                      keyStringLiteral: wholeCall.arguments.length > 0 && ts.isStringLiteral(wholeCall.arguments[0]) ? wholeCall.arguments[0] : void 0
+                    };
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend ServiceMap.Service", void 0, atLocation);
+    }),
+    "TypeParser.extendsServiceMapService",
+    (atLocation) => atLocation
+  );
   const isEffectSqlModelTypeSourceFile = cachedBy(
     fn("TypeParser.isEffectSqlModelTypeSourceFile")(function* (sourceFile) {
       const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
@@ -6419,6 +6523,24 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     `TypeParser.isNodeReferenceToEffectLayerModuleApi(${memberName})`,
     (node) => node
   );
+  const isServiceMapTypeSourceFile = cachedBy(
+    fn("TypeParser.isServiceMapTypeSourceFile")(function* (sourceFile) {
+      const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return yield* typeParserIssue("Node has no symbol", void 0, sourceFile);
+      const serviceMapSymbol = typeChecker.tryGetMemberInModuleExports("ServiceMap", moduleSymbol);
+      if (!serviceMapSymbol) return yield* typeParserIssue("ServiceMap not found", void 0, sourceFile);
+      return sourceFile;
+    }),
+    "TypeParser.isServiceMapTypeSourceFile",
+    (sourceFile) => sourceFile
+  );
+  const isNodeReferenceToServiceMapModuleApi = (memberName) => cachedBy(
+    fn("TypeParser.isNodeReferenceToServiceMapModuleApi")(function* (node) {
+      return yield* isNodeReferenceToExportOfPackageModule(node, "effect", isServiceMapTypeSourceFile, memberName);
+    }),
+    `TypeParser.isNodeReferenceToServiceMapModuleApi(${memberName})`,
+    (node) => node
+  );
   const lazyExpression = cachedBy(
     function(node) {
       if (!ts.isArrowFunction(node) && !ts.isFunctionExpression(node)) {
@@ -6749,6 +6871,9 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     isNodeReferenceToEffectContextModuleApi,
     isNodeReferenceToEffectSqlModelModuleApi,
     isNodeReferenceToEffectLayerModuleApi,
+    isNodeReferenceToEffectSchemaParserModuleApi,
+    isServiceMapTypeSourceFile,
+    isNodeReferenceToServiceMapModuleApi,
     effectType,
     strictEffectType,
     layerType,
@@ -6764,6 +6889,7 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     unnecessaryEffectGen: unnecessaryEffectGen2,
     effectSchemaType,
     contextTag,
+    serviceType,
     pipeableType,
     pipeCall,
     singleArgCall,
@@ -6771,6 +6897,7 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     promiseLike,
     extendsEffectTag,
     extendsEffectService,
+    extendsServiceMapService,
     extendsContextTag,
     extendsSchemaClass,
     extendsSchemaTaggedClass,
@@ -7073,6 +7200,7 @@ var parse2 = fn("writeTagClassAccessors.parse")(function* (node) {
   const typeChecker = yield* service(TypeCheckerApi);
   const typeParser = yield* service(TypeParser);
   const typeCheckerUtils = yield* service(TypeCheckerUtils);
+  if (typeParser.supportedEffect() === "v4") return yield* fail3("not applicable to Effect v4");
   if (!ts.isClassDeclaration(node)) return yield* fail3("not a class declaration");
   const { Service, accessors: accessors2, className, kind } = yield* pipe(
     map8(typeParser.extendsEffectService(node), (_) => ({ kind: "effectService", ..._ })),
@@ -7315,16 +7443,16 @@ var pushHoistedVariableStatement = fn("StructuralSchemaGen.pushHoistedVariableSt
     );
   }
 );
-var createProcessingContext = (maxDepth = 200) => ({
+var createProcessingContext = (supportedEffect, maxDepth = 200) => ({
   depth: 0,
   maxDepth,
-  hoistName: void 0
+  hoistName: void 0,
+  supportedEffect
 });
 var processType = fn(
   "StructuralSchemaGen.processType"
 )(
-  function* (type, context) {
-    const processingContext = context || createProcessingContext();
+  function* (type, processingContext) {
     const { hoistedSchemas, nameToType, ts, typeChecker, usedGlobalIdentifiers } = yield* service(
       StructuralSchemaGenContext
     );
@@ -7459,7 +7587,7 @@ var processUnionType = fn(
     const allLiterals = types.every(
       (t) => t.flags & ts.TypeFlags.StringLiteral || t.flags & ts.TypeFlags.NumberLiteral || t.flags & ts.TypeFlags.BooleanLiteral
     );
-    if (allLiterals) {
+    if (allLiterals && context.supportedEffect !== "v4") {
       const literals = yield* all(
         ...types.map((t) => processType(t, context))
       );
@@ -7469,7 +7597,13 @@ var processUnionType = fn(
         }
         return expr;
       }).filter((arg) => arg !== void 0);
-      return [createApiCall("Literal", literalValues), false];
+      return [
+        createApiCall(
+          "Literal",
+          literalValues
+        ),
+        false
+      ];
     }
     const members = yield* all(
       ...types.map((t) => processType(t, context))
@@ -7477,7 +7611,13 @@ var processUnionType = fn(
     if (members.length === 1) {
       return [members[0], false];
     }
-    return [createApiCall("Union", members), false];
+    return [
+      createApiCall(
+        "Union",
+        context.supportedEffect === "v4" ? [ts.factory.createArrayLiteralExpression(members)] : members
+      ),
+      false
+    ];
   }
 );
 var processIntersectionType = fn(
@@ -7523,12 +7663,18 @@ var processTupleType = fn(
   "StructuralSchemaGen.processTupleType"
 )(
   function* (type, context) {
-    const { createApiCall, typeChecker } = yield* service(StructuralSchemaGenContext);
+    const { createApiCall, ts, typeChecker } = yield* service(StructuralSchemaGenContext);
     const typeArgs = typeChecker.getTypeArguments(type);
     const elementSchemas = yield* all(
       ...typeArgs.map((t) => processType(t, context))
     );
-    return [createApiCall("Tuple", elementSchemas), false];
+    return [
+      createApiCall(
+        "Tuple",
+        context.supportedEffect === "v4" ? [ts.factory.createArrayLiteralExpression(elementSchemas)] : elementSchemas
+      ),
+      false
+    ];
   }
 );
 var processObjectType = fn(
@@ -7545,7 +7691,6 @@ var processObjectType = fn(
     } = yield* service(
       StructuralSchemaGenContext
     );
-    let hasRecords = false;
     const properties = typeChecker.getPropertiesOfType(type);
     const propertyAssignments = [];
     for (const property of properties) {
@@ -7585,20 +7730,28 @@ var processObjectType = fn(
     const args2 = [
       ts.factory.createObjectLiteralExpression(propertyAssignments, propertyAssignments.length > 0)
     ];
+    const records = [];
     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)
-        ])
-      );
+      records.push({ key: keySchema, value: valueSchema });
+    }
+    if (context.supportedEffect === "v4") {
+      if (records.length > 0) {
+        return [
+          createApiCall("StructWithRest", [
+            createApiCall("Struct", args2),
+            ts.factory.createArrayLiteralExpression(
+              records.map(({ key, value }) => createApiCall("Record", [key, value]))
+            )
+          ]),
+          propertyAssignments.length === 0
+        ];
+      }
     }
-    if (!hasRecords && context.hoistName) {
+    if (records.length === 0 && context.hoistName) {
       const ctx = yield* service(StructuralSchemaGenContext);
       yield* pushHoistedStatement(
         ctx,
@@ -7633,6 +7786,14 @@ var processObjectType = fn(
       );
       return [ctx.hoistedSchemas.get(type)(), true];
     }
+    for (const { key, value } of records) {
+      args2.push(
+        ts.factory.createObjectLiteralExpression([
+          ts.factory.createPropertyAssignment("key", key),
+          ts.factory.createPropertyAssignment("value", value)
+        ])
+      );
+    }
     return [createApiCall("Struct", args2), propertyAssignments.length === 0];
   }
 );
@@ -7718,7 +7879,7 @@ var process = fn("StructuralSchemaGen.process")(
       all(
         ...fromIterable(ctx.nameToType.entries()).map(
           ([name, type]) => pipe(
-            processType(type),
+            processType(type, createProcessingContext(typeParser.supportedEffect())),
             orElse2(
               (error) => succeed(ts.addSyntheticLeadingComment(
                 ts.factory.createIdentifier(""),
@@ -8377,6 +8538,7 @@ var deterministicKeys = createDiagnostic({
             typeParser.extendsEffectService(node),
             orElse2(() => typeParser.extendsContextTag(node)),
             orElse2(() => typeParser.extendsEffectTag(node)),
+            orElse2(() => typeParser.extendsServiceMapService(node)),
             map8(({ className, keyStringLiteral }) => ({ keyStringLiteral, className, target: "service" }))
           ),
           orElse2(
@@ -9772,6 +9934,9 @@ More info and examples at https://effect.website/docs/requirements-management/la
       if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && ts.idText(node.expression.name) === "GenericTag") {
         const nodeType = typeCheckerUtils.getTypeAtLocation(node);
         if (nodeType) typesToCheck.push([nodeType, node]);
+      } else if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && ts.idText(node.expression.name) === "Service") {
+        const nodeType = typeCheckerUtils.getTypeAtLocation(node);
+        if (nodeType) typesToCheck.push([nodeType, node]);
       } else if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
         const classSym = typeChecker.getSymbolAtLocation(node.name);
         if (classSym) {
@@ -9785,6 +9950,7 @@ More info and examples at https://effect.website/docs/requirements-management/la
       for (const [type, reportAt] of typesToCheck) {
         yield* pipe(
           typeParser.contextTag(type, node),
+          orElse2(() => typeParser.serviceType(type, node)),
           flatMap4(
             ({ Service }) => pipe(
               parseLeakedRequirements(Service, node),
@@ -10559,6 +10725,7 @@ var nonObjectEffectServiceType = createDiagnostic({
     const typeChecker = yield* service(TypeCheckerApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
+    if (typeParser.supportedEffect() === "v4") return;
     function isPrimitiveType(type) {
       return typeCheckerUtils.unrollUnionMembers(type).some(
         (type2) => !!(type2.flags & ts.TypeFlags.String || type2.flags & ts.TypeFlags.Number || type2.flags & ts.TypeFlags.Boolean || type2.flags & ts.TypeFlags.StringLiteral || type2.flags & ts.TypeFlags.NumberLiteral || type2.flags & ts.TypeFlags.BooleanLiteral || type2.flags & ts.TypeFlags.Undefined || type2.flags & ts.TypeFlags.Null)
@@ -11037,6 +11204,7 @@ var runEffectInsideEffect = createDiagnostic({
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
     const tsUtils = yield* service(TypeScriptUtils);
+    if (typeParser.supportedEffect() === "v4") return;
     const parseEffectMethod = (node, methodName) => pipe(
       typeParser.isNodeReferenceToEffectModuleApi(methodName)(node),
       map8(() => ({ node, methodName }))
@@ -11231,12 +11399,18 @@ var schemaStructWithTag = createDiagnostic({
 });
 
 // src/diagnostics/schemaSyncInEffect.ts
-var syncToEffectMethod = {
+var syncToEffectMethodV3 = {
   decodeSync: "decode",
   decodeUnknownSync: "decodeUnknown",
   encodeSync: "encode",
   encodeUnknownSync: "encodeUnknown"
 };
+var syncToEffectMethodV4 = {
+  decodeSync: "decodeEffect",
+  decodeUnknownSync: "decodeUnknownEffect",
+  encodeSync: "encodeEffect",
+  encodeUnknownSync: "encodeUnknownEffect"
+};
 var schemaSyncInEffect = createDiagnostic({
   name: "schemaSyncInEffect",
   code: 43,
@@ -11245,8 +11419,10 @@ var schemaSyncInEffect = createDiagnostic({
   apply: fn("schemaSyncInEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
+    const syncToEffectMethod = typeParser.supportedEffect() === "v3" ? syncToEffectMethodV3 : syncToEffectMethodV4;
     const parseSchemaSyncMethod = (node, methodName) => pipe(
       typeParser.isNodeReferenceToEffectParseResultModuleApi(methodName)(node),
+      orElse2(() => typeParser.isNodeReferenceToEffectSchemaParserModuleApi(methodName)(node)),
       map8(() => ({ node, methodName }))
     );
     const nodeToVisit = [];
@@ -11276,7 +11452,7 @@ var schemaSyncInEffect = createDiagnostic({
       const effectMethodName = syncToEffectMethod[isSchemaSyncCall.value.methodName];
       report({
         location: node.expression,
-        messageText: `Using ${nodeText} inside an Effect generator is not recommended. Use Schema.${effectMethodName} instead to get properly typed ParseError in the error channel.`,
+        messageText: `Using ${nodeText} inside an Effect generator is not recommended. Use Schema.${effectMethodName} instead to get properly typed error channel.`,
         fixes: []
       });
     }
@@ -11292,6 +11468,7 @@ var schemaUnionOfLiterals = createDiagnostic({
   apply: fn("schemaUnionOfLiterals.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
+    if (typeParser.supportedEffect() === "v4") return;
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -12129,23 +12306,38 @@ var effectSchemaSelfInClasses = createCompletion({
         });
       }
     }
-    if (typeParser.supportedEffect() === "v3") {
-      const hasTaggedClassCompletion = isFullyQualified || isSome2(
+    if (typeParser.supportedEffect() === "v4") {
+      const hasTaggedErrorCompletion = isFullyQualified || isSome2(
         yield* pipe(
-          typeParser.isNodeReferenceToEffectSchemaModuleApi("TaggedClass")(accessedObject),
+          typeParser.isNodeReferenceToEffectSchemaModuleApi("TaggedErrorClass")(accessedObject),
           option
         )
       );
-      if (hasTaggedClassCompletion) {
+      if (hasTaggedErrorCompletion) {
         completions2.push({
-          name: `TaggedClass<${name}>`,
+          name: `TaggedError<${name}>`,
           kind: ts.ScriptElementKind.constElement,
-          insertText: isFullyQualified ? `${schemaIdentifier}.TaggedClass<${name}>()("${name}", {${"${0}"}}){}` : `TaggedClass<${name}>()("${name}", {${"${0}"}}){}`,
+          insertText: isFullyQualified ? `${schemaIdentifier}.TaggedErrorClass<${name}>()("${errorTagKey}", {${"${0}"}}){}` : `TaggedErrorClass<${name}>()("${errorTagKey}", {${"${0}"}}){}`,
           replacementSpan,
           isSnippet: true
         });
       }
     }
+    const hasTaggedClassCompletion = isFullyQualified || isSome2(
+      yield* pipe(
+        typeParser.isNodeReferenceToEffectSchemaModuleApi("TaggedClass")(accessedObject),
+        option
+      )
+    );
+    if (hasTaggedClassCompletion) {
+      completions2.push({
+        name: `TaggedClass<${name}>`,
+        kind: ts.ScriptElementKind.constElement,
+        insertText: isFullyQualified ? `${schemaIdentifier}.TaggedClass<${name}>()("${name}", {${"${0}"}}){}` : `TaggedClass<${name}>()("${name}", {${"${0}"}}){}`,
+        replacementSpan,
+        isSnippet: true
+      });
+    }
     if (typeParser.supportedEffect() === "v3") {
       const hasTaggedRequestCompletion = isFullyQualified || isSome2(
         yield* pipe(
@@ -12174,24 +12366,7 @@ var effectSchemaSelfInClasses = createCompletion({
         completions2.push({
           name: `ErrorClass<${name}>`,
           kind: ts.ScriptElementKind.constElement,
-          insertText: isFullyQualified ? `${schemaIdentifier}.ErrorClass<${name}>()({${"${0}"}}){}` : `ErrorClass<${name}>()({${"${0}"}}){}`,
-          replacementSpan,
-          isSnippet: true
-        });
-      }
-    }
-    if (typeParser.supportedEffect() === "v4") {
-      const hasRequestClassCompletion = isFullyQualified || isSome2(
-        yield* pipe(
-          typeParser.isNodeReferenceToEffectSchemaModuleApi("RequestClass")(accessedObject),
-          option
-        )
-      );
-      if (hasRequestClassCompletion) {
-        completions2.push({
-          name: `RequestClass<${name}>`,
-          kind: ts.ScriptElementKind.constElement,
-          insertText: isFullyQualified ? `${schemaIdentifier}.RequestClass<${name}>("${name}")({${"${0}"}}){}` : `RequestClass<${name}>("${name}")({${"${0}"}}){}`,
+          insertText: isFullyQualified ? `${schemaIdentifier}.ErrorClass<${name}>("${name}")({${"${0}"}}){}` : `ErrorClass<${name}>()({${"${0}"}}){}`,
           replacementSpan,
           isSnippet: true
         });
@@ -12446,8 +12621,55 @@ var schemaBrand = createCompletion({
   })
 });
 
+// src/completions/serviceMapSelfInClasses.ts
+var serviceMapSelfInClasses = createCompletion({
+  name: "serviceMapSelfInClasses",
+  apply: fn("serviceMapSelfInClasses")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeParser = yield* service(TypeParser);
+    if (typeParser.supportedEffect() === "v3") return [];
+    const maybeInfos = tsUtils.parseDataForExtendsClassCompletion(sourceFile, position);
+    if (!maybeInfos) return [];
+    const { accessedObject, className, replacementSpan } = maybeInfos;
+    const serviceMapIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "ServiceMap"
+    ) || "ServiceMap";
+    const isFullyQualified = serviceMapIdentifier === ts.idText(accessedObject);
+    const name = ts.idText(className);
+    const tagKey = (yield* createString(sourceFile, name, "service")) || name;
+    const completions2 = [];
+    const hasServiceCompletion = isFullyQualified || isSome2(
+      yield* pipe(
+        typeParser.isNodeReferenceToServiceMapModuleApi("Service")(accessedObject),
+        option
+      )
+    );
+    if (hasServiceCompletion) {
+      completions2.push({
+        name: `Service<${name}, {}>`,
+        kind: ts.ScriptElementKind.constElement,
+        insertText: isFullyQualified ? `${serviceMapIdentifier}.Service<${name}, {${"${0}"}}>()("${tagKey}"){}` : `Service<${name}, {${"${0}"}}>()("${tagKey}"){}`,
+        replacementSpan,
+        isSnippet: true
+      });
+      completions2.push({
+        name: `Service<${name}>({ make })`,
+        kind: ts.ScriptElementKind.constElement,
+        insertText: isFullyQualified ? `${serviceMapIdentifier}.Service<${name}>()("${tagKey}", { make: ${"${0}"} }){}` : `Service<${name}>()("${tagKey}", { make: ${"${0}"} }){}`,
+        replacementSpan,
+        isSnippet: true
+      });
+    }
+    return completions2;
+  })
+});
+
 // src/completions.ts
 var completions = [
+  serviceMapSelfInClasses,
   effectSqlModelSelfInClasses,
   effectSchemaSelfInClasses,
   effectSelfInClasses,
@@ -19085,7 +19307,7 @@ var _findSchemaVariableDeclaration = fn(
     );
   }
 );
-var _createOpaqueTypes = fn("_createOpaqueTypes")(function* (effectSchemaName, inferFromName, typeA, opaqueTypeName, typeE, opaqueEncodedName, opaqueContextName) {
+var _createOpaqueTypes = fn("_createOpaqueTypes")(function* (effectSchemaName, inferFromName, typeA, opaqueTypeName, typeE, opaqueEncodedName, opaqueContextName, isV4, opaqueEncodingServicesName) {
   const ts = yield* service(TypeScriptApi);
   const opaqueInferred = ts.factory.createExpressionWithTypeArguments(
     ts.factory.createPropertyAccessExpression(
@@ -19118,7 +19340,7 @@ var _createOpaqueTypes = fn("_createOpaqueTypes")(function* (effectSchemaName, i
     ts.factory.createPropertyAccessExpression(
       ts.factory.createPropertyAccessExpression(
         ts.factory.createIdentifier(effectSchemaName),
-        ts.factory.createIdentifier("Schema")
+        ts.factory.createIdentifier(isV4 ? "Codec" : "Schema")
       ),
       ts.factory.createIdentifier("Encoded")
     ),
@@ -19145,9 +19367,9 @@ var _createOpaqueTypes = fn("_createOpaqueTypes")(function* (effectSchemaName, i
     ts.factory.createPropertyAccessExpression(
       ts.factory.createPropertyAccessExpression(
         ts.factory.createIdentifier(effectSchemaName),
-        ts.factory.createIdentifier("Schema")
+        ts.factory.createIdentifier(isV4 ? "Codec" : "Schema")
       ),
-      ts.factory.createIdentifier("Context")
+      ts.factory.createIdentifier(isV4 ? "DecodingServices" : "Context")
     ),
     [ts.factory.createTypeQueryNode(
       ts.factory.createIdentifier(inferFromName)
@@ -19159,7 +19381,25 @@ var _createOpaqueTypes = fn("_createOpaqueTypes")(function* (effectSchemaName, i
     [],
     contextInferred
   );
-  return { contextType, encodedType, opaqueType };
+  const contextEncodeInferred = ts.factory.createExpressionWithTypeArguments(
+    ts.factory.createPropertyAccessExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(effectSchemaName),
+        ts.factory.createIdentifier(isV4 ? "Codec" : "Schema")
+      ),
+      ts.factory.createIdentifier(isV4 ? "EncodingServices" : "Context")
+    ),
+    [ts.factory.createTypeQueryNode(
+      ts.factory.createIdentifier(inferFromName)
+    )]
+  );
+  const contextEncodeType = ts.factory.createTypeAliasDeclaration(
+    [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+    opaqueEncodingServicesName,
+    [],
+    contextEncodeInferred
+  );
+  return { contextType, contextEncodeType, encodedType, opaqueType };
 });
 var makeSchemaOpaque = createRefactor({
   name: "makeSchemaOpaque",
@@ -19167,6 +19407,8 @@ var makeSchemaOpaque = createRefactor({
   apply: fn("makeSchemaOpaque.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const tsUtils = yield* service(TypeScriptUtils);
+    const typeParser = yield* service(TypeParser);
+    const supportedEffect = typeParser.supportedEffect();
     const maybeNode = yield* _findSchemaVariableDeclaration(sourceFile, textRange);
     if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
     const { identifier, types, variableDeclarationList, variableStatement } = maybeNode.value;
@@ -19182,14 +19424,16 @@ var makeSchemaOpaque = createRefactor({
             "Schema"
           ) || "Schema";
           const newIdentifier = ts.factory.createIdentifier(ts.idText(identifier) + "_");
-          const { contextType, encodedType, opaqueType } = yield* _createOpaqueTypes(
+          const { contextEncodeType, contextType, encodedType, opaqueType } = yield* _createOpaqueTypes(
             effectSchemaName,
             ts.idText(newIdentifier),
             types.A,
             ts.idText(identifier),
             types.I,
             ts.idText(identifier) + "Encoded",
-            ts.idText(identifier) + "Context"
+            supportedEffect === "v4" ? ts.idText(identifier) + "DecodingServices" : ts.idText(identifier) + "Context",
+            supportedEffect === "v4",
+            supportedEffect === "v4" ? ts.idText(identifier) + "EncodingServices" : ts.idText(identifier) + "Context"
           );
           changeTracker.replaceNode(
             sourceFile,
@@ -19199,16 +19443,19 @@ var makeSchemaOpaque = createRefactor({
           changeTracker.insertNodeAfter(sourceFile, variableStatement, opaqueType);
           changeTracker.insertNodeAfter(sourceFile, variableStatement, encodedType);
           changeTracker.insertNodeAfter(sourceFile, variableStatement, contextType);
+          if (supportedEffect === "v4") {
+            changeTracker.insertNodeAfter(sourceFile, variableStatement, contextEncodeType);
+          }
           const newSchemaType = ts.factory.createTypeReferenceNode(
             ts.factory.createQualifiedName(
               ts.factory.createIdentifier(effectSchemaName),
-              ts.factory.createIdentifier("Schema")
+              supportedEffect === "v4" ? ts.factory.createIdentifier("Codec") : ts.factory.createIdentifier("Schema")
             ),
             [
               ts.factory.createTypeReferenceNode(opaqueType.name),
               ts.factory.createTypeReferenceNode(encodedType.name),
               ts.factory.createTypeReferenceNode(contextType.name)
-            ]
+            ].concat(supportedEffect === "v4" ? [ts.factory.createTypeReferenceNode(contextEncodeType.name)] : [])
           );
           const newConstDeclaration = ts.factory.createVariableStatement(
             variableStatement.modifiers,
@@ -19238,6 +19485,8 @@ var makeSchemaOpaqueWithNs = createRefactor({
   apply: fn("makeSchemaOpaqueWithNs.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const tsUtils = yield* service(TypeScriptUtils);
+    const typeParser = yield* service(TypeParser);
+    const supportedEffect = typeParser.supportedEffect();
     const maybeNode = yield* _findSchemaVariableDeclaration(sourceFile, textRange);
     if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
     const { identifier, types, variableDeclarationList, variableStatement } = maybeNode.value;
@@ -19253,14 +19502,16 @@ var makeSchemaOpaqueWithNs = createRefactor({
             "Schema"
           ) || "Schema";
           const newIdentifier = ts.factory.createIdentifier(ts.idText(identifier) + "_");
-          const { contextType, encodedType, opaqueType } = yield* _createOpaqueTypes(
+          const { contextEncodeType, contextType, encodedType, opaqueType } = yield* _createOpaqueTypes(
             effectSchemaName,
             ts.idText(newIdentifier),
             types.A,
             ts.idText(identifier),
             types.I,
             "Encoded",
-            "Context"
+            supportedEffect === "v4" ? "DecodingServices" : "Context",
+            supportedEffect === "v4",
+            supportedEffect === "v4" ? "EncodingServices" : "Context"
           );
           const namespace = ts.factory.createModuleDeclaration(
             [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
@@ -19268,7 +19519,7 @@ var makeSchemaOpaqueWithNs = createRefactor({
             ts.factory.createModuleBlock([
               encodedType,
               contextType
-            ]),
+            ].concat(supportedEffect === "v4" ? [contextEncodeType] : [])),
             ts.NodeFlags.Namespace
           );
           changeTracker.replaceNode(
@@ -19742,12 +19993,14 @@ var makeSchemaGenContext = fn("SchemaGen.makeSchemaGenContext")(function* (sourc
     "Schema"
   ) || "Schema";
   const moduleToImportedName = {};
-  for (const moduleName of ["Option", "Either", "Chunk", "Duration"]) {
+  for (const moduleName of ["Option", "Either", "Chunk", "Duration", "Result"]) {
     const importedName = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", moduleName);
     if (importedName) moduleToImportedName[moduleName] = importedName;
   }
   const ts = yield* service(TypeScriptApi);
+  const typeParser = yield* service(TypeParser);
   return {
+    supportedEffect: typeParser.supportedEffect(),
     sourceFile,
     createApiPropertyAccess: (apiName) => ts.factory.createPropertyAccessExpression(
       ts.factory.createIdentifier(effectSchemaIdentifier),
@@ -19831,7 +20084,7 @@ var createUnsupportedNodeComment = (ts, sourceFile, node) => ts.addSyntheticTrai
   " Not supported conversion: " + node.getText(sourceFile) + " "
 );
 var processNode = (node, isVirtualTypeNode) => gen(function* () {
-  const { createApiCall, createApiPropertyAccess, entityNameToDataTypeName, sourceFile, ts } = yield* service(
+  const { createApiCall, createApiPropertyAccess, entityNameToDataTypeName, sourceFile, supportedEffect, ts } = yield* service(
     SchemaGenContext
   );
   switch (node.kind) {
@@ -19863,9 +20116,12 @@ var processNode = (node, isVirtualTypeNode) => gen(function* () {
   }
   if (ts.isUnionTypeNode(node)) {
     const allLiterals = yield* option(parseAllLiterals(node));
-    if (isSome2(allLiterals)) return createApiCall("Literal", allLiterals.value);
+    if (supportedEffect !== "v4" && isSome2(allLiterals)) return createApiCall("Literal", allLiterals.value);
     const members = yield* all(...node.types.map((_) => processNode(_, isVirtualTypeNode)));
-    return createApiCall("Union", members);
+    return createApiCall(
+      "Union",
+      supportedEffect === "v4" ? [ts.factory.createArrayLiteralExpression(members)] : members
+    );
   }
   if (ts.isIntersectionTypeNode(node)) {
     const [firstSchema, ...otherSchemas] = yield* all(
@@ -19940,6 +20196,9 @@ var processNode = (node, isVirtualTypeNode) => gen(function* () {
             ...node.typeArguments ? node.typeArguments.map((_) => processNode(_, isVirtualTypeNode)) : []
           );
           if (elements.length >= 2) {
+            if (supportedEffect === "v4" && elements.length === 2) {
+              return createApiCall("Record", [elements[0], elements[1]]);
+            }
             return createApiCall(parsedName.value, [
               ts.factory.createObjectLiteralExpression([
                 ts.factory.createPropertyAssignment("key", elements[0]),
@@ -20174,6 +20433,7 @@ var typeToEffectSchema = createRefactor({
     const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const typeParser = yield* service(TypeParser);
     const maybeNode = yield* findNodeToProcess2(sourceFile, textRange);
     if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
     const node = maybeNode.value;
@@ -20185,7 +20445,8 @@ var typeToEffectSchema = createRefactor({
         provideService(TypeCheckerApi, typeChecker),
         provideService(TypeScriptUtils, tsUtils),
         provideService(TypeScriptApi, ts),
-        provideService(TypeCheckerUtils, typeCheckerUtils)
+        provideService(TypeCheckerUtils, typeCheckerUtils),
+        provideService(TypeParser, typeParser)
       )
     };
   })
@@ -20200,6 +20461,7 @@ var typeToEffectSchemaClass = createRefactor({
     const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const typeParser = yield* service(TypeParser);
     const maybeNode = yield* findNodeToProcess2(sourceFile, textRange);
     if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
     const node = maybeNode.value;
@@ -20211,7 +20473,8 @@ var typeToEffectSchemaClass = createRefactor({
         provideService(TypeCheckerApi, typeChecker),
         provideService(TypeScriptUtils, tsUtils),
         provideService(TypeScriptApi, ts),
-        provideService(TypeCheckerUtils, typeCheckerUtils)
+        provideService(TypeCheckerUtils, typeCheckerUtils),
+        provideService(TypeParser, typeParser)
       )
     };
   })