@effect/language-service 0.28.3 → 0.30.0

package/index.js

@@ -735,104 +735,12 @@ var none2 = () => none;
 var some2 = some;
 var isNone2 = isNone;
 var isSome2 = isSome;
-var match = /* @__PURE__ */ dual(2, (self, {
-  onNone,
-  onSome
-}) => isNone2(self) ? onNone() : onSome(self.value));
 var getOrElse2 = /* @__PURE__ */ dual(2, (self, onNone) => isNone2(self) ? onNone() : self.value);
 var orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : self);
 var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nullableValue);
 var getOrUndefined = /* @__PURE__ */ getOrElse2(constUndefined);
 var map2 = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some2(f(self.value)));
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/array.js
-var isNonEmptyArray = (self) => self.length > 0;
-
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Array.js
-var fromIterable = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
-var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
-var appendAll = /* @__PURE__ */ dual(2, (self, that) => fromIterable(self).concat(fromIterable(that)));
-var isArray = Array.isArray;
-var isEmptyArray = (self) => self.length === 0;
-var isEmptyReadonlyArray = isEmptyArray;
-var isNonEmptyReadonlyArray = isNonEmptyArray;
-var isOutOfBounds = (i, as) => i < 0 || i >= as.length;
-var get = /* @__PURE__ */ dual(2, (self, index) => {
-  const i = Math.floor(index);
-  return isOutOfBounds(i, self) ? none2() : some2(self[i]);
-});
-var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
-  const i = Math.floor(index);
-  if (isOutOfBounds(i, self)) {
-    throw new Error(`Index ${i} out of bounds`);
-  }
-  return self[i];
-});
-var head = /* @__PURE__ */ get(0);
-var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
-var tailNonEmpty = (self) => self.slice(1);
-var sort = /* @__PURE__ */ dual(2, (self, O) => {
-  const out = Array.from(self);
-  out.sort(O);
-  return out;
-});
-var containsWith = (isEquivalent) => dual(2, (self, a) => {
-  for (const i of self) {
-    if (isEquivalent(a, i)) {
-      return true;
-    }
-  }
-  return false;
-});
-var _equivalence = /* @__PURE__ */ equivalence();
-var intersectionWith = (isEquivalent) => {
-  const has = containsWith(isEquivalent);
-  return dual(2, (self, that) => fromIterable(self).filter((a) => has(that, a)));
-};
-var intersection = /* @__PURE__ */ intersectionWith(_equivalence);
-var empty = () => [];
-var map3 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
-var flatMap = /* @__PURE__ */ dual(2, (self, f) => {
-  if (isEmptyReadonlyArray(self)) {
-    return [];
-  }
-  const out = [];
-  for (let i = 0; i < self.length; i++) {
-    const inner = f(self[i], i);
-    for (let j = 0; j < inner.length; j++) {
-      out.push(inner[j]);
-    }
-  }
-  return out;
-});
-var flatten = /* @__PURE__ */ flatMap(identity);
-var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
-  const as = fromIterable(self);
-  const out = [];
-  for (let i = 0; i < as.length; i++) {
-    if (predicate(as[i], i)) {
-      out.push(as[i]);
-    }
-  }
-  return out;
-});
-var every = /* @__PURE__ */ dual(2, (self, refinement) => self.every(refinement));
-var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
-  const input = fromIterable(self);
-  if (isNonEmptyReadonlyArray(input)) {
-    const out = [headNonEmpty(input)];
-    const rest = tailNonEmpty(input);
-    for (const r of rest) {
-      if (out.every((a) => !isEquivalent(r, a))) {
-        out.push(r);
-      }
-    }
-    return out;
-  }
-  return [];
-});
-var dedupe = (self) => dedupeWith(self, equivalence());
-
 // src/core/Nano.ts
 var NanoTag = class {
   constructor(key) {
@@ -950,13 +858,13 @@ var OnSuccessProto = {
     return this[args];
   }
 };
-var flatMap2 = dual(2, (fa, f) => {
+var flatMap = dual(2, (fa, f) => {
   const nano = Object.create(OnSuccessProto);
   nano[args] = fa;
   nano[contA] = f;
   return nano;
 });
-var map4 = dual(2, (fa, f) => flatMap2(fa, (_) => succeed(f(_))));
+var map3 = dual(2, (fa, f) => flatMap(fa, (_) => succeed(f(_))));
 var SyncProto = {
   ...PrimitiveProto,
   [evaluate](fiber) {
@@ -997,7 +905,7 @@ var MatchProto = {
     return this[args];
   }
 };
-var match2 = (fa, opts) => {
+var match = (fa, opts) => {
   const nano = Object.create(MatchProto);
   nano[args] = fa;
   nano[contA] = opts.onSuccess;
@@ -1020,7 +928,7 @@ var ProvideServiceProto = {
       ...fiber._services,
       [tag.key]: value
     };
-    return match2(fa, {
+    return match(fa, {
       onSuccess: (_) => {
         fiber._services = prevServices;
         return succeed(_);
@@ -1063,7 +971,7 @@ var CachedProto = {
     fiber._cache[type] = cache;
     const cached2 = cache.get(key);
     if (cached2) return cached2;
-    return match2(fa, {
+    return match(fa, {
       onSuccess: (_) => {
         cache.set(key, succeed(_));
         return succeed(_);
@@ -1111,44 +1019,138 @@ var all = fn("all")(
 var TypeScriptApi = Tag("TypeScriptApi");
 var TypeScriptProgram = Tag("TypeScriptProgram");
 var ChangeTracker = Tag("ChangeTracker");
-function parsePackageContentNameAndVersionFromScope(v) {
-  if (!isObject(v)) return;
-  if (!hasProperty(v, "packageJsonScope")) return;
-  if (!v.packageJsonScope) return;
-  const packageJsonScope = v.packageJsonScope;
-  if (!hasProperty(packageJsonScope, "contents")) return;
-  if (!hasProperty(packageJsonScope.contents, "packageJsonContent")) return;
-  const packageJsonContent = packageJsonScope.contents.packageJsonContent;
-  if (!hasProperty(packageJsonContent, "name")) return;
-  if (!hasProperty(packageJsonContent, "version")) return;
-  if (!hasProperty(packageJsonScope, "packageDirectory")) return;
-  if (!isString(packageJsonScope.packageDirectory)) return;
-  const { name, version } = packageJsonContent;
-  if (!isString(name)) return;
-  if (!isString(version)) return;
-  const hasEffectInPeerDependencies = hasProperty(packageJsonContent, "peerDependencies") && isObject(packageJsonContent.peerDependencies) && hasProperty(packageJsonContent.peerDependencies, "effect");
-  const referencedPackages = Object.keys({
-    ...hasProperty(packageJsonContent, "dependencies") && isObject(packageJsonContent.dependencies) ? packageJsonContent.dependencies : {},
-    ...hasProperty(packageJsonContent, "peerDependencies") && isObject(packageJsonContent.peerDependencies) ? packageJsonContent.peerDependencies : {},
-    ...hasProperty(packageJsonContent, "devDependencies") && isObject(packageJsonContent.devDependencies) ? packageJsonContent.devDependencies : {}
-  });
-  const exportsKeys = Object.keys(
-    hasProperty(packageJsonContent, "exports") && isObject(packageJsonContent.exports) ? packageJsonContent.exports : {}
-  );
-  return {
-    name: name.toLowerCase(),
-    version: version.toLowerCase(),
-    hasEffectInPeerDependencies,
-    contents: packageJsonContent,
-    packageDirectory: packageJsonScope.packageDirectory,
-    referencedPackages,
-    exportsKeys
-  };
-}
-var resolveModulePattern = fn("resolveModulePattern")(
-  function* (sourceFile, pattern) {
+
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/array.js
+var isNonEmptyArray = (self) => self.length > 0;
+
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Array.js
+var fromIterable = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
+var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
+var appendAll = /* @__PURE__ */ dual(2, (self, that) => fromIterable(self).concat(fromIterable(that)));
+var isArray = Array.isArray;
+var isEmptyArray = (self) => self.length === 0;
+var isEmptyReadonlyArray = isEmptyArray;
+var isNonEmptyReadonlyArray = isNonEmptyArray;
+var isOutOfBounds = (i, as) => i < 0 || i >= as.length;
+var get = /* @__PURE__ */ dual(2, (self, index) => {
+  const i = Math.floor(index);
+  return isOutOfBounds(i, self) ? none2() : some2(self[i]);
+});
+var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
+  const i = Math.floor(index);
+  if (isOutOfBounds(i, self)) {
+    throw new Error(`Index ${i} out of bounds`);
+  }
+  return self[i];
+});
+var head = /* @__PURE__ */ get(0);
+var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
+var tailNonEmpty = (self) => self.slice(1);
+var sort = /* @__PURE__ */ dual(2, (self, O) => {
+  const out = Array.from(self);
+  out.sort(O);
+  return out;
+});
+var containsWith = (isEquivalent) => dual(2, (self, a) => {
+  for (const i of self) {
+    if (isEquivalent(a, i)) {
+      return true;
+    }
+  }
+  return false;
+});
+var _equivalence = /* @__PURE__ */ equivalence();
+var intersectionWith = (isEquivalent) => {
+  const has = containsWith(isEquivalent);
+  return dual(2, (self, that) => fromIterable(self).filter((a) => has(that, a)));
+};
+var intersection = /* @__PURE__ */ intersectionWith(_equivalence);
+var empty = () => [];
+var map4 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
+var flatMap2 = /* @__PURE__ */ dual(2, (self, f) => {
+  if (isEmptyReadonlyArray(self)) {
+    return [];
+  }
+  const out = [];
+  for (let i = 0; i < self.length; i++) {
+    const inner = f(self[i], i);
+    for (let j = 0; j < inner.length; j++) {
+      out.push(inner[j]);
+    }
+  }
+  return out;
+});
+var flatten = /* @__PURE__ */ flatMap2(identity);
+var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
+  const as = fromIterable(self);
+  const out = [];
+  for (let i = 0; i < as.length; i++) {
+    if (predicate(as[i], i)) {
+      out.push(as[i]);
+    }
+  }
+  return out;
+});
+var every = /* @__PURE__ */ dual(2, (self, refinement) => self.every(refinement));
+var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
+  const input = fromIterable(self);
+  if (isNonEmptyReadonlyArray(input)) {
+    const out = [headNonEmpty(input)];
+    const rest = tailNonEmpty(input);
+    for (const r of rest) {
+      if (out.every((a) => !isEquivalent(r, a))) {
+        out.push(r);
+      }
+    }
+    return out;
+  }
+  return [];
+});
+var dedupe = (self) => dedupeWith(self, equivalence());
+
+// src/core/TypeScriptUtils.ts
+var TypeScriptUtils = Tag("TypeScriptUtils");
+var nanoLayer = (fa) => pipe(
+  service(TypeScriptApi),
+  flatMap((ts) => pipe(fa, provideService(TypeScriptUtils, makeTypeScriptUtils(ts))))
+);
+function makeTypeScriptUtils(ts) {
+  function parsePackageContentNameAndVersionFromScope(v) {
+    if (!isObject(v)) return;
+    if (!hasProperty(v, "packageJsonScope")) return;
+    if (!v.packageJsonScope) return;
+    const packageJsonScope = v.packageJsonScope;
+    if (!hasProperty(packageJsonScope, "contents")) return;
+    if (!hasProperty(packageJsonScope.contents, "packageJsonContent")) return;
+    const packageJsonContent = packageJsonScope.contents.packageJsonContent;
+    if (!hasProperty(packageJsonContent, "name")) return;
+    if (!hasProperty(packageJsonContent, "version")) return;
+    if (!hasProperty(packageJsonScope, "packageDirectory")) return;
+    if (!isString(packageJsonScope.packageDirectory)) return;
+    const { name, version } = packageJsonContent;
+    if (!isString(name)) return;
+    if (!isString(version)) return;
+    const hasEffectInPeerDependencies = hasProperty(packageJsonContent, "peerDependencies") && isObject(packageJsonContent.peerDependencies) && hasProperty(packageJsonContent.peerDependencies, "effect");
+    const referencedPackages = Object.keys({
+      ...hasProperty(packageJsonContent, "dependencies") && isObject(packageJsonContent.dependencies) ? packageJsonContent.dependencies : {},
+      ...hasProperty(packageJsonContent, "peerDependencies") && isObject(packageJsonContent.peerDependencies) ? packageJsonContent.peerDependencies : {},
+      ...hasProperty(packageJsonContent, "devDependencies") && isObject(packageJsonContent.devDependencies) ? packageJsonContent.devDependencies : {}
+    });
+    const exportsKeys = Object.keys(
+      hasProperty(packageJsonContent, "exports") && isObject(packageJsonContent.exports) ? packageJsonContent.exports : {}
+    );
+    return {
+      name: name.toLowerCase(),
+      version: version.toLowerCase(),
+      hasEffectInPeerDependencies,
+      contents: packageJsonContent,
+      packageDirectory: packageJsonScope.packageDirectory,
+      referencedPackages,
+      exportsKeys
+    };
+  }
+  function resolveModulePattern(sourceFile, pattern) {
     if (pattern.indexOf("*") === -1) return [pattern.toLowerCase()];
-    const ts = yield* service(TypeScriptApi);
     const packageJsonScope = parsePackageContentNameAndVersionFromScope(sourceFile);
     const referencedPackages = [];
     for (const statement of sourceFile.statements) {
@@ -1161,31 +1163,47 @@ var resolveModulePattern = fn("resolveModulePattern")(
     return pipe(
       referencedPackages.concat(packageJsonScope?.referencedPackages || []),
       dedupe,
-      map3((packageName) => packageName.toLowerCase()),
+      map4((packageName) => packageName.toLowerCase()),
       filter(
         (packageName) => pattern.endsWith("*") && packageName.startsWith(pattern.toLowerCase().substring(0, pattern.length - 1))
       )
     );
   }
-);
-function makeGetModuleSpecifier(ts) {
-  if (!(hasProperty(ts, "moduleSpecifiers") && hasProperty(ts.moduleSpecifiers, "getModuleSpecifier") && isFunction2(ts.moduleSpecifiers.getModuleSpecifier))) return;
-  const _internal = ts.moduleSpecifiers.getModuleSpecifier;
-  return (compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, options) => {
-    return _internal(
-      compilerOptions,
-      importingSourceFile,
-      importingSourceFileName,
-      toFileName,
-      host,
-      options
-    );
-  };
-}
-
-// src/core/AST.ts
-function collectSelfAndAncestorNodesInRange(node, textRange) {
-  return sync(() => {
+  function makeGetModuleSpecifier() {
+    if (!(hasProperty(ts, "moduleSpecifiers") && hasProperty(ts.moduleSpecifiers, "getModuleSpecifier") && isFunction2(ts.moduleSpecifiers.getModuleSpecifier))) return;
+    const _internal = ts.moduleSpecifiers.getModuleSpecifier;
+    return (compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, options) => {
+      return _internal(
+        compilerOptions,
+        importingSourceFile,
+        importingSourceFileName,
+        toFileName,
+        host,
+        options
+      );
+    };
+  }
+  function findNodeWithLeadingCommentAtPosition(sourceFile, position) {
+    const sourceText = sourceFile.text;
+    let result;
+    function find(node) {
+      const leading = ts.getLeadingCommentRanges(sourceText, node.getFullStart());
+      if (leading) {
+        for (const commentRange of leading) {
+          if (commentRange.pos <= position && position < commentRange.end) {
+            result = { node, commentRange };
+            return;
+          }
+        }
+      }
+      if (node.getFullStart() <= position && position < node.getEnd()) {
+        node.forEachChild(find);
+      }
+    }
+    find(sourceFile);
+    return result;
+  }
+  function collectSelfAndAncestorNodesInRange(node, textRange) {
     let result = empty();
     let parent = node;
     while (parent) {
@@ -1195,52 +1213,50 @@ function collectSelfAndAncestorNodesInRange(node, textRange) {
       parent = parent.parent;
     }
     return result;
-  });
-}
-var getAncestorNodesInRange = fn("AST.getAncestorNodesInRange")(function* (sourceFile, textRange) {
-  const nodeAtPosition = yield* option(findNodeAtPosition(sourceFile, textRange.pos));
-  if (isNone2(nodeAtPosition)) return empty();
-  return yield* collectSelfAndAncestorNodesInRange(nodeAtPosition.value, textRange);
-});
-var NodeNotFoundError = class {
-  _tag = "@effect/language-service/NodeNotFoundError";
-};
-var findNodeAtPosition = fn("AST.findNodeAtPosition")(function* (sourceFile, position) {
-  const ts = yield* service(TypeScriptApi);
-  function find(node) {
-    if (position >= node.getStart() && position < node.getEnd()) {
-      return ts.forEachChild(node, find) || node;
+  }
+  function findNodeAtPosition(sourceFile, position) {
+    function find(node) {
+      if (position >= node.getStart() && position < node.getEnd()) {
+        return ts.forEachChild(node, find) || node;
+      }
+      return void 0;
     }
-    return void 0;
+    return find(sourceFile);
   }
-  const result = find(sourceFile);
-  if (!result) return yield* fail(new NodeNotFoundError());
-  return result;
-});
-var getCommentAtPosition = fn("TypeScriptApi.getCommentAtPosition")(function* (sourceFile, pos) {
-  const ts = yield* service(TypeScriptApi);
-  const token = yield* findNodeAtPosition(sourceFile, pos);
-  if (token === void 0 || token.kind === ts.SyntaxKind.JsxText || pos >= token.end - (ts.tokenToString(token.kind) || "").length) {
-    return yield* fail(new NodeNotFoundError());
-  }
-  const startPos = token.pos === 0 ? (ts.getShebang(sourceFile.text) || "").length : token.pos;
-  if (startPos === 0) return yield* fail(new NodeNotFoundError());
-  const result = ts.forEachTrailingCommentRange(sourceFile.text, startPos, isCommentInRange, pos) || ts.forEachLeadingCommentRange(sourceFile.text, startPos, isCommentInRange, pos);
-  if (!result) return yield* fail(new NodeNotFoundError());
-  return result;
-});
-function isCommentInRange(pos, end, kind, _nl, at) {
-  return at >= pos && at < end ? { pos, end, kind } : void 0;
-}
-function toTextRange(positionOrRange) {
-  return typeof positionOrRange === "number" ? { end: positionOrRange, pos: positionOrRange } : positionOrRange;
-}
-function isNodeInRange(textRange) {
-  return (node) => node.pos <= textRange.pos && node.end >= textRange.end;
-}
-var transformAsyncAwaitToEffectGen = fn("AST.transformAsyncAwaitToEffectGen")(
-  function* (node, effectModuleName, onAwait) {
-    const ts = yield* service(TypeScriptApi);
+  function findNodeAtPositionIncludingTrivia(sourceFile, position) {
+    function find(node) {
+      if (position >= node.pos && position < node.end) {
+        return ts.forEachChild(node, find) || node;
+      }
+      return void 0;
+    }
+    return find(sourceFile);
+  }
+  function getAncestorNodesInRange(sourceFile, textRange) {
+    const nodeAtPosition = findNodeAtPosition(sourceFile, textRange.pos);
+    if (!nodeAtPosition) return empty();
+    return collectSelfAndAncestorNodesInRange(nodeAtPosition, textRange);
+  }
+  function getCommentAtPosition(sourceFile, pos) {
+    const token = findNodeAtPositionIncludingTrivia(sourceFile, pos);
+    if (token === void 0 || token.kind === ts.SyntaxKind.JsxText || pos >= token.end - (ts.tokenToString(token.kind) || "").length) {
+      return;
+    }
+    const startPos = token.pos === 0 ? (ts.getShebang(sourceFile.text) || "").length : token.pos;
+    if (startPos === 0) return;
+    const result = ts.forEachTrailingCommentRange(sourceFile.text, startPos, isCommentInRange, pos) || ts.forEachLeadingCommentRange(sourceFile.text, startPos, isCommentInRange, pos);
+    return result;
+  }
+  function isCommentInRange(pos, end, kind, _nl, at) {
+    return at >= pos && at < end ? { pos, end, kind } : void 0;
+  }
+  function toTextRange(positionOrRange) {
+    return typeof positionOrRange === "number" ? { end: positionOrRange, pos: positionOrRange } : positionOrRange;
+  }
+  function isNodeInRange(textRange) {
+    return (node) => node.pos <= textRange.pos && node.end >= textRange.end;
+  }
+  function transformAsyncAwaitToEffectGen(node, effectModuleName, onAwait) {
     function visitor(_) {
       if (ts.isAwaitExpression(_)) {
         const expression = ts.visitEachChild(_.expression, visitor, ts.nullTransformationContext);
@@ -1252,7 +1268,7 @@ var transformAsyncAwaitToEffectGen = fn("AST.transformAsyncAwaitToEffectGen")(
       return ts.visitEachChild(_, visitor, ts.nullTransformationContext);
     }
     const generatorBody = visitor(node.body);
-    const effectGenCallExp = yield* createEffectGenCallExpression(effectModuleName, generatorBody);
+    const effectGenCallExp = createEffectGenCallExpression(effectModuleName, generatorBody);
     let currentFlags = ts.getCombinedModifierFlags(node);
     currentFlags &= ~ts.ModifierFlags.Async;
     const newModifiers = ts.factory.createModifiersFromModifierFlags(currentFlags);
@@ -1290,45 +1306,7 @@ var transformAsyncAwaitToEffectGen = fn("AST.transformAsyncAwaitToEffectGen")(
       newBody
     );
   }
-);
-var addReturnTypeAnnotation = fn("AST.addReturnTypeAnnotation")(function* (sourceFile, declaration, typeNode) {
-  const ts = yield* service(TypeScriptApi);
-  const changes = yield* service(ChangeTracker);
-  const closeParen = ts.findChildOfKind(declaration, ts.SyntaxKind.CloseParenToken, sourceFile);
-  const needParens = ts.isArrowFunction(declaration) && closeParen === void 0;
-  const endNode = needParens ? declaration.parameters[0] : closeParen;
-  if (endNode) {
-    if (needParens) {
-      changes.insertNodeBefore(
-        sourceFile,
-        endNode,
-        ts.factory.createToken(ts.SyntaxKind.OpenParenToken)
-      );
-      changes.insertNodeAfter(
-        sourceFile,
-        endNode,
-        ts.factory.createToken(ts.SyntaxKind.CloseParenToken)
-      );
-    }
-    changes.insertNodeAt(sourceFile, endNode.end, typeNode, { prefix: ": " });
-  }
-});
-var removeReturnTypeAnnotation = fn("AST.removeReturnTypeAnnotation")(function* (sourceFile, declaration) {
-  const ts = yield* service(TypeScriptApi);
-  const changes = yield* service(ChangeTracker);
-  const closeParen = ts.findChildOfKind(declaration, ts.SyntaxKind.CloseParenToken, sourceFile);
-  const needParens = ts.isArrowFunction(declaration) && closeParen === void 0;
-  const endNode = needParens ? declaration.parameters[0] : closeParen;
-  if (endNode && declaration.type) {
-    changes.deleteRange(sourceFile, { pos: endNode.end, end: declaration.type.end });
-  }
-});
-var ImportModuleIdentifierNotFoundError = class {
-  _tag = "@effect/language-service/ImportModuleIdentifierNotFoundError";
-};
-var findImportedModuleIdentifier = fn("AST.findImportedModuleIdentifier")(
-  function* (sourceFile, test) {
-    const ts = yield* service(TypeScriptApi);
+  function findImportedModuleIdentifier(sourceFile, test) {
     for (const statement of sourceFile.statements) {
       if (!ts.isImportDeclaration(statement)) continue;
       const importClause = statement.importClause;
@@ -1336,72 +1314,64 @@ var findImportedModuleIdentifier = fn("AST.findImportedModuleIdentifier")(
       const namedBindings = importClause.namedBindings;
       if (!namedBindings) continue;
       if (ts.isNamespaceImport(namedBindings)) {
-        if (yield* test(namedBindings.name, statement.moduleSpecifier, none2())) {
-          return namedBindings.name;
+        if (test(namedBindings.name, statement.moduleSpecifier, none2())) {
+          return namedBindings.name.text;
         }
       } else if (ts.isNamedImports(namedBindings)) {
         for (const importSpecifier of namedBindings.elements) {
           const importProperty = fromNullable(importSpecifier.propertyName).pipe(
             orElse(() => some2(importSpecifier.name))
           );
-          if (yield* test(importSpecifier.name, statement.moduleSpecifier, importProperty)) {
-            return importSpecifier.name;
+          if (test(importSpecifier.name, statement.moduleSpecifier, importProperty)) {
+            return importSpecifier.name.text;
           }
         }
       }
     }
-    return yield* fail(new ImportModuleIdentifierNotFoundError());
   }
-);
-function findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, packageName, moduleName) {
-  return findImportedModuleIdentifier(
-    sourceFile,
-    fn(
-      "AST.findImportedModuleIdentifierByPackageAndNameOrBarrel.findImportedModuleIdentifier"
-    )(function* (_, fromModule, importProperty) {
-      const ts = yield* service(TypeScriptApi);
-      if (isNone2(importProperty) && ts.isStringLiteral(fromModule) && fromModule.text === packageName + "/" + moduleName) {
-        return true;
+  function findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, packageName, moduleName) {
+    return findImportedModuleIdentifier(
+      sourceFile,
+      (_, fromModule, importProperty) => {
+        if (isNone2(importProperty) && ts.isStringLiteral(fromModule) && fromModule.text === packageName + "/" + moduleName) {
+          return true;
+        }
+        if (isSome2(importProperty) && ts.isIdentifier(importProperty.value) && importProperty.value.text === moduleName && ts.isStringLiteral(fromModule) && fromModule.text === packageName) {
+          return true;
+        }
+        return false;
       }
-      if (isSome2(importProperty) && ts.isIdentifier(importProperty.value) && importProperty.value.text === moduleName && ts.isStringLiteral(fromModule) && fromModule.text === packageName) {
-        return true;
+    );
+  }
+  function simplifyTypeNode(typeNode) {
+    function collectCallable(typeNode2) {
+      if (ts.isParenthesizedTypeNode(typeNode2)) return collectCallable(typeNode2.type);
+      if (ts.isFunctionTypeNode(typeNode2)) {
+        return some2([
+          ts.factory.createCallSignature(typeNode2.typeParameters, typeNode2.parameters, typeNode2.type)
+        ]);
+      }
+      if (ts.isTypeLiteralNode(typeNode2)) {
+        const allCallSignatures = typeNode2.members.every(ts.isCallSignatureDeclaration);
+        if (allCallSignatures) {
+          return some2(typeNode2.members);
+        }
       }
-      return false;
-    })
-  );
-}
-var simplifyTypeNode = fn("AST.simplifyTypeNode")(function* (typeNode) {
-  const ts = yield* service(TypeScriptApi);
-  function collectCallable(typeNode2) {
-    if (ts.isParenthesizedTypeNode(typeNode2)) return collectCallable(typeNode2.type);
-    if (ts.isFunctionTypeNode(typeNode2)) {
-      return some2([
-        ts.factory.createCallSignature(typeNode2.typeParameters, typeNode2.parameters, typeNode2.type)
-      ]);
-    }
-    if (ts.isTypeLiteralNode(typeNode2)) {
-      const allCallSignatures = typeNode2.members.every(ts.isCallSignatureDeclaration);
-      if (allCallSignatures) {
-        return some2(typeNode2.members);
+      if (ts.isIntersectionTypeNode(typeNode2)) {
+        const members = typeNode2.types.map((node) => collectCallable(node));
+        if (members.every(isSome2)) {
+          return some2(members.map((_) => isSome2(_) ? _.value : []).flat());
+        }
       }
+      return none2();
     }
-    if (ts.isIntersectionTypeNode(typeNode2)) {
-      const members = typeNode2.types.map((node) => collectCallable(node));
-      if (members.every(isSome2)) {
-        return some2(members.map((_) => isSome2(_) ? _.value : []).flat());
-      }
+    const callSignatures = collectCallable(typeNode);
+    if (isSome2(callSignatures) && callSignatures.value.length > 1) {
+      return ts.factory.createTypeLiteralNode(callSignatures.value);
     }
-    return none2();
-  }
-  const callSignatures = collectCallable(typeNode);
-  if (isSome2(callSignatures) && callSignatures.value.length > 1) {
-    return ts.factory.createTypeLiteralNode(callSignatures.value);
+    return typeNode;
   }
-  return typeNode;
-});
-var tryPreserveDeclarationSemantics = fn("AST.tryPreserveDeclarationSemantics")(
-  function* (nodeToReplace, node) {
-    const ts = yield* service(TypeScriptApi);
+  function tryPreserveDeclarationSemantics(nodeToReplace, node) {
     if (!ts.isExpression(node)) return node;
     if (ts.isFunctionDeclaration(nodeToReplace)) {
       if (!nodeToReplace.name) return node;
@@ -1428,14 +1398,9 @@ var tryPreserveDeclarationSemantics = fn("AST.tryPreserveDeclarationSemantics")(
     }
     return node;
   }
-);
-var parseAccessedExpressionForCompletion = fn(
-  "AST.parseAccessedExpressionForCompletion"
-)(
-  function* (sourceFile, position) {
-    const ts = yield* service(TypeScriptApi);
+  function parseAccessedExpressionForCompletion(sourceFile, position) {
     const precedingToken = ts.findPrecedingToken(position, sourceFile, void 0, true);
-    if (!precedingToken) return yield* fail(new NodeNotFoundError());
+    if (!precedingToken) return;
     let accessedObject = precedingToken;
     let replacementSpan = ts.createTextSpan(position, 0);
     let outerNode = precedingToken;
@@ -1461,67 +1426,56 @@ var parseAccessedExpressionForCompletion = fn(
       accessedObject = precedingToken;
       outerNode = precedingToken;
     } else {
-      return yield* fail(new NodeNotFoundError());
+      return;
     }
     return { accessedObject, outerNode, replacementSpan };
   }
-);
-var parseDataForExtendsClassCompletion = fn(
-  "AST.parseDataForExtendsClassCompletion"
-)(function* (sourceFile, position) {
-  const ts = yield* service(TypeScriptApi);
-  const { accessedObject, outerNode, replacementSpan } = yield* parseAccessedExpressionForCompletion(
-    sourceFile,
-    position
-  );
-  if (!ts.isIdentifier(accessedObject)) return yield* fail(new NodeNotFoundError());
-  let classDeclaration = outerNode.parent;
-  while (ts.isExpressionWithTypeArguments(classDeclaration) || ts.isHeritageClause(classDeclaration)) {
-    if (!classDeclaration.parent) break;
-    classDeclaration = classDeclaration.parent;
-  }
-  if (!ts.isClassDeclaration(classDeclaration)) return yield* fail(new NodeNotFoundError());
-  if (!classDeclaration.name) return yield* fail(new NodeNotFoundError());
-  return {
-    accessedObject,
-    classDeclaration,
-    className: classDeclaration.name,
-    replacementSpan
-  };
-});
-var createEffectGenCallExpression = fn("AST.createEffectGenCallExpression")(function* (effectModuleIdentifierName, node) {
-  const ts = yield* service(TypeScriptApi);
-  const generator = ts.factory.createFunctionExpression(
-    void 0,
-    ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
-    void 0,
-    [],
-    [],
-    void 0,
-    node
-    // NOTE(mattia): intended, to use same routine for both ConciseBody and Body
-  );
-  return ts.factory.createCallExpression(
-    ts.factory.createPropertyAccessExpression(
-      ts.factory.createIdentifier(effectModuleIdentifierName),
-      "gen"
-    ),
-    void 0,
-    [generator]
-  );
-});
-var createEffectGenCallExpressionWithBlock = fn(
-  "AST.createEffectGenCallExpressionWithBlock"
-)(function* (effectModuleIdentifierName, statement) {
-  const ts = yield* service(TypeScriptApi);
-  return yield* createEffectGenCallExpression(
-    effectModuleIdentifierName,
-    ts.factory.createBlock(Array.isArray(statement) ? statement : [statement], false)
-  );
-});
-var createReturnYieldStarStatement = fn("AST.createReturnYieldStarStatement")(
-  function* (expr) {
-    const ts = yield* service(TypeScriptApi);
+  function parseDataForExtendsClassCompletion(sourceFile, position) {
+    const maybeInfos = parseAccessedExpressionForCompletion(sourceFile, position);
+    if (!maybeInfos) return;
+    const { accessedObject, outerNode, replacementSpan } = maybeInfos;
+    if (!ts.isIdentifier(accessedObject)) return;
+    let classDeclaration = outerNode.parent;
+    while (ts.isExpressionWithTypeArguments(classDeclaration) || ts.isHeritageClause(classDeclaration)) {
+      if (!classDeclaration.parent) break;
+      classDeclaration = classDeclaration.parent;
+    }
+    if (!ts.isClassDeclaration(classDeclaration)) return;
+    if (!classDeclaration.name) return;
+    return {
+      accessedObject,
+      classDeclaration,
+      className: classDeclaration.name,
+      replacementSpan
+    };
+  }
+  function createEffectGenCallExpression(effectModuleIdentifierName, node) {
+    const generator = ts.factory.createFunctionExpression(
+      void 0,
+      ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+      void 0,
+      [],
+      [],
+      void 0,
+      node
+      // NOTE(mattia): intended, to use same routine for both ConciseBody and Body
+    );
+    return ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(effectModuleIdentifierName),
+        "gen"
+      ),
+      void 0,
+      [generator]
+    );
+  }
+  function createEffectGenCallExpressionWithBlock(effectModuleIdentifierName, statement) {
+    return createEffectGenCallExpression(
+      effectModuleIdentifierName,
+      ts.factory.createBlock(isArray(statement) ? statement : [statement], false)
+    );
+  }
+  function createReturnYieldStarStatement(expr) {
     return ts.factory.createReturnStatement(
       ts.factory.createYieldExpression(
         ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
@@ -1529,7 +1483,26 @@ var createReturnYieldStarStatement = fn("AST.createReturnYieldStarStatement")(
       )
     );
   }
-);
+  return {
+    findNodeAtPositionIncludingTrivia,
+    parsePackageContentNameAndVersionFromScope,
+    resolveModulePattern,
+    findNodeWithLeadingCommentAtPosition,
+    getCommentAtPosition,
+    getAncestorNodesInRange,
+    toTextRange,
+    isNodeInRange,
+    transformAsyncAwaitToEffectGen,
+    findImportedModuleIdentifierByPackageAndNameOrBarrel,
+    simplifyTypeNode,
+    tryPreserveDeclarationSemantics,
+    parseDataForExtendsClassCompletion,
+    createEffectGenCallExpressionWithBlock,
+    createReturnYieldStarStatement,
+    makeGetModuleSpecifier,
+    parseAccessedExpressionForCompletion
+  };
+}
 
 // src/core/LanguageServicePluginOptions.ts
 var LanguageServicePluginOptions = Tag("PluginOptions");
@@ -1539,7 +1512,7 @@ function parseDiagnosticSeverity(config) {
     pipe(
       Object.entries(config),
       filter(([key, value]) => isString(key) && isString(value)),
-      map3(([key, value]) => [String(key).toLowerCase(), String(value).toLowerCase()]),
+      map4(([key, value]) => [String(key).toLowerCase(), String(value).toLowerCase()]),
       filter(
         ([_, value]) => value === "off" || value === "error" || value === "warning" || value === "message" || value === "suggestion"
       )
@@ -1631,27 +1604,8 @@ var getCompletionsAtPosition = fn("LSP.getCompletionsAtPosition")(function* (com
 var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
   function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const pluginOptions = yield* service(LanguageServicePluginOptions);
-    function findNodeWithLeadingCommentAtPosition(position) {
-      const sourceText = sourceFile.text;
-      let result;
-      function find(node) {
-        const leading = ts.getLeadingCommentRanges(sourceText, node.getFullStart());
-        if (leading) {
-          for (const r of leading) {
-            if (r.pos <= position && position < r.end) {
-              result = node;
-              return;
-            }
-          }
-        }
-        if (node.getFullStart() <= position && position < node.getEnd()) {
-          node.forEachChild(find);
-        }
-      }
-      find(sourceFile);
-      return result;
-    }
     function findParentStatementForDisableNextLine(node) {
       let result;
       function find(node2) {
@@ -1669,10 +1623,10 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
     const sectionOverrides = {};
     const skippedRules = [];
     const regex = /@effect-diagnostics(-next-line)?((?:\s[a-zA-Z0-9/]+:(?:off|warning|error|message|suggestion|skip-file))+)?/gm;
-    let match3;
-    while ((match3 = regex.exec(sourceFile.text)) !== null) {
-      const nextLineCaptureGroup = match3[1];
-      const rulesCaptureGroup = match3[2];
+    let match2;
+    while ((match2 = regex.exec(sourceFile.text)) !== null) {
+      const nextLineCaptureGroup = match2[1];
+      const rulesCaptureGroup = match2[2];
       if (rulesCaptureGroup) {
         const trimmedRuleString = rulesCaptureGroup.trim();
         if (trimmedRuleString) {
@@ -1684,19 +1638,19 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
               if (ruleLevel === "skip-file") skippedRules.push(ruleName);
               const isOverrideNextLine = nextLineCaptureGroup && nextLineCaptureGroup.trim().toLowerCase() === "-next-line";
               if (isOverrideNextLine) {
-                const node = findNodeWithLeadingCommentAtPosition(match3.index);
-                if (node) {
+                const foundNode = tsUtils.findNodeWithLeadingCommentAtPosition(sourceFile, match2.index);
+                if (foundNode) {
                   lineOverrides[ruleName] = lineOverrides[ruleName] || [];
                   lineOverrides[ruleName].unshift({
-                    pos: node.getFullStart(),
-                    end: node.end,
+                    pos: foundNode.node.getFullStart(),
+                    end: foundNode.node.end,
                     level: ruleLevel
                   });
                 }
               } else {
                 sectionOverrides[ruleName] = sectionOverrides[ruleName] || [];
                 sectionOverrides[ruleName].unshift({
-                  pos: match3.index,
+                  pos: match2.index,
                   level: ruleLevel
                 });
               }
@@ -1711,7 +1665,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       message: ts.DiagnosticCategory.Message,
       suggestion: ts.DiagnosticCategory.Suggestion
     };
-    const execute = fn("LSP.ruleExecutor")(function* (rule) {
+    const execute = (rule) => gen(function* () {
       const diagnostics2 = [];
       const codeFixes = [];
       const ruleNameLowered = rule.name.toLowerCase();
@@ -1720,13 +1674,13 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       if (defaultLevel === "off" && (lineOverrides[ruleNameLowered] || sectionOverrides[ruleNameLowered] || []).length === 0) {
         return { diagnostics: diagnostics2, codeFixes };
       }
-      const fixByDisableNextLine = (_) => ({
+      const fixByDisableNextLine = (node) => ({
         fixName: rule.name + "_skipNextLine",
         description: "Disable " + rule.name + " for this line",
-        apply: flatMap2(
+        apply: flatMap(
           service(ChangeTracker),
-          (changeTracker) => sync(() => {
-            const disableAtNode = findParentStatementForDisableNextLine(_.node);
+          (changeTracker) => gen(function* () {
+            const disableAtNode = findParentStatementForDisableNextLine(node);
             const { line } = ts.getLineAndCharacterOfPosition(sourceFile, disableAtNode.getStart());
             changeTracker.insertCommentBeforeLine(
               sourceFile,
@@ -1740,7 +1694,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       const fixByDisableEntireFile = {
         fixName: rule.name + "_skipFile",
         description: "Disable " + rule.name + " for this entire file",
-        apply: flatMap2(
+        apply: flatMap(
           service(ChangeTracker),
           (changeTracker) => sync(
             () => changeTracker.insertText(
@@ -1754,29 +1708,30 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       };
       const applicableDiagnostics = [];
       yield* rule.apply(sourceFile, (entry) => {
+        const range = "getEnd" in entry.location ? { pos: entry.location.getStart(sourceFile), end: entry.location.getEnd() } : entry.location;
+        const node = "getEnd" in entry.location ? entry.location : tsUtils.findNodeAtPositionIncludingTrivia(sourceFile, entry.location.pos);
         applicableDiagnostics.push({
-          ...entry,
-          fixes: entry.fixes.concat([fixByDisableNextLine(entry), fixByDisableEntireFile])
+          range,
+          messageText: entry.messageText,
+          fixes: entry.fixes.concat(node ? [fixByDisableNextLine(node)] : []).concat([fixByDisableEntireFile])
         });
       });
       for (const emitted of applicableDiagnostics.slice(0)) {
         let newLevel = defaultLevel;
         const lineOverride = (lineOverrides[ruleNameLowered] || []).find(
-          (_) => _.pos < emitted.node.getStart(sourceFile) && _.end >= emitted.node.getEnd()
+          (_) => _.pos < emitted.range.pos && _.end >= emitted.range.end
         );
         if (lineOverride) {
           newLevel = lineOverride.level;
         } else {
-          const sectionOverride = (sectionOverrides[ruleNameLowered] || []).find(
-            (_) => _.pos < emitted.node.getStart(sourceFile)
-          );
+          const sectionOverride = (sectionOverrides[ruleNameLowered] || []).find((_) => _.pos < emitted.range.pos);
           if (sectionOverride) newLevel = sectionOverride.level;
         }
         if (!(newLevel in levelToDiagnosticCategory)) continue;
         diagnostics2.push({
           file: sourceFile,
-          start: emitted.node.getStart(sourceFile),
-          length: emitted.node.getEnd() - emitted.node.getStart(sourceFile),
+          start: emitted.range.pos,
+          length: emitted.range.end - emitted.range.pos,
           messageText: emitted.messageText,
           category: levelToDiagnosticCategory[newLevel],
           code: rule.code,
@@ -1786,8 +1741,8 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
           codeFixes.push({
             ...fix,
             code: rule.code,
-            start: emitted.node.getStart(sourceFile),
-            end: emitted.node.getEnd()
+            start: emitted.range.pos,
+            end: emitted.range.end
           });
         }
       }
@@ -1796,28 +1751,97 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
     return { execute };
   }
 );
+var cyrb53 = (str, seed = 0) => {
+  let h1 = 3735928559 ^ seed, h2 = 1103547991 ^ seed;
+  for (let i = 0, ch; i < str.length; i++) {
+    ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507);
+  h1 ^= Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
+  h2 ^= Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (h2 >>> 0).toString(16).padStart(8, "0") + (h1 >>> 0).toString(16).padStart(8, "0");
+};
+var CodegenNotApplicableError = class {
+  constructor(cause) {
+    this.cause = cause;
+  }
+  _tag = "@effect/language-service/CodegenNotApplicableError";
+};
+function createCodegen(definition) {
+  return definition;
+}
+var getCodegensForSourceFile = fn("LSP.getApplicableCodegens")(function* (codegens2, sourceFile) {
+  const tsUtils = yield* service(TypeScriptUtils);
+  const result = [];
+  const regex = /@effect-codegens((?:\s[a-zA-Z0-9]+(?::(?:[a-zA-Z0-9]+))?)+)+/gmid;
+  let match2;
+  while ((match2 = regex.exec(sourceFile.text)) !== null) {
+    const pos = match2.indices?.[0]?.[0];
+    if (!pos) continue;
+    const commentRange = tsUtils.getCommentAtPosition(sourceFile, pos);
+    if (!commentRange) continue;
+    const commentText = sourceFile.text.slice(pos, commentRange.end);
+    const codegenRegex = /(\s+)(\w+)(?::(\w+))?/gmi;
+    let codegenMatch;
+    while ((codegenMatch = codegenRegex.exec(commentText)) !== null) {
+      const whitespace = codegenMatch[1] || "";
+      const codegenName = codegenMatch[2] || "";
+      const codegenHash = codegenMatch[3] || "";
+      const range = {
+        pos: codegenMatch.index + pos + whitespace.length,
+        end: codegenMatch.index + pos + codegenMatch[0].length
+      };
+      const codegen = codegens2.find((codegen2) => codegen2.name === codegenName);
+      if (!codegen) continue;
+      result.push({ codegen, hash: codegenHash, range });
+    }
+  }
+  return result;
+});
+var getEditsForCodegen = fn("LSP.getEditsForCodegen")(function* (codegens2, sourceFile, textRange) {
+  const applicableCodegens = yield* getCodegensForSourceFile(codegens2, sourceFile);
+  const inRangeCodegens = applicableCodegens.filter(
+    (codegen2) => codegen2.range.pos <= textRange.pos && codegen2.range.end >= textRange.end
+  );
+  if (inRangeCodegens.length !== 1) {
+    return yield* fail(new CodegenNotApplicableError("zero or multiple codegens in range"));
+  }
+  const { codegen, range } = inRangeCodegens[0];
+  const edit = yield* codegen.apply(sourceFile, range);
+  const updateHashComment = pipe(
+    service(ChangeTracker),
+    map3((changeTracker) => {
+      changeTracker.deleteRange(sourceFile, range);
+      changeTracker.insertText(sourceFile, range.pos, `${codegen.name}:${edit.hash}`);
+    })
+  );
+  return {
+    ...edit,
+    apply: pipe(
+      edit.apply,
+      flatMap(() => updateHashComment)
+    ),
+    ignore: updateHashComment
+  };
+});
 
 // src/completions/contextSelfInClasses.ts
 var contextSelfInClasses = createCompletion({
   name: "contextSelfInClasses",
   apply: fn("contextSelfInClasses")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
-    const maybeInfos = yield* option(
-      parseDataForExtendsClassCompletion(sourceFile, position)
-    );
-    if (isNone2(maybeInfos)) return [];
-    const { accessedObject, className, replacementSpan } = maybeInfos.value;
-    const contextName = yield* option(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Context"
-      )
-    );
-    const contextIdentifier = match(contextName, {
-      onNone: () => "Context",
-      onSome: (_) => _.text
-    });
+    const tsUtils = yield* service(TypeScriptUtils);
+    const maybeInfos = tsUtils.parseDataForExtendsClassCompletion(sourceFile, position);
+    if (!maybeInfos) return [];
+    const { accessedObject, className, replacementSpan } = maybeInfos;
+    const contextIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Context"
+    ) || "Context";
     if (contextIdentifier !== accessedObject.text) return [];
     const name = className.text;
     return [{
@@ -1832,12 +1856,6 @@ var contextSelfInClasses = createCompletion({
 
 // src/core/TypeCheckerApi.ts
 var TypeCheckerApi = Tag("TypeChecker");
-var TypeCheckerApiCache = Tag("TypeCheckerApiCache");
-function makeTypeCheckerApiCache() {
-  return {
-    expectedAndRealType: /* @__PURE__ */ new WeakMap()
-  };
-}
 var deterministicTypeOrder = gen(function* () {
   const typeChecker = yield* service(TypeCheckerApi);
   return make2((a, b) => {
@@ -1936,106 +1954,106 @@ var getInferredReturnType = fn("TypeCheckerApi.getInferredReturnType")(function*
   }
   return returnType;
 });
-var expectedAndRealType = fn("TypeCheckerApi.expectedAndRealType")(function* (sourceFile) {
-  const cache = yield* service(TypeCheckerApiCache);
-  const resultCached = cache.expectedAndRealType.get(sourceFile);
-  if (resultCached) return resultCached;
-  const typeChecker = yield* service(TypeCheckerApi);
-  const ts = yield* service(TypeScriptApi);
-  const result = [];
-  const nodeToVisit = [sourceFile];
-  const appendNodeToVisit = (node) => {
-    nodeToVisit.push(node);
-    return void 0;
-  };
-  while (nodeToVisit.length > 0) {
-    const node = nodeToVisit.shift();
-    if (ts.isVariableDeclaration(node) && node.initializer) {
-      const expectedType = typeChecker.getTypeAtLocation(node.name);
-      const realType = typeChecker.getTypeAtLocation(node.initializer);
-      result.push([node.name, expectedType, node.initializer, realType]);
-      appendNodeToVisit(node.initializer);
-      continue;
-    } else if (ts.isCallExpression(node)) {
-      const resolvedSignature = typeChecker.getResolvedSignature(node);
-      if (resolvedSignature) {
-        resolvedSignature.getParameters().map((parameter, index) => {
-          const expectedType = typeChecker.getTypeOfSymbolAtLocation(parameter, node);
-          const realType = typeChecker.getTypeAtLocation(node.arguments[index]);
-          result.push([
-            node.arguments[index],
-            expectedType,
-            node.arguments[index],
-            realType
-          ]);
-        });
-      }
-      ts.forEachChild(node, appendNodeToVisit);
-      continue;
-    } else if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
-      const parent = node.parent;
-      if (ts.isObjectLiteralElement(parent)) {
-        if (ts.isObjectLiteralExpression(parent.parent) && parent.name === node) {
-          const type = typeChecker.getContextualType(parent.parent);
-          if (type) {
-            const symbol3 = typeChecker.getPropertyOfType(type, node.text);
-            if (symbol3) {
-              const expectedType = typeChecker.getTypeOfSymbolAtLocation(symbol3, node);
-              const realType = typeChecker.getTypeAtLocation(node);
-              result.push([node, expectedType, node, realType]);
+var expectedAndRealType = cachedBy(
+  fn("TypeCheckerApi.expectedAndRealType")(function* (sourceFile) {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const ts = yield* service(TypeScriptApi);
+    const result = [];
+    const nodeToVisit = [sourceFile];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts.isVariableDeclaration(node) && node.initializer) {
+        const expectedType = typeChecker.getTypeAtLocation(node.name);
+        const realType = typeChecker.getTypeAtLocation(node.initializer);
+        result.push([node.name, expectedType, node.initializer, realType]);
+        appendNodeToVisit(node.initializer);
+        continue;
+      } else if (ts.isCallExpression(node)) {
+        const resolvedSignature = typeChecker.getResolvedSignature(node);
+        if (resolvedSignature) {
+          resolvedSignature.getParameters().map((parameter, index) => {
+            const expectedType = typeChecker.getTypeOfSymbolAtLocation(parameter, node);
+            const realType = typeChecker.getTypeAtLocation(node.arguments[index]);
+            result.push([
+              node.arguments[index],
+              expectedType,
+              node.arguments[index],
+              realType
+            ]);
+          });
+        }
+        ts.forEachChild(node, appendNodeToVisit);
+        continue;
+      } else if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+        const parent = node.parent;
+        if (ts.isObjectLiteralElement(parent)) {
+          if (ts.isObjectLiteralExpression(parent.parent) && parent.name === node) {
+            const type = typeChecker.getContextualType(parent.parent);
+            if (type) {
+              const symbol3 = typeChecker.getPropertyOfType(type, node.text);
+              if (symbol3) {
+                const expectedType = typeChecker.getTypeOfSymbolAtLocation(symbol3, node);
+                const realType = typeChecker.getTypeAtLocation(node);
+                result.push([node, expectedType, node, realType]);
+              }
             }
           }
         }
-      }
-      ts.forEachChild(node, appendNodeToVisit);
-      continue;
-    } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
-      const expectedType = typeChecker.getTypeAtLocation(node.left);
-      const realType = typeChecker.getTypeAtLocation(node.right);
-      result.push([node.left, expectedType, node.right, realType]);
-      appendNodeToVisit(node.right);
-      continue;
-    } else if (ts.isReturnStatement(node) && node.expression) {
-      const parentDeclaration = yield* option(getAncestorConvertibleDeclaration(node));
-      if (isSome2(parentDeclaration)) {
-        const expectedType = yield* option(getInferredReturnType(parentDeclaration.value));
-        const realType = typeChecker.getTypeAtLocation(node.expression);
+        ts.forEachChild(node, appendNodeToVisit);
+        continue;
+      } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+        const expectedType = typeChecker.getTypeAtLocation(node.left);
+        const realType = typeChecker.getTypeAtLocation(node.right);
+        result.push([node.left, expectedType, node.right, realType]);
+        appendNodeToVisit(node.right);
+        continue;
+      } else if (ts.isReturnStatement(node) && node.expression) {
+        const parentDeclaration = yield* option(getAncestorConvertibleDeclaration(node));
+        if (isSome2(parentDeclaration)) {
+          const expectedType = yield* option(getInferredReturnType(parentDeclaration.value));
+          const realType = typeChecker.getTypeAtLocation(node.expression);
+          if (isSome2(expectedType)) {
+            result.push([node, expectedType.value, node, realType]);
+          }
+        }
+        ts.forEachChild(node, appendNodeToVisit);
+        continue;
+      } else if (ts.isArrowFunction(node) && (node.typeParameters || []).length === 0 && ts.isExpression(node.body)) {
+        const body = node.body;
+        const expectedType = typeChecker.getContextualType(body);
+        const realType = typeChecker.getTypeAtLocation(body);
+        if (expectedType) {
+          result.push([body, expectedType, body, realType]);
+        }
+        ts.forEachChild(body, appendNodeToVisit);
+        continue;
+      } else if (ts.isArrowFunction(node) && (node.typeParameters || []).length > 0 && ts.isExpression(node.body)) {
+        const body = node.body;
+        const expectedType = yield* option(getInferredReturnType(node));
+        const realType = typeChecker.getTypeAtLocation(body);
         if (isSome2(expectedType)) {
-          result.push([node, expectedType.value, node, realType]);
+          result.push([body, expectedType.value, body, realType]);
         }
+        ts.forEachChild(body, appendNodeToVisit);
+        continue;
+      } else if (ts.isSatisfiesExpression(node)) {
+        const expectedType = typeChecker.getTypeAtLocation(node.type);
+        const realType = typeChecker.getTypeAtLocation(node.expression);
+        result.push([node.expression, expectedType, node.expression, realType]);
+        appendNodeToVisit(node.expression);
+        continue;
       }
       ts.forEachChild(node, appendNodeToVisit);
-      continue;
-    } else if (ts.isArrowFunction(node) && (node.typeParameters || []).length === 0 && ts.isExpression(node.body)) {
-      const body = node.body;
-      const expectedType = typeChecker.getContextualType(body);
-      const realType = typeChecker.getTypeAtLocation(body);
-      if (expectedType) {
-        result.push([body, expectedType, body, realType]);
-      }
-      ts.forEachChild(body, appendNodeToVisit);
-      continue;
-    } else if (ts.isArrowFunction(node) && (node.typeParameters || []).length > 0 && ts.isExpression(node.body)) {
-      const body = node.body;
-      const expectedType = yield* option(getInferredReturnType(node));
-      const realType = typeChecker.getTypeAtLocation(body);
-      if (isSome2(expectedType)) {
-        result.push([body, expectedType.value, body, realType]);
-      }
-      ts.forEachChild(body, appendNodeToVisit);
-      continue;
-    } else if (ts.isSatisfiesExpression(node)) {
-      const expectedType = typeChecker.getTypeAtLocation(node.type);
-      const realType = typeChecker.getTypeAtLocation(node.expression);
-      result.push([node.expression, expectedType, node.expression, realType]);
-      appendNodeToVisit(node.expression);
-      continue;
     }
-    ts.forEachChild(node, appendNodeToVisit);
-  }
-  cache.expectedAndRealType.set(sourceFile, result);
-  return result;
-});
+    return result;
+  }),
+  "TypeCheckerApi.expectedAndRealType",
+  (sourceFile) => sourceFile
+);
 var unrollUnionMembers = (type) => {
   const result = [];
   let toTest = [type];
@@ -2131,109 +2149,31 @@ var durationInput = createCompletion({
                   (name) => ({
                     name,
                     kind: ts.ScriptElementKind.string,
-                    insertText: `${"${0}"} ${name}`,
-                    isSnippet: true
-                  })
-                );
-              }
-            }
-          }
-        }
-      }
-    }
-    return [];
-  })
-});
-
-// src/completions/effectDataClasses.ts
-var effectDataClasses = createCompletion({
-  name: "effectDataClasses",
-  apply: fn("effectDataClasses")(function* (sourceFile, position) {
-    const ts = yield* service(TypeScriptApi);
-    const maybeInfos = yield* option(
-      parseDataForExtendsClassCompletion(sourceFile, position)
-    );
-    if (isNone2(maybeInfos)) return [];
-    const { accessedObject, className, replacementSpan } = maybeInfos.value;
-    const dataName = yield* option(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Data"
-      )
-    );
-    const effectDataIdentifier = match(dataName, {
-      onNone: () => "Data",
-      onSome: (_) => _.text
-    });
-    if (effectDataIdentifier !== accessedObject.text) return [];
-    const name = className.text;
-    return [{
-      name: `TaggedError("${name}")`,
-      kind: ts.ScriptElementKind.constElement,
-      insertText: `${effectDataIdentifier}.TaggedError("${name}")<{${"${0}"}}>{}`,
-      replacementSpan,
-      isSnippet: true
-    }, {
-      name: `TaggedClass("${name}")`,
-      kind: ts.ScriptElementKind.constElement,
-      insertText: `${effectDataIdentifier}.TaggedClass("${name}")<{${"${0}"}}>{}`,
-      replacementSpan,
-      isSnippet: true
-    }];
-  })
-});
-
-// src/diagnostics/duplicatePackage.ts
-var checkedPackagesCache = /* @__PURE__ */ new Map();
-var programResolvedCacheSize = /* @__PURE__ */ new Map();
-var duplicatePackage = createDiagnostic({
-  name: "duplicatePackage",
-  code: 6,
-  severity: "warning",
-  apply: fn("duplicatePackage.apply")(function* (sourceFile, report) {
-    const program = yield* service(TypeScriptProgram);
-    const options = yield* service(LanguageServicePluginOptions);
-    if (sourceFile.statements.length < 1) return;
-    let resolvedPackages = checkedPackagesCache.get(sourceFile.fileName) || {};
-    const newResolvedModuleSize = hasProperty(program, "resolvedModules") && hasProperty(program.resolvedModules, "size") && isNumber(program.resolvedModules.size) ? program.resolvedModules.size : 0;
-    const oldResolvedSize = programResolvedCacheSize.get(sourceFile.fileName) || -1;
-    if (newResolvedModuleSize !== oldResolvedSize) {
-      const seenPackages = /* @__PURE__ */ new Set();
-      resolvedPackages = {};
-      program.getSourceFiles().map((_) => {
-        const packageInfo = parsePackageContentNameAndVersionFromScope(_);
-        if (!packageInfo) return;
-        const packageNameAndVersion = packageInfo.name + "@" + packageInfo.version;
-        if (seenPackages.has(packageNameAndVersion)) return;
-        seenPackages.add(packageNameAndVersion);
-        if (!(packageInfo.name === "effect" || packageInfo.hasEffectInPeerDependencies)) return;
-        if (options.allowedDuplicatedPackages.indexOf(packageInfo.name) > -1) return;
-        resolvedPackages[packageInfo.name] = resolvedPackages[packageInfo.name] || {};
-        resolvedPackages[packageInfo.name][packageInfo.version] = packageInfo.packageDirectory;
-      });
-      checkedPackagesCache.set(sourceFile.fileName, resolvedPackages);
-      programResolvedCacheSize.set(sourceFile.fileName, newResolvedModuleSize);
-    }
-    for (const packageName of Object.keys(resolvedPackages)) {
-      if (Object.keys(resolvedPackages[packageName]).length > 1) {
-        const versions = Object.keys(resolvedPackages[packageName]);
-        report({
-          node: sourceFile.statements[0],
-          messageText: `Package ${packageName} is referenced multiple times with different versions (${versions.join(", ")}) and may cause unexpected type errors.
-Cleanup your dependencies and your package lockfile to avoid multiple instances of this package and reload the project.
-If this is intended set the LSP config "allowedDuplicatedPackages" to ${JSON.stringify(options.allowedDuplicatedPackages.concat([packageName]))}.
-
-${versions.map((version) => `- found ${version} at ${resolvedPackages[packageName][version]}`).join("\n")}`,
-          fixes: []
-        });
+                    insertText: `${"${0}"} ${name}`,
+                    isSnippet: true
+                  })
+                );
+              }
+            }
+          }
+        }
       }
     }
+    return [];
   })
 });
 
 // src/core/TypeParser.ts
 var TypeParser = Tag("@effect/language-service/TypeParser");
+var nanoLayer2 = (fa) => gen(function* () {
+  const ts = yield* service(TypeScriptApi);
+  const tsUtils = yield* service(TypeScriptUtils);
+  const typeChecker = yield* service(TypeCheckerApi);
+  return yield* pipe(
+    fa,
+    provideService(TypeParser, make3(ts, tsUtils, typeChecker))
+  );
+});
 var TypeParserIssue = class _TypeParserIssue {
   _tag = "@effect/language-service/TypeParserIssue";
   static issue = fail(new _TypeParserIssue());
@@ -2241,7 +2181,7 @@ var TypeParserIssue = class _TypeParserIssue {
 function typeParserIssue(_message, _type, _node) {
   return TypeParserIssue.issue;
 }
-function make3(ts, typeChecker) {
+function make3(ts, tsUtils, typeChecker) {
   function covariantTypeArgument(type) {
     const signatures = type.getCallSignatures();
     if (signatures.length !== 1) {
@@ -2303,7 +2243,7 @@ function make3(ts, typeChecker) {
     const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
     return invariantTypeArgument(propertyType);
   };
-  const effectVarianceStruct = (type, atLocation) => map4(
+  const effectVarianceStruct = (type, atLocation) => map3(
     all(
       varianceStructCovariantType(type, atLocation, "_A"),
       varianceStructCovariantType(type, atLocation, "_E"),
@@ -2311,7 +2251,7 @@ function make3(ts, typeChecker) {
     ),
     ([A, E, R]) => ({ A, E, R })
   );
-  const layerVarianceStruct = (type, atLocation) => map4(
+  const layerVarianceStruct = (type, atLocation) => map3(
     all(
       varianceStructContravariantType(type, atLocation, "_ROut"),
       varianceStructCovariantType(type, atLocation, "_E"),
@@ -2399,6 +2339,36 @@ function make3(ts, typeChecker) {
     "TypeParser.effectSubtype",
     (type) => type
   );
+  const importedSchemaModule = cachedBy(
+    fn("TypeParser.importedSchemaModule")(function* (node) {
+      const type = typeChecker.getTypeAtLocation(node);
+      const propertySymbol = typeChecker.getPropertyOfType(type, "Class");
+      if (!propertySymbol) {
+        return yield* typeParserIssue("Type has no 'Class' property", type, node);
+      }
+      if (!ts.isExpression(node)) {
+        return yield* typeParserIssue("Node is not an expression", type, node);
+      }
+      return node;
+    }),
+    "TypeParser.importedSchemaModule",
+    (node) => node
+  );
+  const importedContextModule = cachedBy(
+    fn("TypeParser.importedContextModule")(function* (node) {
+      const type = typeChecker.getTypeAtLocation(node);
+      const propertySymbol = typeChecker.getPropertyOfType(type, "Tag");
+      if (!propertySymbol) {
+        return yield* typeParserIssue("Type has no 'Tag' property", type, node);
+      }
+      if (!ts.isExpression(node)) {
+        return yield* typeParserIssue("Node is not an expression", type, node);
+      }
+      return node;
+    }),
+    "TypeParser.importedContextModule",
+    (node) => node
+  );
   const importedEffectModule = cachedBy(
     fn("TypeParser.importedEffectModule")(function* (node) {
       const type = typeChecker.getTypeAtLocation(node);
@@ -2440,7 +2410,7 @@ function make3(ts, typeChecker) {
       }
       return pipe(
         importedEffectModule(propertyAccess.expression),
-        map4((effectModule) => ({
+        map3((effectModule) => ({
           node,
           effectModule,
           generatorFunction,
@@ -2488,7 +2458,7 @@ function make3(ts, typeChecker) {
       }
       return pipe(
         importedEffectModule(propertyAccess.expression),
-        map4((effectModule) => ({
+        map3((effectModule) => ({
           node,
           effectModule,
           generatorFunction,
@@ -2541,7 +2511,7 @@ function make3(ts, typeChecker) {
       }
       return pipe(
         importedEffectModule(propertyAccess.expression),
-        map4((effectModule) => ({
+        map3((effectModule) => ({
           node,
           generatorFunction,
           effectModule,
@@ -2583,15 +2553,11 @@ function make3(ts, typeChecker) {
           if (!explicitReturn && !(successType.flags & ts.TypeFlags.VoidLike)) {
             replacementNode = pipe(
               gen(function* () {
-                const effectIdentifier = pipe(
-                  yield* option(
-                    findImportedModuleIdentifierByPackageAndNameOrBarrel(node.getSourceFile(), "effect", "Effect")
-                  ),
-                  match({
-                    onNone: () => "Effect",
-                    onSome: (_) => _.text
-                  })
-                );
+                const effectIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+                  node.getSourceFile(),
+                  "effect",
+                  "Effect"
+                ) || "Effect";
                 return ts.factory.createCallExpression(
                   ts.factory.createPropertyAccessExpression(
                     ts.factory.createIdentifier(effectIdentifier),
@@ -2619,7 +2585,7 @@ function make3(ts, typeChecker) {
     "TypeParser.unnecessaryEffectGen",
     (node) => node
   );
-  const effectSchemaVarianceStruct = (type, atLocation) => map4(
+  const effectSchemaVarianceStruct = (type, atLocation) => map3(
     all(
       varianceStructInvariantType(type, atLocation, "_A"),
       varianceStructInvariantType(type, atLocation, "_I"),
@@ -2651,7 +2617,7 @@ function make3(ts, typeChecker) {
     "TypeParser.effectSchemaType",
     (type) => type
   );
-  const contextTagVarianceStruct = (type, atLocation) => map4(
+  const contextTagVarianceStruct = (type, atLocation) => map3(
     all(
       varianceStructInvariantType(type, atLocation, "_Identifier"),
       varianceStructInvariantType(type, atLocation, "_Service")
@@ -2745,39 +2711,805 @@ function make3(ts, typeChecker) {
           if (!callbackParameter) {
             continue;
           }
-          const callbackParameterType = callableType.getTypeParameterAtPosition(0);
-          if (!callbackParameterType) {
-            continue;
+          const callbackParameterType = callableType.getTypeParameterAtPosition(0);
+          if (!callbackParameterType) {
+            continue;
+          }
+          return succeed({
+            type: callbackParameterType
+          });
+        }
+      }
+      return typeParserIssue("not a promise", type, atLocation);
+    },
+    "TypeParser.promiseLike",
+    (type) => type
+  );
+  const extendsSchemaClass = cachedBy(
+    fn("TypeParser.extendsSchemaClass")(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 expression = typeX.expression;
+            if (ts.isCallExpression(expression)) {
+              const schemaCall = expression.expression;
+              if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                const selfTypeNode = schemaCall.typeArguments[0];
+                const schemaIdentifier = schemaCall.expression;
+                if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "Class") {
+                  const parsedSchemaModule = yield* pipe(
+                    importedSchemaModule(schemaIdentifier.expression),
+                    option
+                  );
+                  if (isSome2(parsedSchemaModule)) {
+                    return {
+                      className: atLocation.name,
+                      selfTypeNode,
+                      Schema: parsedSchemaModule.value
+                    };
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Schema.Class", void 0, atLocation);
+    }),
+    "TypeParser.extendsSchemaClass",
+    (atLocation) => atLocation
+  );
+  const extendsSchemaTaggedClass = cachedBy(
+    fn("TypeParser.extendsSchemaTaggedClass")(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 expression = typeX.expression;
+            if (ts.isCallExpression(expression)) {
+              const tagCall = expression.expression;
+              if (ts.isCallExpression(tagCall)) {
+                const schemaCall = tagCall.expression;
+                if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                  const selfTypeNode = schemaCall.typeArguments[0];
+                  const schemaIdentifier = schemaCall.expression;
+                  if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "TaggedClass") {
+                    const parsedSchemaModule = yield* pipe(
+                      importedSchemaModule(schemaIdentifier.expression),
+                      option
+                    );
+                    if (isSome2(parsedSchemaModule)) {
+                      return {
+                        className: atLocation.name,
+                        selfTypeNode,
+                        Schema: parsedSchemaModule.value
+                      };
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Schema.TaggedClass", void 0, atLocation);
+    }),
+    "TypeParser.extendsSchemaTaggedClass",
+    (atLocation) => atLocation
+  );
+  const extendsSchemaTaggedError = cachedBy(
+    fn("TypeParser.extendsSchemaTaggedError")(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 expression = typeX.expression;
+            if (ts.isCallExpression(expression)) {
+              const tagCall = expression.expression;
+              if (ts.isCallExpression(tagCall)) {
+                const schemaCall = tagCall.expression;
+                if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                  const selfTypeNode = schemaCall.typeArguments[0];
+                  const schemaIdentifier = schemaCall.expression;
+                  if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "TaggedError") {
+                    const parsedSchemaModule = yield* pipe(
+                      importedSchemaModule(schemaIdentifier.expression),
+                      option
+                    );
+                    if (isSome2(parsedSchemaModule)) {
+                      return {
+                        className: atLocation.name,
+                        selfTypeNode,
+                        Schema: parsedSchemaModule.value
+                      };
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Schema.TaggedError", void 0, atLocation);
+    }),
+    "TypeParser.extendsSchemaTaggedError",
+    (atLocation) => atLocation
+  );
+  const extendsSchemaTaggedRequest = cachedBy(
+    fn("TypeParser.extendsSchemaTaggedRequest")(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 expression = typeX.expression;
+            if (ts.isCallExpression(expression)) {
+              const tagCall = expression.expression;
+              if (ts.isCallExpression(tagCall)) {
+                const schemaCall = tagCall.expression;
+                if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                  const selfTypeNode = schemaCall.typeArguments[0];
+                  const schemaIdentifier = schemaCall.expression;
+                  if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "TaggedRequest") {
+                    const parsedSchemaModule = yield* pipe(
+                      importedSchemaModule(schemaIdentifier.expression),
+                      option
+                    );
+                    if (isSome2(parsedSchemaModule)) {
+                      return {
+                        className: atLocation.name,
+                        selfTypeNode,
+                        Schema: parsedSchemaModule.value
+                      };
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Schema.TaggedRequest", void 0, atLocation);
+    }),
+    "TypeParser.extendsSchemaTaggedRequest",
+    (atLocation) => atLocation
+  );
+  const extendsContextTag = cachedBy(
+    fn("TypeParser.extendsContextTag")(function* (atLocation) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
+      if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
+      const type = typeChecker.getTypeOfSymbol(classSym);
+      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 contextTagCall = wholeCall.expression;
+              if (ts.isCallExpression(contextTagCall) && wholeCall.typeArguments && wholeCall.typeArguments.length > 0) {
+                const contextTagIdentifier = contextTagCall.expression;
+                const selfTypeNode = wholeCall.typeArguments[0];
+                if (ts.isPropertyAccessExpression(contextTagIdentifier) && ts.isIdentifier(contextTagIdentifier.name) && contextTagIdentifier.name.text === "Tag") {
+                  const parsedContextModule = yield* pipe(
+                    importedContextModule(contextTagIdentifier.expression),
+                    option
+                  );
+                  if (isSome2(parsedContextModule)) {
+                    const tagType = yield* contextTag(type, atLocation);
+                    return {
+                      className: atLocation.name,
+                      selfTypeNode,
+                      args: contextTagCall.arguments,
+                      Identifier: tagType.Identifier,
+                      Tag: parsedContextModule.value
+                    };
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Context.Tag", void 0, atLocation);
+    }),
+    "TypeParser.extendsContextTag",
+    (atLocation) => atLocation
+  );
+  const extendsEffectService = cachedBy(
+    fn("TypeParser.extendsEffectService")(function* (atLocation) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
+      if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
+      const type = typeChecker.getTypeOfSymbol(classSym);
+      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 effectServiceCall = wholeCall.expression;
+              if (ts.isCallExpression(effectServiceCall) && effectServiceCall.typeArguments && effectServiceCall.typeArguments.length > 0) {
+                const effectServiceIdentifier = effectServiceCall.expression;
+                const selfTypeNode = effectServiceCall.typeArguments[0];
+                if (ts.isPropertyAccessExpression(effectServiceIdentifier) && ts.isIdentifier(effectServiceIdentifier.name) && effectServiceIdentifier.name.text === "Service") {
+                  const parsedContextTag = yield* pipe(
+                    importedEffectModule(effectServiceIdentifier.expression),
+                    flatMap(() => contextTag(type, atLocation)),
+                    option
+                  );
+                  if (isSome2(parsedContextTag)) {
+                    let accessors2 = void 0;
+                    if (wholeCall.arguments.length >= 2) {
+                      const args2 = wholeCall.arguments[1];
+                      if (ts.isObjectLiteralExpression(args2)) {
+                        for (const property of args2.properties) {
+                          if (ts.isPropertyAssignment(property) && property.name && ts.isIdentifier(property.name) && property.name.text === "accessors" && property.initializer && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                            accessors2 = true;
+                          }
+                        }
+                      }
+                    }
+                    return {
+                      ...parsedContextTag.value,
+                      className: atLocation.name,
+                      selfTypeNode,
+                      args: wholeCall.arguments,
+                      accessors: accessors2
+                    };
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Effect.Service", void 0, atLocation);
+    }),
+    "TypeParser.extendsEffectService",
+    (atLocation) => atLocation
+  );
+  return {
+    effectType,
+    strictEffectType,
+    layerType,
+    fiberType,
+    effectSubtype,
+    importedEffectModule,
+    effectGen,
+    effectFnUntracedGen,
+    effectFnGen,
+    unnecessaryEffectGen: unnecessaryEffectGen2,
+    effectSchemaType,
+    contextTag,
+    pipeableType,
+    pipeCall,
+    scopeType,
+    promiseLike,
+    extendsEffectService,
+    extendsContextTag,
+    extendsSchemaClass,
+    extendsSchemaTaggedClass,
+    extendsSchemaTaggedError,
+    extendsSchemaTaggedRequest
+  };
+}
+
+// src/refactors/writeTagClassAccessors.ts
+var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, service2, className, atLocation, involvedMembers) {
+  const ts = yield* service(TypeScriptApi);
+  const tsUtils = yield* service(TypeScriptUtils);
+  const typeChecker = yield* service(TypeCheckerApi);
+  const typeParser = yield* service(TypeParser);
+  const changeTracker = yield* service(ChangeTracker);
+  const insertLocation = atLocation.members.length > 0 ? atLocation.members[0].pos : atLocation.getEnd() - 1;
+  const effectIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+    sourceFile,
+    "effect",
+    "Effect"
+  ) || "Effect";
+  const createFunctionProperty = (className2, propertyName, type, forceAny) => {
+    const arrowBody = ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(effectIdentifier),
+        "andThen"
+      ),
+      void 0,
+      [
+        ts.factory.createIdentifier(className2.text),
+        ts.factory.createArrowFunction(
+          void 0,
+          void 0,
+          [ts.factory.createParameterDeclaration(
+            void 0,
+            void 0,
+            "_",
+            void 0,
+            forceAny ? ts.factory.createTypeReferenceNode("any") : void 0
+          )],
+          void 0,
+          void 0,
+          ts.factory.createCallExpression(
+            ts.factory.createPropertyAccessExpression(
+              ts.factory.createIdentifier("_"),
+              propertyName
+            ),
+            void 0,
+            [
+              ts.factory.createSpreadElement(ts.factory.createIdentifier("args"))
+            ]
+          )
+        )
+      ]
+    );
+    return ts.factory.createPropertyDeclaration(
+      [ts.factory.createModifier(ts.SyntaxKind.StaticKeyword)],
+      propertyName,
+      void 0,
+      type,
+      ts.factory.createArrowFunction(
+        void 0,
+        void 0,
+        [ts.factory.createParameterDeclaration(
+          void 0,
+          ts.factory.createToken(ts.SyntaxKind.DotDotDotToken),
+          "args",
+          void 0,
+          forceAny ? ts.factory.createArrayTypeNode(ts.factory.createTypeReferenceNode("any")) : void 0
+        )],
+        void 0,
+        void 0,
+        forceAny ? ts.factory.createAsExpression(arrowBody, ts.factory.createTypeReferenceNode("any")) : arrowBody
+      )
+    );
+  };
+  const generateReturnType = (type, atLocation2, className2) => pipe(
+    typeParser.effectType(type, atLocation2),
+    flatMap((returnedEffect) => {
+      const contextType = returnedEffect.R.flags & ts.TypeFlags.Never ? ts.factory.createTypeReferenceNode(className2.text) : ts.factory.createUnionTypeNode(
+        [
+          ts.factory.createTypeReferenceNode(className2.text),
+          typeChecker.typeToTypeNode(returnedEffect.R, atLocation2, ts.NodeBuilderFlags.NoTruncation)
+        ]
+      );
+      const successType = typeChecker.typeToTypeNode(
+        returnedEffect.A,
+        atLocation2,
+        ts.NodeBuilderFlags.NoTruncation
+      );
+      if (!successType) return fail("error generating success type");
+      const failureType = typeChecker.typeToTypeNode(
+        returnedEffect.E,
+        atLocation2,
+        ts.NodeBuilderFlags.NoTruncation
+      );
+      if (!failureType) return fail("error generating failure type");
+      const typeNode = ts.factory.createTypeReferenceNode(
+        ts.factory.createQualifiedName(
+          ts.factory.createIdentifier(effectIdentifier),
+          ts.factory.createIdentifier("Effect")
+        ),
+        [successType, failureType, contextType]
+      );
+      return succeed(typeNode);
+    }),
+    orElse2(
+      () => pipe(
+        typeParser.promiseLike(type, atLocation2),
+        flatMap(({ type: type2 }) => {
+          const successType = typeChecker.typeToTypeNode(
+            type2,
+            atLocation2,
+            ts.NodeBuilderFlags.NoTruncation
+          );
+          if (!successType) return fail("error generating success type");
+          return succeed(ts.factory.createTypeReferenceNode(
+            ts.factory.createQualifiedName(
+              ts.factory.createIdentifier(effectIdentifier),
+              ts.factory.createIdentifier("Effect")
+            ),
+            [
+              successType,
+              ts.factory.createTypeReferenceNode(
+                ts.factory.createQualifiedName(
+                  ts.factory.createIdentifier("Cause"),
+                  ts.factory.createIdentifier("UnknownException")
+                )
+              ),
+              ts.factory.createTypeReferenceNode(className2.text)
+            ]
+          ));
+        })
+      )
+    ),
+    orElse2(() => {
+      const successType = typeChecker.typeToTypeNode(type, atLocation2, ts.NodeBuilderFlags.NoTruncation);
+      if (!successType) return fail("error generating success type");
+      const typeNode = ts.factory.createTypeReferenceNode(
+        ts.factory.createQualifiedName(
+          ts.factory.createIdentifier(effectIdentifier),
+          ts.factory.createIdentifier("Effect")
+        ),
+        [
+          successType,
+          ts.factory.createTypeReferenceNode("never"),
+          ts.factory.createTypeReferenceNode(className2.text)
+        ]
+      );
+      return succeed(typeNode);
+    })
+  );
+  const proxySignature = (signature, atLocation2, className2) => gen(function* () {
+    const signatureDeclaration = typeChecker.signatureToSignatureDeclaration(
+      signature,
+      ts.SyntaxKind.FunctionType,
+      atLocation2,
+      ts.NodeBuilderFlags.NoTruncation
+    );
+    if (!signatureDeclaration) return yield* fail("error generating signature");
+    const returnType = yield* generateReturnType(signature.getReturnType(), atLocation2, className2);
+    return ts.factory.createFunctionTypeNode(
+      signatureDeclaration.typeParameters,
+      signatureDeclaration.parameters,
+      returnType
+    );
+  });
+  for (const { property, propertyType } of involvedMembers) {
+    const callSignatures = [];
+    let propertyDeclaration = void 0;
+    for (const signature of propertyType.getCallSignatures()) {
+      yield* pipe(
+        proxySignature(signature, atLocation, className),
+        map3((sig) => {
+          callSignatures.push(sig);
+        }),
+        ignore
+      );
+    }
+    const allSignatures = ts.factory.createIntersectionTypeNode(callSignatures);
+    const type = tsUtils.simplifyTypeNode(allSignatures);
+    propertyDeclaration = createFunctionProperty(className, property.getName(), type, callSignatures.length > 1);
+    const oldProperty = atLocation.members.filter(ts.isPropertyDeclaration).find((p) => {
+      const symbol3 = typeChecker.getSymbolAtLocation(p.name);
+      return symbol3?.getName() === property.getName();
+    });
+    if (oldProperty) {
+      changeTracker.deleteRange(sourceFile, {
+        pos: oldProperty.getStart(sourceFile),
+        end: oldProperty.getEnd()
+      });
+      changeTracker.insertNodeAt(sourceFile, oldProperty.getStart(sourceFile), propertyDeclaration);
+    } else {
+      changeTracker.insertNodeAt(sourceFile, insertLocation, propertyDeclaration, { suffix: "\n" });
+    }
+  }
+});
+var parse2 = fn("writeTagClassAccessors.parse")(function* (node) {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  const typeParser = yield* service(TypeParser);
+  if (!ts.isClassDeclaration(node)) return yield* fail("not a class declaration");
+  const { Service, accessors: accessors2, className } = yield* pipe(
+    typeParser.extendsEffectService(node),
+    orElse2(() => fail("not a class extending Effect.Service call"))
+  );
+  if (accessors2 !== true) return yield* fail("accessors are not enabled in the Effect.Service call");
+  const involvedMembers = [];
+  for (const property of typeChecker.getPropertiesOfType(Service)) {
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(property, node);
+    const callSignatures = propertyType.getCallSignatures();
+    if (callSignatures.length > 0) {
+      const withTypeParameters = callSignatures.filter((_) => _.typeParameters && _.typeParameters.length > 0);
+      if (callSignatures.length > 1 || withTypeParameters.length > 0) involvedMembers.push({ property, propertyType });
+    }
+  }
+  const hash2 = involvedMembers.map(({ property, propertyType }) => {
+    return property.getName() + ": " + typeChecker.typeToString(propertyType);
+  }).concat([className.text]).join("\n");
+  return { Service, className, atLocation: node, hash: cyrb53(hash2), involvedMembers };
+});
+var writeTagClassAccessors = createRefactor({
+  name: "writeTagClassAccessors",
+  description: "Implement accessors methods with generics or multiple signatures",
+  apply: fn("writeTagClassAccessors.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const parseNode = (node) => pipe(
+      parse2(node),
+      map3(({ Service, atLocation, className, involvedMembers }) => ({
+        kind: "refactor.rewrite.effect.writeTagClassAccessors",
+        description: "Implement Service accessors",
+        apply: pipe(
+          generate(sourceFile, Service, className, atLocation, involvedMembers),
+          provideService(TypeScriptUtils, tsUtils),
+          provideService(TypeParser, typeParser),
+          provideService(TypeCheckerApi, typeChecker),
+          provideService(TypeScriptApi, ts)
+        )
+      }))
+    );
+    const parentNodes = tsUtils.getAncestorNodesInRange(sourceFile, textRange);
+    return yield* pipe(
+      firstSuccessOf(parentNodes.map(parseNode)),
+      orElse2(() => fail(new RefactorNotApplicableError()))
+    );
+  })
+});
+
+// src/codegens/accessors.ts
+var accessors = createCodegen({
+  name: "accessors",
+  apply: fn("accessors.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const nodeAndCommentRange = tsUtils.findNodeWithLeadingCommentAtPosition(sourceFile, textRange.pos);
+    if (!nodeAndCommentRange) return yield* fail(new CodegenNotApplicableError("no node and comment range"));
+    return yield* pipe(
+      parse2(nodeAndCommentRange.node),
+      map3(
+        (_) => ({
+          hash: _.hash,
+          description: "Generate accessors for the service",
+          apply: pipe(
+            generate(sourceFile, _.Service, _.className, _.atLocation, _.involvedMembers),
+            provideService(TypeScriptApi, ts),
+            provideService(TypeScriptUtils, tsUtils),
+            provideService(TypeCheckerApi, typeChecker),
+            provideService(TypeParser, typeParser)
+          )
+        })
+      ),
+      orElse2((cause) => fail(new CodegenNotApplicableError(cause)))
+    );
+  })
+});
+
+// src/codegens.ts
+var codegens = [accessors];
+
+// src/completions/effectCodegensComment.ts
+var effectCodegensComment = createCompletion({
+  name: "effectCodegensComment",
+  apply: fn("effectCodegensComment")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const sourceText = sourceFile.text;
+    const match2 = /(\/\/|\/\*(?:\*?))\s*(@)\s*$/id.exec(sourceText.substring(0, position));
+    if (match2 && match2.indices) {
+      const lastIndex = match2.indices[2][0];
+      const replacementSpan = {
+        start: lastIndex,
+        length: Math.max(0, position - lastIndex)
+      };
+      const allCodegens = sort(Object.values(codegens).map((codegen) => codegen.name), string2).join(",");
+      const enableSnippet = "${1|" + allCodegens + "|} $0";
+      return [{
+        name: `@effect-codegens`,
+        kind: ts.ScriptElementKind.string,
+        insertText: "@effect-codegens " + enableSnippet,
+        isSnippet: true,
+        replacementSpan
+      }];
+    }
+    return [];
+  })
+});
+
+// src/completions/effectDataClasses.ts
+var effectDataClasses = createCompletion({
+  name: "effectDataClasses",
+  apply: fn("effectDataClasses")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const maybeInfos = tsUtils.parseDataForExtendsClassCompletion(sourceFile, position);
+    if (!maybeInfos) return [];
+    const { accessedObject, className, replacementSpan } = maybeInfos;
+    const effectDataIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Data"
+    ) || "Data";
+    if (effectDataIdentifier !== accessedObject.text) return [];
+    const name = className.text;
+    return [{
+      name: `TaggedError("${name}")`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `${effectDataIdentifier}.TaggedError("${name}")<{${"${0}"}}>{}`,
+      replacementSpan,
+      isSnippet: true
+    }, {
+      name: `TaggedClass("${name}")`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `${effectDataIdentifier}.TaggedClass("${name}")<{${"${0}"}}>{}`,
+      replacementSpan,
+      isSnippet: true
+    }];
+  })
+});
+
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/encoding/common.js
+var encoder = /* @__PURE__ */ new TextEncoder();
+
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/encoding/base64.js
+var encode = (bytes) => {
+  const length = bytes.length;
+  let result = "";
+  let i;
+  for (i = 2; i < length; i += 3) {
+    result += base64abc[bytes[i - 2] >> 2];
+    result += base64abc[(bytes[i - 2] & 3) << 4 | bytes[i - 1] >> 4];
+    result += base64abc[(bytes[i - 1] & 15) << 2 | bytes[i] >> 6];
+    result += base64abc[bytes[i] & 63];
+  }
+  if (i === length + 1) {
+    result += base64abc[bytes[i - 2] >> 2];
+    result += base64abc[(bytes[i - 2] & 3) << 4];
+    result += "==";
+  }
+  if (i === length) {
+    result += base64abc[bytes[i - 2] >> 2];
+    result += base64abc[(bytes[i - 2] & 3) << 4 | bytes[i - 1] >> 4];
+    result += base64abc[(bytes[i - 1] & 15) << 2];
+    result += "=";
+  }
+  return result;
+};
+var base64abc = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "+", "/"];
+
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/encoding/base64Url.js
+var encode2 = (data) => encode(data).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Encoding.js
+var encodeBase64Url = (input) => typeof input === "string" ? encode2(encoder.encode(input)) : encode2(input);
+
+// src/diagnostics/classSelfMismatch.ts
+var classSelfMismatch = createDiagnostic({
+  name: "classSelfMismatch",
+  code: 20,
+  severity: "error",
+  apply: fn("classSelfMismatch.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
+        const result = yield* pipe(
+          typeParser.extendsEffectService(node),
+          orElse2(() => typeParser.extendsContextTag(node)),
+          orElse2(() => typeParser.extendsSchemaClass(node)),
+          orElse2(() => typeParser.extendsSchemaTaggedClass(node)),
+          orElse2(() => typeParser.extendsSchemaTaggedError(node)),
+          orElse2(() => typeParser.extendsSchemaTaggedRequest(node)),
+          orElse2(() => void_)
+        );
+        if (result) {
+          const { className, selfTypeNode } = result;
+          let actualName = "";
+          if (ts.isTypeReferenceNode(selfTypeNode)) {
+            if (ts.isIdentifier(selfTypeNode.typeName)) {
+              actualName = selfTypeNode.typeName.text;
+            } else if (ts.isQualifiedName(selfTypeNode.typeName)) {
+              actualName = selfTypeNode.typeName.right.text;
+            }
+          }
+          const expectedName = className.text;
+          if (actualName !== expectedName) {
+            report({
+              location: selfTypeNode,
+              messageText: `Self type parameter should be '${expectedName}'`,
+              fixes: [{
+                fixName: "classSelfMismatch_fix",
+                description: `Replace '${actualName}' with '${expectedName}'`,
+                apply: gen(function* () {
+                  const changeTracker = yield* service(ChangeTracker);
+                  const typeArgs = ts.isTypeReferenceNode(selfTypeNode) ? selfTypeNode.typeArguments : void 0;
+                  const newTypeReference = ts.factory.createTypeReferenceNode(
+                    ts.factory.createIdentifier(expectedName),
+                    typeArgs
+                  );
+                  changeTracker.replaceNode(sourceFile, selfTypeNode, newTypeReference);
+                })
+              }]
+            });
           }
-          return succeed({
-            type: callbackParameterType
-          });
         }
       }
-      return typeParserIssue("not a promise", type, atLocation);
-    },
-    "TypeParser.promiseLike",
-    (type) => type
-  );
-  return {
-    effectType,
-    strictEffectType,
-    layerType,
-    fiberType,
-    effectSubtype,
-    importedEffectModule,
-    effectGen,
-    effectFnUntracedGen,
-    effectFnGen,
-    unnecessaryEffectGen: unnecessaryEffectGen2,
-    effectSchemaType,
-    contextTag,
-    pipeableType,
-    pipeCall,
-    scopeType,
-    promiseLike
-  };
-}
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
+// src/diagnostics/duplicatePackage.ts
+var checkedPackagesCache = /* @__PURE__ */ new Map();
+var programResolvedCacheSize = /* @__PURE__ */ new Map();
+var duplicatePackage = createDiagnostic({
+  name: "duplicatePackage",
+  code: 6,
+  severity: "warning",
+  apply: fn("duplicatePackage.apply")(function* (sourceFile, report) {
+    const program = yield* service(TypeScriptProgram);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const options = yield* service(LanguageServicePluginOptions);
+    if (sourceFile.statements.length < 1) return;
+    let resolvedPackages = checkedPackagesCache.get(sourceFile.fileName) || {};
+    const newResolvedModuleSize = hasProperty(program, "resolvedModules") && hasProperty(program.resolvedModules, "size") && isNumber(program.resolvedModules.size) ? program.resolvedModules.size : 0;
+    const oldResolvedSize = programResolvedCacheSize.get(sourceFile.fileName) || -1;
+    if (newResolvedModuleSize !== oldResolvedSize) {
+      const seenPackages = /* @__PURE__ */ new Set();
+      resolvedPackages = {};
+      program.getSourceFiles().map((_) => {
+        const packageInfo = tsUtils.parsePackageContentNameAndVersionFromScope(_);
+        if (!packageInfo) return;
+        const packageNameAndVersion = packageInfo.name + "@" + packageInfo.version;
+        if (seenPackages.has(packageNameAndVersion)) return;
+        seenPackages.add(packageNameAndVersion);
+        if (!(packageInfo.name === "effect" || packageInfo.hasEffectInPeerDependencies)) return;
+        if (options.allowedDuplicatedPackages.indexOf(packageInfo.name) > -1) return;
+        resolvedPackages[packageInfo.name] = resolvedPackages[packageInfo.name] || {};
+        resolvedPackages[packageInfo.name][packageInfo.version] = packageInfo.packageDirectory;
+      });
+      checkedPackagesCache.set(sourceFile.fileName, resolvedPackages);
+      programResolvedCacheSize.set(sourceFile.fileName, newResolvedModuleSize);
+    }
+    for (const packageName of Object.keys(resolvedPackages)) {
+      if (Object.keys(resolvedPackages[packageName]).length > 1) {
+        const versions = Object.keys(resolvedPackages[packageName]);
+        report({
+          location: sourceFile.statements[0],
+          messageText: `Package ${packageName} is referenced multiple times with different versions (${versions.join(", ")}) and may cause unexpected type errors.
+Cleanup your dependencies and your package lockfile to avoid multiple instances of this package and reload the project.
+If this is intended set the LSP config "allowedDuplicatedPackages" to ${JSON.stringify(options.allowedDuplicatedPackages.concat([packageName]))}.
+
+${versions.map((version) => `- found ${version} at ${resolvedPackages[packageName][version]}`).join("\n")}`,
+          fixes: []
+        });
+      }
+    }
+  })
+});
 
 // src/diagnostics/effectInVoidSuccess.ts
 var effectInVoidSuccess = createDiagnostic({
@@ -2794,7 +3526,7 @@ var effectInVoidSuccess = createDiagnostic({
       if (expectedEffect.A.flags & ts.TypeFlags.Void) {
         const voidValueTypes = unrollUnionMembers(realEffect.A);
         const voidedEffect = yield* firstSuccessOf(
-          voidValueTypes.map((_) => map4(typeParser.strictEffectType(_, node), () => _))
+          voidValueTypes.map((_) => map3(typeParser.strictEffectType(_, node), () => _))
         );
         return { voidedEffect };
       }
@@ -2810,10 +3542,10 @@ var effectInVoidSuccess = createDiagnostic({
             valueNode,
             realType
           ),
-          map4(({ voidedEffect }) => {
+          map3(({ voidedEffect }) => {
             report(
               {
-                node,
+                location: node,
                 messageText: `There is a nested '${typeChecker.typeToString(voidedEffect)}' in the 'void' success channel, beware that this could lead to nested Effect<Effect<...>> that won't be executed.`,
                 fixes: []
               }
@@ -2862,7 +3594,7 @@ var floatingEffect = createDiagnostic({
         );
         if (isNone2(allowedFloatingEffects)) {
           report({
-            node,
+            location: node,
             messageText: `Effect must be yielded or assigned to a variable.`,
             fixes: []
           });
@@ -2903,9 +3635,9 @@ var genericEffectServices = createDiagnostic({
       for (const [type, reportAt] of typesToCheck) {
         yield* pipe(
           typeParser.contextTag(type, node),
-          map4(() => {
+          map3(() => {
             report({
-              node: reportAt,
+              location: reportAt,
               messageText: `Effect Services with type parameters are not supported because they cannot be properly discriminated at runtime, which may cause unexpected behavior.`,
               fixes: []
             });
@@ -2927,17 +3659,16 @@ var importFromBarrel = createDiagnostic({
     const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
     if (languageServicePluginOptions.namespaceImportPackages.length === 0) return;
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const program = yield* service(TypeScriptProgram);
     const packageNamesToCheck = flatten(
-      yield* all(
-        ...languageServicePluginOptions.namespaceImportPackages.map(
-          (packageName) => resolveModulePattern(sourceFile, packageName)
-        )
+      languageServicePluginOptions.namespaceImportPackages.map(
+        (packageName) => tsUtils.resolveModulePattern(sourceFile, packageName)
       )
     );
     const isImportedFromBarrelExport = (element) => {
-      const getModuleSpecifier = makeGetModuleSpecifier(ts);
+      const getModuleSpecifier = tsUtils.makeGetModuleSpecifier();
       const resolveExternalModuleName = makeResolveExternalModuleName(typeChecker);
       if (!(getModuleSpecifier && resolveExternalModuleName)) return;
       const importDeclaration = ts.findAncestor(element, (node) => ts.isImportDeclaration(node));
@@ -3013,7 +3744,7 @@ var importFromBarrel = createDiagnostic({
         unbarrelledFileName
       } = result;
       report({
-        node,
+        location: node,
         messageText: `Importing from barrel module ${barrelModuleName} is not allowed.`,
         fixes: [
           {
@@ -3078,13 +3809,13 @@ var leakingRequirements = createDiagnostic({
             let effectContextType = void 0;
             yield* pipe(
               typeParser.effectType(servicePropertyType, atLocation),
-              map4((_) => effectContextType = _.R),
+              map3((_) => effectContextType = _.R),
               orElse2(() => {
                 const servicePropertyCallSignatures = servicePropertyType.getCallSignatures();
                 if (servicePropertyCallSignatures.length === 1) {
                   return pipe(
                     typeParser.effectType(servicePropertyCallSignatures[0].getReturnType(), atLocation),
-                    map4((_) => {
+                    map3((_) => {
                       effectContextType = _.R;
                     })
                   );
@@ -3102,7 +3833,7 @@ var leakingRequirements = createDiagnostic({
                   if (type.flags & ts.TypeFlags.Never) return succeed(true);
                   return pipe(
                     typeParser.scopeType(type, atLocation),
-                    map4(() => true),
+                    map3(() => true),
                     orElse2(() => succeed(false))
                   );
                 }
@@ -3127,7 +3858,7 @@ var leakingRequirements = createDiagnostic({
     function reportLeakingRequirements(node, requirements) {
       if (requirements.length === 0) return;
       report({
-        node,
+        location: node,
         messageText: `This Service is leaking the ${requirements.map((_) => typeChecker.typeToString(_)).join(" | ")} requirement.
 If these requirements cannot be cached and are expected to be provided per method invocation (e.g. HttpServerRequest), you can safely disable this diagnostic for this line through quickfixes.
 More info at https://effect.website/docs/requirements-management/layers/#avoiding-requirement-leakage`,
@@ -3158,10 +3889,10 @@ More info at https://effect.website/docs/requirements-management/layers/#avoidin
       for (const [type, reportAt] of typesToCheck) {
         yield* pipe(
           typeParser.contextTag(type, node),
-          flatMap2(
+          flatMap(
             ({ Service }) => pipe(
               parseLeakedRequirements(Service, node),
-              map4((requirements) => reportLeakingRequirements(reportAt, sort(requirements, typeOrder)))
+              map3((requirements) => reportLeakingRequirements(reportAt, sort(requirements, typeOrder)))
             )
           ),
           orElse2(() => sync(() => ts.forEachChild(node, appendNodeToVisit))),
@@ -3186,7 +3917,7 @@ var missingEffectContext = createDiagnostic({
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
-      flatMap2(
+      flatMap(
         ([expectedEffect, realEffect]) => getMissingTypeEntriesInTargetType(
           realEffect.R,
           expectedEffect.R
@@ -3204,10 +3935,10 @@ var missingEffectContext = createDiagnostic({
             valueNode,
             realType
           ),
-          map4(
+          map3(
             (missingTypes) => missingTypes.length > 0 ? report(
               {
-                node,
+                location: node,
                 messageText: `Missing '${sortTypes(missingTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect context.`,
                 fixes: []
               }
@@ -3227,18 +3958,15 @@ var missingEffectError = createDiagnostic({
   severity: "error",
   apply: fn("missingEffectError.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
-    const effectModuleIdentifier = yield* pipe(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Effect"
-      ),
-      map4((_) => _.text),
-      orElse2(() => succeed("Effect"))
-    );
+    const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Effect"
+    ) || "Effect";
     const createDieMessage = (message) => ts.factory.createCallExpression(
       ts.factory.createPropertyAccessExpression(
         ts.factory.createIdentifier(effectModuleIdentifier),
@@ -3252,13 +3980,13 @@ var missingEffectError = createDiagnostic({
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
-      flatMap2(
+      flatMap(
         ([expectedEffect, realEffect]) => pipe(
           getMissingTypeEntriesInTargetType(
             realEffect.E,
             expectedEffect.E
           ),
-          map4((missingErrorTypes) => ({ missingErrorTypes, expectedErrorType: expectedEffect.E }))
+          map3((missingErrorTypes) => ({ missingErrorTypes, expectedErrorType: expectedEffect.E }))
         )
       )
     );
@@ -3273,7 +4001,7 @@ var missingEffectError = createDiagnostic({
             valueNode,
             realType
           ),
-          map4((result) => {
+          map3((result) => {
             if (result.missingErrorTypes.length === 0) return;
             const fixes = [];
             if (ts.isExpression(valueNode) && result.expectedErrorType.flags & ts.TypeFlags.Never) {
@@ -3296,17 +4024,17 @@ var missingEffectError = createDiagnostic({
             if (ts.isExpression(valueNode)) {
               const propertyAssignments = pipe(
                 result.missingErrorTypes,
-                map3((_) => typeChecker.getPropertyOfType(_, "_tag")),
+                map4((_) => typeChecker.getPropertyOfType(_, "_tag")),
                 filter((_) => !!_),
-                map3((_) => typeChecker.getTypeOfSymbolAtLocation(_, valueNode)),
+                map4((_) => typeChecker.getTypeOfSymbolAtLocation(_, valueNode)),
                 filter((_) => !!(_.flags & ts.TypeFlags.Literal)),
-                map3((_) => typeChecker.typeToTypeNode(_, void 0, ts.NodeBuilderFlags.NoTruncation)),
+                map4((_) => typeChecker.typeToTypeNode(_, void 0, ts.NodeBuilderFlags.NoTruncation)),
                 filter((_) => !!_ && ts.isLiteralTypeNode(_)),
-                map3((_) => _.literal),
+                map4((_) => _.literal),
                 filter((_) => ts.isLiteralExpression(_)),
-                map3((_) => _.text),
+                map4((_) => _.text),
                 sort(string2),
-                map3(
+                map4(
                   (_) => ts.factory.createPropertyAssignment(
                     ts.factory.createIdentifier(_),
                     ts.factory.createArrowFunction(
@@ -3340,7 +4068,7 @@ var missingEffectError = createDiagnostic({
             }
             report(
               {
-                node,
+                location: node,
                 messageText: `Missing '${sortTypes(result.missingErrorTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`,
                 fixes
               }
@@ -3404,7 +4132,7 @@ var missingReturnYieldStar = createDiagnostic({
                   })
                 }] : [];
                 report({
-                  node,
+                  location: node,
                   messageText: `Yielded Effect never succeeds, so it is best to use a 'return yield*' instead.`,
                   fixes: fix
                 });
@@ -3447,7 +4175,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
             typeParser.effectGen(effectGenNode),
             orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
             orElse2(() => typeParser.effectFnGen(effectGenNode)),
-            map4(({ functionStar }) => {
+            map3(({ functionStar }) => {
               if (functionStar) {
                 brokenGenerators.add(functionStar);
               }
@@ -3460,7 +4188,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
     }
     brokenGenerators.forEach(
       (node) => report({
-        node,
+        location: node,
         messageText: `Seems like you used yield instead of yield* inside this Effect.gen.`,
         fixes: []
       })
@@ -3482,7 +4210,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
         })
       }] : [];
       report({
-        node,
+        location: node,
         messageText: `When yielding Effects inside Effect.gen, you should use yield* instead of yield.`,
         fixes: fix
       });
@@ -3497,34 +4225,27 @@ var multipleEffectProvide = createDiagnostic({
   severity: "warning",
   apply: fn("multipleEffectProvide.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
-    const effectModuleIdentifier = yield* pipe(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Effect"
-      ),
-      map4((_) => _.text),
-      orElse2(() => succeed("Effect"))
-    );
-    const layerModuleIdentifier = yield* pipe(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Layer"
-      ),
-      map4((_) => _.text),
-      orElse2(() => succeed("Layer"))
-    );
+    const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Effect"
+    ) || "Effect";
+    const layerModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Layer"
+    ) || "Layer";
     const parseEffectProvideLayer = (node) => {
       if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && node.expression.name.text === "provide" && node.arguments.length > 0) {
         const layer = node.arguments[0];
         const type = typeChecker.getTypeAtLocation(layer);
         return pipe(
           typeParser.importedEffectModule(node.expression.expression),
-          flatMap2(() => typeParser.layerType(type, layer)),
-          map4(() => ({ layer, node })),
+          flatMap(() => typeParser.layerType(type, layer)),
+          map3(() => ({ layer, node })),
           orElse2(() => void_)
         );
       }
@@ -3546,7 +4267,7 @@ var multipleEffectProvide = createDiagnostic({
       for (const chunk of previousLayers) {
         if (chunk.length < 2) continue;
         report({
-          node: chunk[0].node,
+          location: chunk[0].node,
           messageText: "Avoid chaining Effect.provide calls, as this can lead to service lifecycle issues. Instead, merge layers and provide them in a single call.",
           fixes: [{
             fixName: "multipleEffectProvide_fix",
@@ -3594,6 +4315,51 @@ var multipleEffectProvide = createDiagnostic({
   })
 });
 
+// src/diagnostics/outdatedEffectCodegen.ts
+var outdatedEffectCodegen = createDiagnostic({
+  name: "outdatedEffectCodegen",
+  code: 19,
+  severity: "warning",
+  apply: fn("outdatedEffectCodegen.apply")(function* (sourceFile, _report) {
+    const codegensWithRanges = yield* getCodegensForSourceFile(codegens, sourceFile);
+    for (const { codegen, hash: hash2, range } of codegensWithRanges) {
+      yield* pipe(
+        getEditsForCodegen([codegen], sourceFile, range),
+        map3((applicable) => {
+          if (applicable.hash !== hash2) {
+            _report({
+              location: range,
+              messageText: `Codegen ${codegen.name} result is outdated`,
+              fixes: [
+                {
+                  fixName: "outdatedEffectCodegen_fix",
+                  description: `Re-run ${codegen.name}`,
+                  apply: applicable.apply
+                },
+                {
+                  fixName: "outdatedEffectCodegen_ignore",
+                  description: `Ignore this ${codegen.name} update`,
+                  apply: applicable.ignore
+                }
+              ]
+            });
+          }
+        }),
+        orElse2(
+          (e) => sync(() => {
+            _report({
+              location: range,
+              messageText: `Codegen ${codegen.name} is not applicable here: ${e.cause}`,
+              fixes: []
+            });
+          })
+        ),
+        ignore
+      );
+    }
+  })
+});
+
 // src/diagnostics/returnEffectInGen.ts
 var returnEffectInGen = createDiagnostic({
   name: "returnEffectInGen",
@@ -3628,7 +4394,7 @@ var returnEffectInGen = createDiagnostic({
               typeParser.effectGen(effectGenNode),
               orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
               orElse2(() => typeParser.effectFnGen(effectGenNode)),
-              map4(() => {
+              map3(() => {
                 const fix = node.expression ? [{
                   fixName: "returnEffectInGen_fix",
                   description: "Add yield* statement",
@@ -3645,7 +4411,7 @@ var returnEffectInGen = createDiagnostic({
                   })
                 }] : [];
                 report({
-                  node,
+                  location: node,
                   messageText: `You are returning an Effect-able type inside a generator function, and will result in nested Effect<Effect<...>>.
 Maybe you wanted to return yield* instead?
 Nested Effect-able types may be intended if you plan to later manually flatten or unwrap this Effect, if so you can safely disable this diagnostic for this line through quickfixes.`,
@@ -3668,17 +4434,14 @@ var scopeInLayerEffect = createDiagnostic({
   severity: "warning",
   apply: fn("scopeInLayerEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
-    const layerModuleIdentifier = yield* pipe(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Layer"
-      ),
-      map4((_) => _.text),
-      orElse2(() => succeed("Layer"))
-    );
+    const layerModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Layer"
+    ) || "Layer";
     function parseLayerEffectApiCall(node) {
       if (!ts.isCallExpression(node)) return;
       const expression = node.expression;
@@ -3702,9 +4465,9 @@ var scopeInLayerEffect = createDiagnostic({
       }
       return pipe(
         firstSuccessOf(entries.map((type2) => typeParser.scopeType(type2, node))),
-        map4(
+        map3(
           () => report({
-            node,
+            location: node,
             messageText: `Seems like you are constructing a layer with a scope in the requirements.
 Consider using "scoped" instead to get rid of the scope in the requirements.`,
             fixes: methodIdentifier ? [{
@@ -3737,7 +4500,7 @@ Consider using "scoped" instead to get rid of the scope in the requirements.`,
         const type = typeChecker.getTypeAtLocation(node);
         yield* pipe(
           typeParser.layerType(type, node),
-          flatMap2(({ RIn }) => reportIfLayerRequireScope(RIn, node, layerEffectApiCall.methodIdentifier)),
+          flatMap(({ RIn }) => reportIfLayerRequireScope(RIn, node, layerEffectApiCall.methodIdentifier)),
           ignore
         );
         continue;
@@ -3751,7 +4514,7 @@ Consider using "scoped" instead to get rid of the scope in the requirements.`,
             const type = typeChecker.getTypeOfSymbolAtLocation(defaultLayer, node);
             yield* pipe(
               typeParser.layerType(type, node),
-              flatMap2(({ RIn }) => reportIfLayerRequireScope(RIn, node, void 0)),
+              flatMap(({ RIn }) => reportIfLayerRequireScope(RIn, node, void 0)),
               ignore
             );
             continue;
@@ -3820,7 +4583,7 @@ var strictBooleanExpressions = createDiagnostic({
           if (type.flags & ts.TypeFlags.BooleanLiteral) continue;
           const typeName = typeChecker.typeToString(type);
           report({
-            node: nodeToCheck,
+            location: nodeToCheck,
             messageText: `Unexpected \`${typeName}\` type in condition, expected strictly a boolean instead.`,
             fixes: []
           });
@@ -3860,9 +4623,9 @@ var tryCatchInEffectGen = createDiagnostic({
             typeParser.effectGen(effectGenNode),
             orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
             orElse2(() => typeParser.effectFnGen(effectGenNode)),
-            map4(() => {
+            map3(() => {
               report({
-                node,
+                location: node,
                 messageText: "Avoid using try/catch inside Effect generators. Use Effect's error handling mechanisms instead (e.g., Effect.try, Effect.tryPromise, Effect.catchAll, Effect.catchTag).",
                 fixes: []
               });
@@ -3895,9 +4658,9 @@ var unnecessaryEffectGen = createDiagnostic({
       if (ts.isCallExpression(node)) {
         yield* pipe(
           typeParser.unnecessaryEffectGen(node),
-          map4(
+          map3(
             ({ replacementNode }) => report({
-              node,
+              location: node,
               messageText: `This Effect.gen contains a single return statement.`,
               fixes: [{
                 fixName: "unnecessaryEffectGen_fix",
@@ -3938,10 +4701,10 @@ var unnecessaryPipe = createDiagnostic({
       if (ts.isCallExpression(node)) {
         yield* pipe(
           typeParser.pipeCall(node),
-          map4(({ args: args2, subject }) => {
+          map3(({ args: args2, subject }) => {
             if (args2.length === 0) {
               report({
-                node,
+                location: node,
                 messageText: `This pipe call contains no arguments.`,
                 fixes: [{
                   fixName: "unnecessaryPipe_fix",
@@ -3983,12 +4746,12 @@ var unnecessaryPipeChain = createDiagnostic({
       if (ts.isCallExpression(node)) {
         yield* pipe(
           typeParser.pipeCall(node),
-          flatMap2(
-            (pipeCall) => map4(typeParser.pipeCall(pipeCall.subject), (innerCall) => ({ pipeCall, innerCall }))
+          flatMap(
+            (pipeCall) => map3(typeParser.pipeCall(pipeCall.subject), (innerCall) => ({ pipeCall, innerCall }))
           ),
-          map4(({ innerCall, pipeCall }) => {
+          map3(({ innerCall, pipeCall }) => {
             report({
-              node,
+              location: node,
               messageText: `Chained pipe calls can be simplified to a single pipe call`,
               fixes: [{
                 fixName: "unnecessaryPipeChain_fix",
@@ -4029,9 +4792,64 @@ var unnecessaryPipeChain = createDiagnostic({
                 })
               }]
             });
-          }),
-          ignore
-        );
+          }),
+          ignore
+        );
+      }
+    }
+  })
+});
+
+// src/diagnostics/unsupportedServiceAccessors.ts
+var unsupportedServiceAccessors = createDiagnostic({
+  name: "unsupportedServiceAccessors",
+  code: 21,
+  severity: "warning",
+  apply: fn("unsupportedServiceAccessors.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (ts.isClassDeclaration(node)) {
+        const parseResult = yield* pipe(
+          parse2(node),
+          orElse2(() => succeed(null))
+        );
+        if (parseResult && parseResult.involvedMembers.length > 0) {
+          const existingStaticMembers = /* @__PURE__ */ new Set();
+          node.members?.forEach((member) => {
+            if (ts.isPropertyDeclaration(member) && member.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.StaticKeyword)) {
+              if (member.name && ts.isIdentifier(member.name)) {
+                existingStaticMembers.add(member.name.text);
+              }
+            }
+          });
+          const missingMembers = parseResult.involvedMembers.filter(
+            ({ property }) => !existingStaticMembers.has(property.getName())
+          );
+          if (missingMembers.length > 0) {
+            const memberNames = missingMembers.map(({ property }) => `'${property.getName()}'`).join(", ");
+            report({
+              location: parseResult.className,
+              messageText: `Even if accessors are enabled, accessors for ${memberNames} won't be available because the signature have generic type parameters or multiple call signatures.`,
+              fixes: [{
+                fixName: "unsupportedServiceAccessors_enableCodegen",
+                description: "Enable accessors codegen",
+                apply: gen(function* () {
+                  const changeTracker = yield* service(ChangeTracker);
+                  const comment = "// @effect-codegens accessors\n";
+                  changeTracker.insertText(sourceFile, node.getStart(sourceFile), comment);
+                })
+              }]
+            });
+          }
+        }
       }
     }
   })
@@ -4039,6 +4857,7 @@ var unnecessaryPipeChain = createDiagnostic({
 
 // src/diagnostics.ts
 var diagnostics = [
+  classSelfMismatch,
   duplicatePackage,
   missingEffectContext,
   missingEffectError,
@@ -4056,7 +4875,9 @@ var diagnostics = [
   effectInVoidSuccess,
   unnecessaryPipeChain,
   strictBooleanExpressions,
-  multipleEffectProvide
+  multipleEffectProvide,
+  outdatedEffectCodegen,
+  unsupportedServiceAccessors
 ];
 
 // src/completions/effectDiagnosticsComment.ts
@@ -4065,9 +4886,9 @@ var effectDiagnosticsComment = createCompletion({
   apply: fn("effectDiagnosticsComment")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
     const sourceText = sourceFile.text;
-    const match3 = /(\/\/|\/\*(?:\*?))\s*(@)\s*$/id.exec(sourceText.substring(0, position));
-    if (match3 && match3.indices) {
-      const lastIndex = match3.indices[2][0];
+    const match2 = /(\/\/|\/\*(?:\*?))\s*(@)\s*$/id.exec(sourceText.substring(0, position));
+    if (match2 && match2.indices) {
+      const lastIndex = match2.indices[2][0];
       const replacementSpan = {
         start: lastIndex,
         length: Math.max(0, position - lastIndex)
@@ -4097,22 +4918,15 @@ var effectSchemaSelfInClasses = createCompletion({
   name: "effectSchemaSelfInClasses",
   apply: fn("effectSchemaSelfInClasses")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
-    const maybeInfos = yield* option(
-      parseDataForExtendsClassCompletion(sourceFile, position)
-    );
-    if (isNone2(maybeInfos)) return [];
-    const { accessedObject, className, replacementSpan } = maybeInfos.value;
-    const effectSchemaName = yield* option(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Schema"
-      )
-    );
-    const schemaIdentifier = match(effectSchemaName, {
-      onNone: () => "Schema",
-      onSome: (_) => _.text
-    });
+    const tsUtils = yield* service(TypeScriptUtils);
+    const maybeInfos = tsUtils.parseDataForExtendsClassCompletion(sourceFile, position);
+    if (!maybeInfos) return [];
+    const { accessedObject, className, replacementSpan } = maybeInfos;
+    const schemaIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Schema"
+    ) || "Schema";
     if (schemaIdentifier !== accessedObject.text) return [];
     const name = className.text;
     return [{
@@ -4148,22 +4962,15 @@ var effectSelfInClasses = createCompletion({
   name: "effectSelfInClasses",
   apply: fn("effectSelfInClasses")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
-    const maybeInfos = yield* option(
-      parseDataForExtendsClassCompletion(sourceFile, position)
-    );
-    if (isNone2(maybeInfos)) return [];
-    const { accessedObject, className, replacementSpan } = maybeInfos.value;
-    const effectName = yield* option(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Effect"
-      )
-    );
-    const effectIdentifier = match(effectName, {
-      onNone: () => "Effect",
-      onSome: (_) => _.text
-    });
+    const tsUtils = yield* service(TypeScriptUtils);
+    const maybeInfos = tsUtils.parseDataForExtendsClassCompletion(sourceFile, position);
+    if (!maybeInfos) return [];
+    const { accessedObject, className, replacementSpan } = maybeInfos;
+    const effectIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Effect"
+    ) || "Effect";
     if (effectIdentifier !== accessedObject.text) return [];
     const name = className.text;
     return [{
@@ -4181,12 +4988,11 @@ var fnFunctionStar = createCompletion({
   name: "fnFunctionStar",
   apply: fn("fnFunctionStar")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeParser = yield* service(TypeParser);
-    const maybeInfos = yield* option(
-      parseAccessedExpressionForCompletion(sourceFile, position)
-    );
-    if (isNone2(maybeInfos)) return [];
-    const { accessedObject } = maybeInfos.value;
+    const maybeInfos = tsUtils.parseAccessedExpressionForCompletion(sourceFile, position);
+    if (!maybeInfos) return [];
+    const { accessedObject } = maybeInfos;
     const isEffectModule = yield* option(typeParser.importedEffectModule(accessedObject));
     if (isNone2(isEffectModule)) return [];
     const span = ts.createTextSpan(
@@ -4194,9 +5000,9 @@ var fnFunctionStar = createCompletion({
       Math.max(0, position - accessedObject.end - 1)
     );
     const maybeFnName = pipe(
-      yield* getAncestorNodesInRange(sourceFile, toTextRange(accessedObject.pos)),
+      tsUtils.getAncestorNodesInRange(sourceFile, tsUtils.toTextRange(accessedObject.pos)),
       filter(ts.isVariableDeclaration),
-      map3((_) => _.name && ts.isIdentifier(_.name) ? _.name.text : ""),
+      map4((_) => _.name && ts.isIdentifier(_.name) ? _.name.text : ""),
       filter((_) => _.length > 0),
       head,
       map2((name) => [
@@ -4231,12 +5037,11 @@ var genFunctionStar = createCompletion({
   name: "genFunctionStar",
   apply: fn("genFunctionStar")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
-    const maybeInfos = yield* option(
-      parseAccessedExpressionForCompletion(sourceFile, position)
-    );
-    if (isNone2(maybeInfos)) return [];
-    const { accessedObject } = maybeInfos.value;
+    const maybeInfos = tsUtils.parseAccessedExpressionForCompletion(sourceFile, position);
+    if (!maybeInfos) return [];
+    const { accessedObject } = maybeInfos;
     const type = typeChecker.getTypeAtLocation(accessedObject);
     const genMemberSymbol = type.getProperty("gen");
     if (!genMemberSymbol) return [];
@@ -4261,22 +5066,15 @@ var rpcMakeClasses = createCompletion({
   name: "rpcMakeClasses",
   apply: fn("rpcMakeClasses")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
-    const maybeInfos = yield* option(
-      parseDataForExtendsClassCompletion(sourceFile, position)
-    );
-    if (isNone2(maybeInfos)) return [];
-    const { accessedObject, className, replacementSpan } = maybeInfos.value;
-    const rpcName = yield* option(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "@effect/rpc",
-        "Rpc"
-      )
-    );
-    const rpcIdentifier = match(rpcName, {
-      onNone: () => "Rpc",
-      onSome: (_) => _.text
-    });
+    const tsUtils = yield* service(TypeScriptUtils);
+    const maybeInfos = tsUtils.parseDataForExtendsClassCompletion(sourceFile, position);
+    if (!maybeInfos) return [];
+    const { accessedObject, className, replacementSpan } = maybeInfos;
+    const rpcIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "@effect/rpc",
+      "Rpc"
+    ) || "Rpc";
     if (rpcIdentifier !== accessedObject.text) return [];
     const name = className.text;
     return [{
@@ -4294,34 +5092,25 @@ var schemaBrand = createCompletion({
   name: "schemaBrand",
   apply: fn("schemaBrand")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
-    const maybeInfos = yield* option(
-      parseAccessedExpressionForCompletion(sourceFile, position)
-    );
-    if (isNone2(maybeInfos)) return [];
-    const { accessedObject } = maybeInfos.value;
+    const tsUtils = yield* service(TypeScriptUtils);
+    const maybeInfos = tsUtils.parseAccessedExpressionForCompletion(sourceFile, position);
+    if (!maybeInfos) return [];
+    const { accessedObject } = maybeInfos;
     if (!ts.isIdentifier(accessedObject)) return [];
-    const schemaName = match(
-      yield* option(
-        findImportedModuleIdentifierByPackageAndNameOrBarrel(
-          sourceFile,
-          "effect",
-          "Schema"
-        )
-      ),
-      {
-        onNone: () => "Schema",
-        onSome: (_) => _.text
-      }
-    );
+    const schemaName = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Schema"
+    ) || "Schema";
     if (schemaName !== accessedObject.text) return [];
     const span = ts.createTextSpan(
       accessedObject.end + 1,
       Math.max(0, position - accessedObject.end - 1)
     );
     return pipe(
-      yield* getAncestorNodesInRange(sourceFile, toTextRange(accessedObject.pos)),
+      tsUtils.getAncestorNodesInRange(sourceFile, tsUtils.toTextRange(accessedObject.pos)),
       filter(ts.isVariableDeclaration),
-      map3((_) => _.name && ts.isIdentifier(_.name) ? _.name.text : ""),
+      map4((_) => _.name && ts.isIdentifier(_.name) ? _.name.text : ""),
       filter((_) => _.length > 0),
       head,
       map2((name) => [
@@ -4348,6 +5137,7 @@ var completions = [
   fnFunctionStar,
   effectDataClasses,
   effectDiagnosticsComment,
+  effectCodegensComment,
   durationInput,
   schemaBrand
 ];
@@ -4355,10 +5145,11 @@ var completions = [
 // src/core/AutoImport.ts
 var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
   const ts = yield* service(TypeScriptApi);
+  const tsUtils = yield* service(TypeScriptUtils);
   const program = yield* service(TypeScriptProgram);
   const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
   const host = program;
-  const getModuleSpecifier = makeGetModuleSpecifier(ts);
+  const getModuleSpecifier = tsUtils.makeGetModuleSpecifier();
   function collectSourceFileReexports(sourceFile) {
     const namespaceExports = [];
     const namedExports = [];
@@ -4412,7 +5203,7 @@ var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
       if (!isArray(_entrypoints)) return;
       if (!every(isString)) return;
       const entrypoints = _entrypoints.map((_) => String(_));
-      const info = parsePackageContentNameAndVersionFromScope({ packageJsonScope: packageJsonInfo });
+      const info = tsUtils.parsePackageContentNameAndVersionFromScope({ packageJsonScope: packageJsonInfo });
       if (!info) return { entrypoints, exportedKeys: [] };
       return { entrypoints, exportedKeys: info.exportsKeys };
     } catch (_) {
@@ -4442,7 +5233,7 @@ var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
   const collectImportCache = fn("TypeScriptApi")(
     function* (packagePatterns, kind) {
       for (const packagePattern of packagePatterns) {
-        const packageNames = yield* resolveModulePattern(fromSourceFile, packagePattern);
+        const packageNames = tsUtils.resolveModulePattern(fromSourceFile, packagePattern);
         for (const packageName of packageNames) {
           const packageInfo = getPackageInfo(fromSourceFile.fileName, packageName);
           if (!packageInfo) continue;
@@ -4574,6 +5365,7 @@ var getOrMakeAutoImportProvider = fn("getOrMakeAutoImportProvider")(function* (s
 });
 var parseImportOnlyChanges = fn("parseImportOnlyChanges")(function* (sourceFile, changes) {
   const ts = yield* service(TypeScriptApi);
+  const tsUtils = yield* service(TypeScriptUtils);
   const deletions = [];
   const imports = [];
   for (const change of changes) {
@@ -4609,7 +5401,7 @@ var parseImportOnlyChanges = fn("parseImportOnlyChanges")(function* (sourceFile,
         return;
       }
     } else {
-      const ancestorNodes = yield* getAncestorNodesInRange(sourceFile, {
+      const ancestorNodes = tsUtils.getAncestorNodesInRange(sourceFile, {
         pos: change.span.start,
         end: change.span.start
       });
@@ -4903,12 +5695,13 @@ function effectRpcDefinition(applicableGotoDefinition, sourceFile, position) {
   return gen(function* () {
     const program = yield* service(TypeScriptProgram);
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
-    const textRange = toTextRange(position);
+    const textRange = tsUtils.toTextRange(position);
     function isSymbolFromEffectRpcModule(symbol3) {
       if (symbol3.valueDeclaration) {
         const sourceFile2 = symbol3.valueDeclaration.getSourceFile();
-        const packageInfo = parsePackageContentNameAndVersionFromScope(sourceFile2);
+        const packageInfo = tsUtils.parsePackageContentNameAndVersionFromScope(sourceFile2);
         if (packageInfo && packageInfo.name === "@effect/rpc") {
           const fileSymbol = typeChecker.getSymbolAtLocation(sourceFile2);
           return fileSymbol && fileSymbol.exports && fileSymbol.exports.has("isRpc") && fileSymbol.exports.has("make") && fileSymbol.exports.has("fromTaggedRequest");
@@ -4919,7 +5712,7 @@ function effectRpcDefinition(applicableGotoDefinition, sourceFile, position) {
     function isSymbolFromEffectRpcClientModule(symbol3) {
       if (symbol3.valueDeclaration) {
         const sourceFile2 = symbol3.valueDeclaration.getSourceFile();
-        const packageInfo = parsePackageContentNameAndVersionFromScope(sourceFile2);
+        const packageInfo = tsUtils.parsePackageContentNameAndVersionFromScope(sourceFile2);
         if (packageInfo && packageInfo.name === "@effect/rpc") {
           const fileSymbol = typeChecker.getSymbolAtLocation(sourceFile2);
           return fileSymbol && fileSymbol.exports && fileSymbol.exports.has("RpcClient") && fileSymbol.exports.has("make");
@@ -4929,8 +5722,8 @@ function effectRpcDefinition(applicableGotoDefinition, sourceFile, position) {
     }
     let rpcName = null;
     let callNode = null;
-    for (const node of yield* getAncestorNodesInRange(sourceFile, textRange)) {
-      if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name) && isNodeInRange(textRange)(node.name)) {
+    for (const node of tsUtils.getAncestorNodesInRange(sourceFile, textRange)) {
+      if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name) && tsUtils.isNodeInRange(textRange)(node.name)) {
         const type = typeChecker.getTypeAtLocation(node);
         for (const callSig of type.getCallSignatures()) {
           if (callSig.parameters.length >= 2 && isSymbolFromEffectRpcClientModule(callSig.parameters[1])) {
@@ -5082,7 +5875,7 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
           type,
           atLocation
         ),
-        map4((_) => makeSymbolDisplayParts("Effect Type Parameters", _.A, _.E, _.R)),
+        map3((_) => makeSymbolDisplayParts("Effect Type Parameters", _.A, _.E, _.R)),
         orElse2(() => {
           const callSignatues = type.getCallSignatures();
           if (callSignatues.length !== 1) return succeed([]);
@@ -5092,7 +5885,7 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
               returnType,
               atLocation
             ),
-            map4((_) => makeSymbolDisplayParts("Returned Effect Type Parameters", _.A, _.E, _.R))
+            map3((_) => makeSymbolDisplayParts("Returned Effect Type Parameters", _.A, _.E, _.R))
           );
         })
       );
@@ -5121,41 +5914,6 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
   );
 }
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/encoding/common.js
-var encoder = /* @__PURE__ */ new TextEncoder();
-
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/encoding/base64.js
-var encode = (bytes) => {
-  const length = bytes.length;
-  let result = "";
-  let i;
-  for (i = 2; i < length; i += 3) {
-    result += base64abc[bytes[i - 2] >> 2];
-    result += base64abc[(bytes[i - 2] & 3) << 4 | bytes[i - 1] >> 4];
-    result += base64abc[(bytes[i - 1] & 15) << 2 | bytes[i] >> 6];
-    result += base64abc[bytes[i] & 63];
-  }
-  if (i === length + 1) {
-    result += base64abc[bytes[i - 2] >> 2];
-    result += base64abc[(bytes[i - 2] & 3) << 4];
-    result += "==";
-  }
-  if (i === length) {
-    result += base64abc[bytes[i - 2] >> 2];
-    result += base64abc[(bytes[i - 2] & 3) << 4 | bytes[i - 1] >> 4];
-    result += base64abc[(bytes[i - 1] & 15) << 2];
-    result += "=";
-  }
-  return result;
-};
-var base64abc = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "+", "/"];
-
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/encoding/base64Url.js
-var encode2 = (data) => encode(data).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
-
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Encoding.js
-var encodeBase64Url = (input) => typeof input === "string" ? encode2(encoder.encode(input)) : encode2(input);
-
 // node_modules/.pnpm/pako@2.1.0/node_modules/pako/dist/pako.esm.mjs
 var Z_FIXED$1 = 4;
 var Z_BINARY = 0;
@@ -6025,7 +6783,7 @@ var read_buf = (strm, buf, start, size) => {
 var longest_match = (s, cur_match) => {
   let chain_length = s.max_chain_length;
   let scan = s.strstart;
-  let match3;
+  let match2;
   let len;
   let best_len = s.prev_length;
   let nice_match = s.nice_match;
@@ -6043,14 +6801,14 @@ var longest_match = (s, cur_match) => {
     nice_match = s.lookahead;
   }
   do {
-    match3 = cur_match;
-    if (_win[match3 + best_len] !== scan_end || _win[match3 + best_len - 1] !== scan_end1 || _win[match3] !== _win[scan] || _win[++match3] !== _win[scan + 1]) {
+    match2 = cur_match;
+    if (_win[match2 + best_len] !== scan_end || _win[match2 + best_len - 1] !== scan_end1 || _win[match2] !== _win[scan] || _win[++match2] !== _win[scan + 1]) {
       continue;
     }
     scan += 2;
-    match3++;
+    match2++;
     do {
-    } while (_win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && scan < strend);
+    } while (_win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && scan < strend);
     len = MAX_MATCH - (strend - scan);
     scan = strend - MAX_MATCH;
     if (len > best_len) {
@@ -7751,7 +8509,7 @@ var inflate_table = (type, lens, lens_index, codes, table, table_index, work, op
   let mask;
   let next;
   let base = null;
-  let match3;
+  let match2;
   const count = new Uint16Array(MAXBITS + 1);
   const offs = new Uint16Array(MAXBITS + 1);
   let extra = null;
@@ -7807,15 +8565,15 @@ var inflate_table = (type, lens, lens_index, codes, table, table_index, work, op
   }
   if (type === CODES$1) {
     base = extra = work;
-    match3 = 20;
+    match2 = 20;
   } else if (type === LENS$1) {
     base = lbase;
     extra = lext;
-    match3 = 257;
+    match2 = 257;
   } else {
     base = dbase;
     extra = dext;
-    match3 = 0;
+    match2 = 0;
   }
   huff = 0;
   sym = 0;
@@ -7831,12 +8589,12 @@ var inflate_table = (type, lens, lens_index, codes, table, table_index, work, op
   }
   for (; ; ) {
     here_bits = len - drop;
-    if (work[sym] + 1 < match3) {
+    if (work[sym] + 1 < match2) {
       here_op = 0;
       here_val = work[sym];
-    } else if (work[sym] >= match3) {
-      here_op = extra[work[sym] - match3];
-      here_val = base[work[sym] - match3];
+    } else if (work[sym] >= match2) {
+      here_op = extra[work[sym] - match2];
+      here_val = base[work[sym] - match2];
     } else {
       here_op = 32 + 64;
       here_val = 0;
@@ -9599,13 +10357,14 @@ function layerInfo(sourceFile, position, quickInfo2) {
   return pipe(
     gen(function* () {
       const ts = yield* service(TypeScriptApi);
+      const tsUtils = yield* service(TypeScriptUtils);
       const typeChecker = yield* service(TypeCheckerApi);
       const typeParser = yield* service(TypeParser);
-      const range = toTextRange(position);
+      const range = tsUtils.toTextRange(position);
       const maybeNode = pipe(
-        yield* getAncestorNodesInRange(sourceFile, range),
+        tsUtils.getAncestorNodesInRange(sourceFile, range),
         filter((_) => ts.isVariableDeclaration(_) || ts.isPropertyDeclaration(_)),
-        filter((_) => isNodeInRange(range)(_.name)),
+        filter((_) => tsUtils.isNodeInRange(range)(_.name)),
         head
       );
       if (isNone2(maybeNode)) return quickInfo2;
@@ -9622,7 +10381,7 @@ function layerInfo(sourceFile, position, quickInfo2) {
       };
       const layerInfoDisplayParts = yield* pipe(
         processLayerGraphNode(graphCtx, layerNode, void 0),
-        flatMap2(
+        flatMap(
           (rootNode) => gen(function* () {
             yield* succeed(void 0);
             const lines = [];
@@ -9715,10 +10474,10 @@ var asyncAwaitToGen = createRefactor({
   description: "Convert to Effect.gen",
   apply: fn("asyncAwaitToGen.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
-    const typeParser = yield* service(TypeParser);
     const maybeNode = pipe(
-      yield* getAncestorNodesInRange(sourceFile, textRange),
+      tsUtils.getAncestorNodesInRange(sourceFile, textRange),
       filter(
         (node2) => ts.isFunctionDeclaration(node2) || ts.isArrowFunction(node2) || ts.isFunctionExpression(node2)
       ),
@@ -9734,23 +10493,12 @@ var asyncAwaitToGen = createRefactor({
       apply: pipe(
         gen(function* () {
           const changeTracker = yield* service(ChangeTracker);
-          const effectModuleIdentifierName = match(
-            yield* option(
-              findImportedModuleIdentifier(
-                sourceFile,
-                (node2) => pipe(
-                  typeParser.importedEffectModule(node2),
-                  option,
-                  map4(isSome2)
-                )
-              )
-            ),
-            {
-              onNone: () => "Effect",
-              onSome: (node2) => node2.text
-            }
-          );
-          const newDeclaration = yield* transformAsyncAwaitToEffectGen(
+          const effectModuleIdentifierName = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+            sourceFile,
+            "effect",
+            "Effect"
+          ) || "Effect";
+          const newDeclaration = tsUtils.transformAsyncAwaitToEffectGen(
             node,
             effectModuleIdentifierName,
             (expression) => ts.factory.createCallExpression(
@@ -9786,10 +10534,10 @@ var asyncAwaitToGenTryPromise = createRefactor({
   description: "Convert to Effect.gen with failures",
   apply: fn("asyncAwaitToGenTryPromise.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
-    const typeParser = yield* service(TypeParser);
     const maybeNode = pipe(
-      yield* getAncestorNodesInRange(sourceFile, textRange),
+      tsUtils.getAncestorNodesInRange(sourceFile, textRange),
       filter(
         (node2) => ts.isFunctionDeclaration(node2) || ts.isArrowFunction(node2) || ts.isFunctionExpression(node2)
       ),
@@ -9805,22 +10553,11 @@ var asyncAwaitToGenTryPromise = createRefactor({
       apply: pipe(
         gen(function* () {
           const changeTracker = yield* service(ChangeTracker);
-          const effectModuleIdentifierName = match(
-            yield* option(
-              findImportedModuleIdentifier(
-                sourceFile,
-                (node2) => pipe(
-                  typeParser.importedEffectModule(node2),
-                  option,
-                  map4(isSome2)
-                )
-              )
-            ),
-            {
-              onNone: () => "Effect",
-              onSome: (node2) => node2.text
-            }
-          );
+          const effectModuleIdentifierName = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+            sourceFile,
+            "effect",
+            "Effect"
+          ) || "Effect";
           let errorCount = 0;
           function createErrorADT() {
             errorCount++;
@@ -9835,7 +10572,7 @@ var asyncAwaitToGenTryPromise = createRefactor({
               ts.factory.createShorthandPropertyAssignment("error")
             ]);
           }
-          const newDeclaration = yield* transformAsyncAwaitToEffectGen(
+          const newDeclaration = tsUtils.transformAsyncAwaitToEffectGen(
             node,
             effectModuleIdentifierName,
             (expression) => ts.factory.createCallExpression(
@@ -9887,6 +10624,7 @@ var effectGenToFn = createRefactor({
   description: "Convert to Effect.fn",
   apply: fn("effectGenToFn.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeParser = yield* service(TypeParser);
     const parseEffectGenNode = fn("asyncAwaitToGen.apply")(function* (node) {
       const effectGen = yield* typeParser.effectGen(node);
@@ -9923,8 +10661,8 @@ var effectGenToFn = createRefactor({
       return yield* fail(new RefactorNotApplicableError());
     });
     const maybeNode = yield* pipe(
-      yield* getAncestorNodesInRange(sourceFile, textRange),
-      map3(parseEffectGenNode),
+      tsUtils.getAncestorNodesInRange(sourceFile, textRange),
+      map4(parseEffectGenNode),
       firstSuccessOf,
       option
     );
@@ -9963,7 +10701,7 @@ var effectGenToFn = createRefactor({
           changeTracker.replaceNode(
             sourceFile,
             nodeToReplace,
-            yield* tryPreserveDeclarationSemantics(nodeToReplace, effectFnCallWithGenerator)
+            tsUtils.tryPreserveDeclarationSemantics(nodeToReplace, effectFnCallWithGenerator)
           );
         }),
         provideService(TypeScriptApi, ts)
@@ -9978,11 +10716,12 @@ var functionToArrow = createRefactor({
   description: "Convert to arrow",
   apply: fn("functionToArrow.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const maybeNode = pipe(
-      yield* getAncestorNodesInRange(sourceFile, textRange),
+      tsUtils.getAncestorNodesInRange(sourceFile, textRange),
       filter((_) => ts.isFunctionDeclaration(_) || ts.isMethodDeclaration(_)),
       filter((_) => !!_.body),
-      filter((_) => !!_.name && isNodeInRange(textRange)(_.name)),
+      filter((_) => !!_.name && tsUtils.isNodeInRange(textRange)(_.name)),
       head
     );
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
@@ -10013,7 +10752,7 @@ var functionToArrow = createRefactor({
             ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
             newBody
           );
-          const newDeclaration = yield* tryPreserveDeclarationSemantics(
+          const newDeclaration = tsUtils.tryPreserveDeclarationSemantics(
             node,
             arrowFunction
           );
@@ -10034,6 +10773,7 @@ var _findSchemaVariableDeclaration = fn(
 )(
   function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     const findSchema = fn("makeSchemaOpaque.apply.findSchema")(
@@ -10059,8 +10799,8 @@ var _findSchemaVariableDeclaration = fn(
       }
     );
     return yield* pipe(
-      yield* getAncestorNodesInRange(sourceFile, textRange),
-      map3(findSchema),
+      tsUtils.getAncestorNodesInRange(sourceFile, textRange),
+      map4(findSchema),
       firstSuccessOf,
       option
     );
@@ -10147,6 +10887,7 @@ var makeSchemaOpaque = createRefactor({
   description: "Make Schema opaque",
   apply: fn("makeSchemaOpaque.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const maybeNode = yield* _findSchemaVariableDeclaration(sourceFile, textRange);
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
     const { identifier, types, variableDeclarationList, variableStatement } = maybeNode.value;
@@ -10156,19 +10897,11 @@ var makeSchemaOpaque = createRefactor({
       apply: pipe(
         gen(function* () {
           const changeTracker = yield* service(ChangeTracker);
-          const effectSchemaName = match(
-            yield* option(
-              findImportedModuleIdentifierByPackageAndNameOrBarrel(
-                sourceFile,
-                "effect",
-                "Schema"
-              )
-            ),
-            {
-              onNone: () => "Schema",
-              onSome: (_) => _.text
-            }
-          );
+          const effectSchemaName = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+            sourceFile,
+            "effect",
+            "Schema"
+          ) || "Schema";
           const newIdentifier = ts.factory.createIdentifier(identifier.text + "_");
           const { contextType, encodedType, opaqueType } = yield* _createOpaqueTypes(
             effectSchemaName,
@@ -10225,6 +10958,7 @@ var makeSchemaOpaqueWithNs = createRefactor({
   description: "Make Schema opaque with namespace",
   apply: fn("makeSchemaOpaqueWithNs.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const maybeNode = yield* _findSchemaVariableDeclaration(sourceFile, textRange);
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
     const { identifier, types, variableDeclarationList, variableStatement } = maybeNode.value;
@@ -10234,19 +10968,11 @@ var makeSchemaOpaqueWithNs = createRefactor({
       apply: pipe(
         gen(function* () {
           const changeTracker = yield* service(ChangeTracker);
-          const effectSchemaName = match(
-            yield* option(
-              findImportedModuleIdentifierByPackageAndNameOrBarrel(
-                sourceFile,
-                "effect",
-                "Schema"
-              )
-            ),
-            {
-              onNone: () => "Schema",
-              onSome: (_) => _.text
-            }
-          );
+          const effectSchemaName = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+            sourceFile,
+            "effect",
+            "Schema"
+          ) || "Schema";
           const newIdentifier = ts.factory.createIdentifier(identifier.text + "_");
           const { contextType, encodedType, opaqueType } = yield* _createOpaqueTypes(
             effectSchemaName,
@@ -10320,6 +11046,7 @@ var pipeableToDatafirst = createRefactor({
   apply: fn("pipeableToDatafirst.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     function isPipeCall(node2) {
       if (!ts.isCallExpression(node2)) return false;
       const expression = node2.expression;
@@ -10347,13 +11074,13 @@ var pipeableToDatafirst = createRefactor({
       return none2();
     }
     const maybeNode = pipe(
-      yield* getAncestorNodesInRange(sourceFile, textRange),
+      tsUtils.getAncestorNodesInRange(sourceFile, textRange),
       filter(isPipeCall),
-      filter((node2) => isNodeInRange(textRange)(node2.expression)),
+      filter((node2) => tsUtils.isNodeInRange(textRange)(node2.expression)),
       filter(
         (node2) => node2.arguments.length > 0
       ),
-      map3((node2) => {
+      map4((node2) => {
         let newNode2 = node2.arguments[0];
         let didSomething = false;
         for (let i = 1; i < node2.arguments.length; i++) {
@@ -10380,7 +11107,7 @@ var pipeableToDatafirst = createRefactor({
         return didSomething ? some2([node2, newNode2]) : none2();
       }),
       filter(isSome2),
-      map3((_) => _.value),
+      map4((_) => _.value),
       head
     );
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
@@ -10401,8 +11128,9 @@ var removeUnnecessaryEffectGen = createRefactor({
   name: "removeUnnecessaryEffectGen",
   description: "Remove unnecessary Effect.gen",
   apply: fn("removeUnnecessaryEffectGen.apply")(function* (sourceFile, textRange) {
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeParser = yield* service(TypeParser);
-    for (const nodeToReplace of yield* getAncestorNodesInRange(sourceFile, textRange)) {
+    for (const nodeToReplace of tsUtils.getAncestorNodesInRange(sourceFile, textRange)) {
       const maybeNode = yield* option(typeParser.unnecessaryEffectGen(nodeToReplace));
       if (isNone2(maybeNode)) continue;
       const replacementNode = maybeNode.value.replacementNode;
@@ -10425,10 +11153,11 @@ var toggleLazyConst = createRefactor({
   description: "Toggle lazy const",
   apply: fn("toggleLazyConst.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const maybeNode = pipe(
-      yield* getAncestorNodesInRange(sourceFile, textRange),
+      tsUtils.getAncestorNodesInRange(sourceFile, textRange),
       filter(ts.isVariableDeclaration),
-      filter((node2) => isNodeInRange(textRange)(node2.name)),
+      filter((node2) => tsUtils.isNodeInRange(textRange)(node2.name)),
       filter(
         (node2) => !!node2.initializer && !(ts.isArrowFunction(node2.initializer) && ts.isBlock(node2.initializer.body))
       ),
@@ -10467,6 +11196,7 @@ var togglePipeStyle = createRefactor({
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
+    const tsUtils = yield* service(TypeScriptUtils);
     const togglePipeStyle2 = (node) => gen(function* () {
       const pipeCall = yield* typeParser.pipeCall(node);
       switch (pipeCall.kind) {
@@ -10511,7 +11241,7 @@ var togglePipeStyle = createRefactor({
           };
       }
     });
-    const ancestorNodes = yield* getAncestorNodesInRange(sourceFile, textRange);
+    const ancestorNodes = tsUtils.getAncestorNodesInRange(sourceFile, textRange);
     return yield* pipe(
       firstSuccessOf(ancestorNodes.map(togglePipeStyle2)),
       orElse2(() => fail(new RefactorNotApplicableError()))
@@ -10525,9 +11255,38 @@ var toggleReturnTypeAnnotation = createRefactor({
   description: "Toggle return type annotation",
   apply: fn("toggleReturnTypeAnnotation.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
+    function addReturnTypeAnnotation(sourceFile2, changeTracker, declaration, typeNode) {
+      const closeParen = ts.findChildOfKind(declaration, ts.SyntaxKind.CloseParenToken, sourceFile2);
+      const needParens = ts.isArrowFunction(declaration) && closeParen === void 0;
+      const endNode = needParens ? declaration.parameters[0] : closeParen;
+      if (endNode) {
+        if (needParens) {
+          changeTracker.insertNodeBefore(
+            sourceFile2,
+            endNode,
+            ts.factory.createToken(ts.SyntaxKind.OpenParenToken)
+          );
+          changeTracker.insertNodeAfter(
+            sourceFile2,
+            endNode,
+            ts.factory.createToken(ts.SyntaxKind.CloseParenToken)
+          );
+        }
+        changeTracker.insertNodeAt(sourceFile2, endNode.end, typeNode, { prefix: ": " });
+      }
+    }
+    function removeReturnTypeAnnotation(sourceFile2, changeTracker, declaration) {
+      const closeParen = ts.findChildOfKind(declaration, ts.SyntaxKind.CloseParenToken, sourceFile2);
+      const needParens = ts.isArrowFunction(declaration) && closeParen === void 0;
+      const endNode = needParens ? declaration.parameters[0] : closeParen;
+      if (endNode && declaration.type) {
+        changeTracker.deleteRange(sourceFile2, { pos: endNode.end, end: declaration.type.end });
+      }
+    }
     const maybeNode = pipe(
-      yield* getAncestorNodesInRange(sourceFile, textRange),
+      tsUtils.getAncestorNodesInRange(sourceFile, textRange),
       filter(
         (node2) => ts.isFunctionDeclaration(node2) || ts.isFunctionExpression(node2) || ts.isArrowFunction(node2) || ts.isMethodDeclaration(node2)
       ),
@@ -10540,8 +11299,8 @@ var toggleReturnTypeAnnotation = createRefactor({
         kind: "refactor.rewrite.effect.toggleReturnTypeAnnotation",
         description: "Toggle return type annotation",
         apply: pipe(
-          removeReturnTypeAnnotation(sourceFile, node),
-          provideService(TypeScriptApi, ts)
+          service(ChangeTracker),
+          map3((changeTracker) => removeReturnTypeAnnotation(sourceFile, changeTracker, node))
         )
       };
     }
@@ -10557,13 +11316,10 @@ var toggleReturnTypeAnnotation = createRefactor({
       kind: "refactor.rewrite.effect.toggleReturnTypeAnnotation",
       description: "Toggle return type annotation",
       apply: pipe(
-        addReturnTypeAnnotation(
-          sourceFile,
-          node,
-          yield* simplifyTypeNode(returnTypeNode)
-        ),
-        provideService(TypeCheckerApi, typeChecker),
-        provideService(TypeScriptApi, ts)
+        service(ChangeTracker),
+        map3(
+          (changeTracker) => addReturnTypeAnnotation(sourceFile, changeTracker, node, tsUtils.simplifyTypeNode(returnTypeNode))
+        )
       )
     };
   })
@@ -10575,11 +11331,12 @@ var toggleTypeAnnotation = createRefactor({
   description: "Toggle type annotation",
   apply: fn("toggleTypeAnnotation.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const maybeNode = pipe(
-      yield* getAncestorNodesInRange(sourceFile, textRange),
+      tsUtils.getAncestorNodesInRange(sourceFile, textRange),
       filter((node2) => ts.isVariableDeclaration(node2) || ts.isPropertyDeclaration(node2)),
-      filter((node2) => isNodeInRange(textRange)(node2.name)),
+      filter((node2) => tsUtils.isNodeInRange(textRange)(node2.name)),
       filter((node2) => !!node2.initializer),
       head
     );
@@ -10615,7 +11372,7 @@ var toggleTypeAnnotation = createRefactor({
             changeTracker.insertNodeAt(
               sourceFile,
               node.name.end,
-              yield* simplifyTypeNode(initializerTypeNode),
+              tsUtils.simplifyTypeNode(initializerTypeNode),
               {
                 prefix: ": "
               }
@@ -10667,21 +11424,16 @@ var IndexSignatureWithMoreThanOneParameterError = class {
 };
 var SchemaGenContext = Tag("SchemaGenContext");
 var makeSchemaGenContext = fn("SchemaGen.makeSchemaGenContext")(function* (sourceFile) {
-  const effectSchemaIdentifier = pipe(
-    yield* option(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Schema")
-    ),
-    match({
-      onNone: () => "Schema",
-      onSome: (_) => _.text
-    })
-  );
+  const tsUtils = yield* service(TypeScriptUtils);
+  const effectSchemaIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+    sourceFile,
+    "effect",
+    "Schema"
+  ) || "Schema";
   const moduleToImportedName = {};
   for (const moduleName of ["Option", "Either", "Chunk", "Duration"]) {
-    const importedName = yield* option(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", moduleName)
-    );
-    if (isSome2(importedName)) moduleToImportedName[moduleName] = importedName.value.text;
+    const importedName = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", moduleName);
+    if (importedName) moduleToImportedName[moduleName] = importedName;
   }
   const ts = yield* service(TypeScriptApi);
   return {
@@ -11065,10 +11817,11 @@ var process = fn("SchemaGen.process")(
 var findNodeToProcess = fn("SchemaGen.findNodeToProcess")(
   function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     return pipe(
-      yield* getAncestorNodesInRange(sourceFile, textRange),
+      tsUtils.getAncestorNodesInRange(sourceFile, textRange),
       filter((node) => ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)),
-      filter((node) => isNodeInRange(textRange)(node.name)),
+      filter((node) => tsUtils.isNodeInRange(textRange)(node.name)),
       filter((node) => (node.typeParameters || []).length === 0),
       head
     );
@@ -11101,6 +11854,7 @@ var typeToEffectSchema = createRefactor({
   description: "Refactor to Schema",
   apply: fn("typeToEffectSchema.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const maybeNode = yield* findNodeToProcess(sourceFile, textRange);
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
@@ -11111,6 +11865,7 @@ var typeToEffectSchema = createRefactor({
       apply: pipe(
         applyAtNode(sourceFile, node, false),
         provideService(TypeCheckerApi, typeChecker),
+        provideService(TypeScriptUtils, tsUtils),
         provideService(TypeScriptApi, ts)
       )
     };
@@ -11123,6 +11878,7 @@ var typeToEffectSchemaClass = createRefactor({
   description: "Refactor to Schema.Class",
   apply: fn("typeToEffectSchemaClass.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const maybeNode = yield* findNodeToProcess(sourceFile, textRange);
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
@@ -11133,6 +11889,7 @@ var typeToEffectSchemaClass = createRefactor({
       apply: pipe(
         applyAtNode(sourceFile, node, true),
         provideService(TypeCheckerApi, typeChecker),
+        provideService(TypeScriptUtils, tsUtils),
         provideService(TypeScriptApi, ts)
       )
     };
@@ -11145,6 +11902,7 @@ var wrapWithEffectGen = createRefactor({
   description: "Wrap with Effect.gen",
   apply: fn("wrapWithEffectGen.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     const findEffectToWrap = fn("wrapWithEffectGen.apply.findEffectToWrap")(
@@ -11158,37 +11916,26 @@ var wrapWithEffectGen = createRefactor({
       }
     );
     const maybeNode = yield* pipe(
-      yield* getAncestorNodesInRange(sourceFile, textRange),
-      map3(findEffectToWrap),
+      tsUtils.getAncestorNodesInRange(sourceFile, textRange),
+      map4(findEffectToWrap),
       firstSuccessOf,
       option
     );
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
-    const effectModuleIdentifier = match(
-      yield* option(
-        findImportedModuleIdentifier(
-          sourceFile,
-          (node) => pipe(
-            typeParser.importedEffectModule(node),
-            option,
-            map4(isSome2)
-          )
-        )
-      ),
-      {
-        onNone: () => "Effect",
-        onSome: (node) => node.text
-      }
-    );
+    const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Effect"
+    ) || "Effect";
     return {
       kind: "refactor.rewrite.effect.wrapWithEffectGen",
       description: `Wrap with Effect.gen`,
       apply: pipe(
         gen(function* () {
           const changeTracker = yield* service(ChangeTracker);
-          const effectGen = yield* createEffectGenCallExpressionWithBlock(
+          const effectGen = tsUtils.createEffectGenCallExpressionWithBlock(
             effectModuleIdentifier,
-            yield* createReturnYieldStarStatement(maybeNode.value)
+            tsUtils.createReturnYieldStarStatement(maybeNode.value)
           );
           changeTracker.replaceNode(sourceFile, maybeNode.value, effectGen);
         }),
@@ -11219,273 +11966,6 @@ var wrapWithPipe = createRefactor({
   })
 });
 
-// src/refactors/writeTagClassAccessors.ts
-var writeTagClassAccessors = createRefactor({
-  name: "writeTagClassAccessors",
-  description: "Implement Service accessors",
-  apply: fn("writeTagClassAccessors.apply")(function* (sourceFile, textRange) {
-    const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
-    const typeParser = yield* service(TypeParser);
-    const effectIdentifier = pipe(
-      yield* option(
-        findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Effect")
-      ),
-      match({
-        onNone: () => "Effect",
-        onSome: (_) => _.text
-      })
-    );
-    const createConstantProperty = (className, propertyName, type) => ts.factory.createPropertyDeclaration(
-      [ts.factory.createModifier(ts.SyntaxKind.StaticKeyword)],
-      propertyName,
-      void 0,
-      type,
-      ts.factory.createCallExpression(
-        ts.factory.createPropertyAccessExpression(
-          ts.factory.createIdentifier(effectIdentifier),
-          "andThen"
-        ),
-        void 0,
-        [
-          ts.factory.createIdentifier(className.text),
-          ts.factory.createArrowFunction(
-            void 0,
-            void 0,
-            [ts.factory.createParameterDeclaration(
-              void 0,
-              void 0,
-              "_"
-            )],
-            void 0,
-            void 0,
-            ts.factory.createPropertyAccessExpression(
-              ts.factory.createIdentifier("_"),
-              propertyName
-            )
-          )
-        ]
-      )
-    );
-    const createFunctionProperty = (className, propertyName, type, forceAny) => {
-      const arrowBody = ts.factory.createCallExpression(
-        ts.factory.createPropertyAccessExpression(
-          ts.factory.createIdentifier(effectIdentifier),
-          "andThen"
-        ),
-        void 0,
-        [
-          ts.factory.createIdentifier(className.text),
-          ts.factory.createArrowFunction(
-            void 0,
-            void 0,
-            [ts.factory.createParameterDeclaration(
-              void 0,
-              void 0,
-              "_",
-              void 0,
-              forceAny ? ts.factory.createTypeReferenceNode("any") : void 0
-            )],
-            void 0,
-            void 0,
-            ts.factory.createCallExpression(
-              ts.factory.createPropertyAccessExpression(
-                ts.factory.createIdentifier("_"),
-                propertyName
-              ),
-              void 0,
-              [
-                ts.factory.createSpreadElement(ts.factory.createIdentifier("args"))
-              ]
-            )
-          )
-        ]
-      );
-      return ts.factory.createPropertyDeclaration(
-        [ts.factory.createModifier(ts.SyntaxKind.StaticKeyword)],
-        propertyName,
-        void 0,
-        type,
-        ts.factory.createArrowFunction(
-          void 0,
-          void 0,
-          [ts.factory.createParameterDeclaration(
-            void 0,
-            ts.factory.createToken(ts.SyntaxKind.DotDotDotToken),
-            "args",
-            void 0,
-            forceAny ? ts.factory.createArrayTypeNode(ts.factory.createTypeReferenceNode("any")) : void 0
-          )],
-          void 0,
-          void 0,
-          forceAny ? ts.factory.createAsExpression(arrowBody, ts.factory.createTypeReferenceNode("any")) : arrowBody
-        )
-      );
-    };
-    const generateReturnType = (type, atLocation, className) => pipe(
-      typeParser.effectType(type, atLocation),
-      flatMap2((returnedEffect) => {
-        const contextType = returnedEffect.R.flags & ts.TypeFlags.Never ? ts.factory.createTypeReferenceNode(className.text) : ts.factory.createUnionTypeNode(
-          [
-            ts.factory.createTypeReferenceNode(className.text),
-            typeChecker.typeToTypeNode(returnedEffect.R, atLocation, ts.NodeBuilderFlags.NoTruncation)
-          ]
-        );
-        const successType = typeChecker.typeToTypeNode(
-          returnedEffect.A,
-          atLocation,
-          ts.NodeBuilderFlags.NoTruncation
-        );
-        if (!successType) return fail("error generating success type");
-        const failureType = typeChecker.typeToTypeNode(
-          returnedEffect.E,
-          atLocation,
-          ts.NodeBuilderFlags.NoTruncation
-        );
-        if (!failureType) return fail("error generating failure type");
-        const typeNode = ts.factory.createTypeReferenceNode(
-          ts.factory.createQualifiedName(
-            ts.factory.createIdentifier(effectIdentifier),
-            ts.factory.createIdentifier("Effect")
-          ),
-          [successType, failureType, contextType]
-        );
-        return succeed(typeNode);
-      }),
-      orElse2(
-        () => pipe(
-          typeParser.promiseLike(type, atLocation),
-          flatMap2(({ type: type2 }) => {
-            const successType = typeChecker.typeToTypeNode(
-              type2,
-              atLocation,
-              ts.NodeBuilderFlags.NoTruncation
-            );
-            if (!successType) return fail("error generating success type");
-            return succeed(ts.factory.createTypeReferenceNode(
-              ts.factory.createQualifiedName(
-                ts.factory.createIdentifier(effectIdentifier),
-                ts.factory.createIdentifier("Effect")
-              ),
-              [
-                successType,
-                ts.factory.createTypeReferenceNode(
-                  ts.factory.createQualifiedName(
-                    ts.factory.createIdentifier("Cause"),
-                    ts.factory.createIdentifier("UnknownException")
-                  )
-                ),
-                ts.factory.createTypeReferenceNode(className.text)
-              ]
-            ));
-          })
-        )
-      ),
-      orElse2(() => {
-        const successType = typeChecker.typeToTypeNode(type, atLocation, ts.NodeBuilderFlags.NoTruncation);
-        if (!successType) return fail("error generating success type");
-        const typeNode = ts.factory.createTypeReferenceNode(
-          ts.factory.createQualifiedName(
-            ts.factory.createIdentifier(effectIdentifier),
-            ts.factory.createIdentifier("Effect")
-          ),
-          [
-            successType,
-            ts.factory.createTypeReferenceNode("never"),
-            ts.factory.createTypeReferenceNode(className.text)
-          ]
-        );
-        return succeed(typeNode);
-      })
-    );
-    const proxySignature = (signature, atLocation, className) => gen(function* () {
-      const signatureDeclaration = typeChecker.signatureToSignatureDeclaration(
-        signature,
-        ts.SyntaxKind.FunctionType,
-        atLocation,
-        ts.NodeBuilderFlags.NoTruncation
-      );
-      if (!signatureDeclaration) return yield* fail("error generating signature");
-      const returnType = yield* generateReturnType(signature.getReturnType(), atLocation, className);
-      return ts.factory.createFunctionTypeNode(
-        signatureDeclaration.typeParameters,
-        signatureDeclaration.parameters,
-        returnType
-      );
-    });
-    const writeAccessors = fn("writeTagClassAccessors.writeAccessors")(
-      function* (service2, className, atLocation) {
-        const changeTracker = yield* service(ChangeTracker);
-        const insertLocation = atLocation.members.length > 0 ? atLocation.members[0].pos : atLocation.getEnd() - 1;
-        for (const property of typeChecker.getPropertiesOfType(service2)) {
-          const servicePropertyType = typeChecker.getTypeOfSymbolAtLocation(property, atLocation);
-          const callSignatures = [];
-          let propertyDeclaration = void 0;
-          for (const signature of servicePropertyType.getCallSignatures()) {
-            yield* pipe(
-              proxySignature(signature, atLocation, className),
-              map4((sig) => {
-                callSignatures.push(sig);
-              }),
-              ignore
-            );
-          }
-          if (callSignatures.length === 0) {
-            yield* pipe(
-              generateReturnType(servicePropertyType, atLocation, className),
-              map4((type) => {
-                propertyDeclaration = createConstantProperty(className, property.getName(), type);
-              }),
-              ignore
-            );
-          } else {
-            const allSignatures = ts.factory.createIntersectionTypeNode(callSignatures);
-            const type = yield* simplifyTypeNode(allSignatures);
-            propertyDeclaration = createFunctionProperty(className, property.getName(), type, callSignatures.length > 1);
-          }
-          if (propertyDeclaration) {
-            const oldProperty = atLocation.members.filter(ts.isPropertyDeclaration).find((p) => {
-              const symbol3 = typeChecker.getSymbolAtLocation(p.name);
-              return symbol3?.getName() === property.getName();
-            });
-            if (oldProperty) {
-              changeTracker.deleteRange(sourceFile, {
-                pos: oldProperty.getStart(sourceFile),
-                end: oldProperty.getEnd()
-              });
-              changeTracker.insertNodeAt(sourceFile, oldProperty.getStart(sourceFile), propertyDeclaration);
-            } else {
-              changeTracker.insertNodeAt(sourceFile, insertLocation, propertyDeclaration, { suffix: "\n" });
-            }
-          }
-        }
-      }
-    );
-    const writeTagClassAccessors2 = (node) => gen(function* () {
-      if (!ts.isClassDeclaration(node)) return yield* fail(new RefactorNotApplicableError());
-      if (!node.name) return yield* fail(new RefactorNotApplicableError());
-      const classSym = typeChecker.getSymbolAtLocation(node.name);
-      if (!classSym) return yield* fail(new RefactorNotApplicableError());
-      const type = typeChecker.getTypeOfSymbol(classSym);
-      const { Service } = yield* pipe(
-        typeParser.contextTag(type, node),
-        orElse2(() => fail(new RefactorNotApplicableError()))
-      );
-      return {
-        kind: "refactor.rewrite.effect.writeTagClassAccessors",
-        description: "Implement Service accessors",
-        apply: pipe(
-          writeAccessors(Service, node.name, node),
-          provideService(TypeCheckerApi, typeChecker),
-          provideService(TypeScriptApi, ts)
-        )
-      };
-    });
-    const parentNodes = yield* getAncestorNodesInRange(sourceFile, textRange);
-    return yield* firstSuccessOf(parentNodes.map(writeTagClassAccessors2));
-  })
-});
-
 // src/refactors.ts
 var refactors = [
   asyncAwaitToGen,
@@ -11536,13 +12016,10 @@ var init = (modules) => {
     function runNano(program) {
       return (fa) => pipe(
         fa,
-        provideService(TypeParser, make3(modules.typescript, program.getTypeChecker())),
-        provideService(TypeScriptProgram, program),
+        nanoLayer2,
+        nanoLayer,
         provideService(TypeCheckerApi, program.getTypeChecker()),
-        provideService(
-          TypeCheckerApiCache,
-          makeTypeCheckerApiCache()
-        ),
+        provideService(TypeScriptProgram, program),
         provideService(TypeScriptApi, modules.typescript),
         provideService(
           LanguageServicePluginOptions,
@@ -11626,7 +12103,7 @@ var init = (modules) => {
               }
               return effectCodeFixes;
             }),
-            flatMap2(
+            flatMap(
               (effectCodeFixes) => pipe(
                 middlewareAutoImportQuickfixes(
                   sourceFile,
@@ -11635,7 +12112,7 @@ var init = (modules) => {
                   preferences,
                   applicableCodeFixes
                 ),
-                map4((modifiedCodeFixes) => effectCodeFixes.concat(modifiedCodeFixes))
+                map3((modifiedCodeFixes) => effectCodeFixes.concat(modifiedCodeFixes))
               )
             ),
             runNano(program),
@@ -11744,7 +12221,7 @@ var init = (modules) => {
           if (sourceFile) {
             return pipe(
               appendEffectCompletionEntryData(sourceFile, applicableCompletions),
-              flatMap2(
+              flatMap(
                 (augmentedCompletions) => pipe(
                   getCompletionsAtPosition(
                     completions,
@@ -11753,7 +12230,7 @@ var init = (modules) => {
                     options,
                     formattingSettings
                   ),
-                  map4(
+                  map3(
                     (effectCompletions) => augmentedCompletions ? {
                       ...augmentedCompletions,
                       entries: effectCompletions.concat(augmentedCompletions.entries)