@effect/language-service 0.27.2 → 0.28.1

package/index.js

@@ -1,4 +1,9 @@
 "use strict";
+var __defProp = Object.defineProperty;
+var __export = (target, all3) => {
+  for (var name in all3)
+    __defProp(target, name, { get: all3[name], enumerable: true });
+};
 
 // node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Function.js
 var isFunction = (input) => typeof input === "function";
@@ -130,14 +135,150 @@ var globalValue = (id, compute) => {
 };
 
 // node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Predicate.js
+var Predicate_exports = {};
+__export(Predicate_exports, {
+  all: () => all,
+  and: () => and,
+  compose: () => compose,
+  eqv: () => eqv,
+  every: () => every,
+  hasProperty: () => hasProperty,
+  implies: () => implies,
+  isBigInt: () => isBigInt,
+  isBoolean: () => isBoolean,
+  isDate: () => isDate,
+  isError: () => isError,
+  isFunction: () => isFunction2,
+  isIterable: () => isIterable,
+  isMap: () => isMap,
+  isNever: () => isNever,
+  isNotNull: () => isNotNull,
+  isNotNullable: () => isNotNullable,
+  isNotUndefined: () => isNotUndefined,
+  isNull: () => isNull,
+  isNullable: () => isNullable,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isPromise: () => isPromise,
+  isPromiseLike: () => isPromiseLike,
+  isPropertyKey: () => isPropertyKey,
+  isReadonlyRecord: () => isReadonlyRecord,
+  isRecord: () => isRecord,
+  isRecordOrArray: () => isRecordOrArray,
+  isRegExp: () => isRegExp,
+  isSet: () => isSet,
+  isString: () => isString,
+  isSymbol: () => isSymbol,
+  isTagged: () => isTagged,
+  isTruthy: () => isTruthy,
+  isTupleOf: () => isTupleOf,
+  isTupleOfAtLeast: () => isTupleOfAtLeast,
+  isUint8Array: () => isUint8Array,
+  isUndefined: () => isUndefined,
+  isUnknown: () => isUnknown,
+  mapInput: () => mapInput,
+  nand: () => nand,
+  nor: () => nor,
+  not: () => not,
+  or: () => or,
+  product: () => product,
+  productMany: () => productMany,
+  some: () => some,
+  struct: () => struct,
+  tuple: () => tuple,
+  xor: () => xor
+});
+var mapInput = /* @__PURE__ */ dual(2, (self, f) => (b) => self(f(b)));
+var isTupleOf = /* @__PURE__ */ dual(2, (self, n) => self.length === n);
+var isTupleOfAtLeast = /* @__PURE__ */ dual(2, (self, n) => self.length >= n);
+var isTruthy = (input) => !!input;
+var isSet = (input) => input instanceof Set;
+var isMap = (input) => input instanceof Map;
 var isString = (input) => typeof input === "string";
 var isNumber = (input) => typeof input === "number";
 var isBoolean = (input) => typeof input === "boolean";
+var isBigInt = (input) => typeof input === "bigint";
+var isSymbol = (input) => typeof input === "symbol";
+var isPropertyKey = (u) => isString(u) || isNumber(u) || isSymbol(u);
 var isFunction2 = isFunction;
+var isUndefined = (input) => input === void 0;
+var isNotUndefined = (input) => input !== void 0;
+var isNull = (input) => input === null;
+var isNotNull = (input) => input !== null;
+var isNever = (_) => false;
+var isUnknown = (_) => true;
 var isRecordOrArray = (input) => typeof input === "object" && input !== null;
 var isObject = (input) => isRecordOrArray(input) || isFunction2(input);
 var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObject(self) && property in self);
+var isTagged = /* @__PURE__ */ dual(2, (self, tag) => hasProperty(self, "_tag") && self["_tag"] === tag);
+var isNullable = (input) => input === null || input === void 0;
+var isNotNullable = (input) => input !== null && input !== void 0;
+var isError = (input) => input instanceof Error;
+var isUint8Array = (input) => input instanceof Uint8Array;
+var isDate = (input) => input instanceof Date;
+var isIterable = (input) => hasProperty(input, Symbol.iterator);
 var isRecord = (input) => isRecordOrArray(input) && !Array.isArray(input);
+var isReadonlyRecord = isRecord;
+var isPromise = (input) => hasProperty(input, "then") && "catch" in input && isFunction2(input.then) && isFunction2(input.catch);
+var isPromiseLike = (input) => hasProperty(input, "then") && isFunction2(input.then);
+var isRegExp = (input) => input instanceof RegExp;
+var compose = /* @__PURE__ */ dual(2, (ab, bc) => (a) => ab(a) && bc(a));
+var product = (self, that) => ([a, b]) => self(a) && that(b);
+var all = (collection) => {
+  return (as) => {
+    let collectionIndex = 0;
+    for (const p of collection) {
+      if (collectionIndex >= as.length) {
+        break;
+      }
+      if (p(as[collectionIndex]) === false) {
+        return false;
+      }
+      collectionIndex++;
+    }
+    return true;
+  };
+};
+var productMany = (self, collection) => {
+  const rest = all(collection);
+  return ([head2, ...tail]) => self(head2) === false ? false : rest(tail);
+};
+var tuple = (...elements) => all(elements);
+var struct = (fields) => {
+  const keys = Object.keys(fields);
+  return (a) => {
+    for (const key of keys) {
+      if (!fields[key](a[key])) {
+        return false;
+      }
+    }
+    return true;
+  };
+};
+var not = (self) => (a) => !self(a);
+var or = /* @__PURE__ */ dual(2, (self, that) => (a) => self(a) || that(a));
+var and = /* @__PURE__ */ dual(2, (self, that) => (a) => self(a) && that(a));
+var xor = /* @__PURE__ */ dual(2, (self, that) => (a) => self(a) !== that(a));
+var eqv = /* @__PURE__ */ dual(2, (self, that) => (a) => self(a) === that(a));
+var implies = /* @__PURE__ */ dual(2, (antecedent, consequent) => (a) => antecedent(a) ? consequent(a) : true);
+var nor = /* @__PURE__ */ dual(2, (self, that) => (a) => !(self(a) || that(a)));
+var nand = /* @__PURE__ */ dual(2, (self, that) => (a) => !(self(a) && that(a)));
+var every = (collection) => (a) => {
+  for (const p of collection) {
+    if (!p(a)) {
+      return false;
+    }
+  }
+  return true;
+};
+var some = (collection) => (a) => {
+  for (const p of collection) {
+    if (p(a)) {
+      return true;
+    }
+  }
+  return false;
+};
 
 // node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/errors.js
 var getBugErrorMessage = (message) => `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`;
@@ -650,7 +791,7 @@ var isOption = (input) => hasProperty(input, TypeId);
 var isNone = (fa) => fa._tag === "None";
 var isSome = (fa) => fa._tag === "Some";
 var none = /* @__PURE__ */ Object.create(NoneProto);
-var some = (value) => {
+var some2 = (value) => {
   const a = Object.create(SomeProto);
   a.value = value;
   return a;
@@ -732,7 +873,7 @@ var string2 = /* @__PURE__ */ make2((self, that) => self < that ? -1 : 1);
 
 // node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Option.js
 var none2 = () => none;
-var some2 = some;
+var some3 = some2;
 var isNone2 = isNone;
 var isSome2 = isSome;
 var match = /* @__PURE__ */ dual(2, (self, {
@@ -741,9 +882,9 @@ var match = /* @__PURE__ */ dual(2, (self, {
 }) => 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 fromNullable = (nullableValue) => nullableValue == null ? none2() : some3(nullableValue);
 var getOrUndefined = /* @__PURE__ */ getOrElse2(constUndefined);
-var map2 = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some2(f(self.value)));
+var map2 = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some3(f(self.value)));
 
 // node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/array.js
 var isNonEmptyArray = (self) => self.length > 0;
@@ -759,7 +900,7 @@ 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]);
+  return isOutOfBounds(i, self) ? none2() : some3(self[i]);
 });
 var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
   const i = Math.floor(index);
@@ -816,6 +957,7 @@ var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
   }
   return out;
 });
+var every2 = /* @__PURE__ */ dual(2, (self, refinement) => self.every(refinement));
 var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
   const input = fromIterable(self);
   if (isNonEmptyReadonlyArray(input)) {
@@ -1084,7 +1226,7 @@ function cachedBy(fa, type, lookupKey) {
 var option = (fa) => {
   const nano = Object.create(MatchProto);
   nano[args] = fa;
-  nano[contA] = (_) => succeed(some2(_));
+  nano[contA] = (_) => succeed(some3(_));
   nano[contE] = (_) => _ instanceof NanoDefectException ? fail(_) : succeed(none2());
   return nano;
 };
@@ -1095,7 +1237,7 @@ var ignore = (fa) => {
   nano[contE] = (_) => _ instanceof NanoDefectException ? fail(_) : void_;
   return nano;
 };
-var all = fn("all")(
+var all2 = fn("all")(
   function* (...args2) {
     const results = [];
     for (const fa of args2) {
@@ -1131,13 +1273,17 @@ function parsePackageContentNameAndVersionFromScope(v) {
     ...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
+    referencedPackages,
+    exportsKeys
   };
 }
 var resolveModulePattern = fn("resolveModulePattern")(
@@ -1337,7 +1483,7 @@ var findImportedModuleIdentifier = fn("AST.findImportedModuleIdentifier")(
       } else if (ts.isNamedImports(namedBindings)) {
         for (const importSpecifier of namedBindings.elements) {
           const importProperty = fromNullable(importSpecifier.propertyName).pipe(
-            orElse(() => some2(importSpecifier.name))
+            orElse(() => some3(importSpecifier.name))
           );
           if (yield* test(importSpecifier.name, statement.moduleSpecifier, importProperty)) {
             return importSpecifier.name;
@@ -1370,20 +1516,20 @@ var simplifyTypeNode = fn("AST.simplifyTypeNode")(function* (typeNode) {
   function collectCallable(typeNode2) {
     if (ts.isParenthesizedTypeNode(typeNode2)) return collectCallable(typeNode2.type);
     if (ts.isFunctionTypeNode(typeNode2)) {
-      return some2([
+      return some3([
         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 some3(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 some3(members.map((_) => isSome2(_) ? _.value : []).flat());
       }
     }
     return none2();
@@ -2299,7 +2445,7 @@ function make3(ts, typeChecker) {
     return invariantTypeArgument(propertyType);
   };
   const effectVarianceStruct = (type, atLocation) => map4(
-    all(
+    all2(
       varianceStructCovariantType(type, atLocation, "_A"),
       varianceStructCovariantType(type, atLocation, "_E"),
       varianceStructCovariantType(type, atLocation, "_R")
@@ -2307,7 +2453,7 @@ function make3(ts, typeChecker) {
     ([A, E, R]) => ({ A, E, R })
   );
   const layerVarianceStruct = (type, atLocation) => map4(
-    all(
+    all2(
       varianceStructContravariantType(type, atLocation, "_ROut"),
       varianceStructCovariantType(type, atLocation, "_E"),
       varianceStructCovariantType(type, atLocation, "_RIn")
@@ -2615,7 +2761,7 @@ function make3(ts, typeChecker) {
     (node) => node
   );
   const effectSchemaVarianceStruct = (type, atLocation) => map4(
-    all(
+    all2(
       varianceStructInvariantType(type, atLocation, "_A"),
       varianceStructInvariantType(type, atLocation, "_I"),
       varianceStructCovariantType(type, atLocation, "_R")
@@ -2647,7 +2793,7 @@ function make3(ts, typeChecker) {
     (type) => type
   );
   const contextTagVarianceStruct = (type, atLocation) => map4(
-    all(
+    all2(
       varianceStructInvariantType(type, atLocation, "_Identifier"),
       varianceStructInvariantType(type, atLocation, "_Service")
     ),
@@ -2713,6 +2859,47 @@ function make3(ts, typeChecker) {
     "TypeParser.scopeType",
     (type) => type
   );
+  const promiseLike = cachedBy(
+    function(type, atLocation) {
+      const thenProperty = type.getProperty("then");
+      if (!thenProperty) return typeParserIssue("not a promise - missing then property", type, atLocation);
+      const thenType = typeChecker.getTypeOfSymbolAtLocation(thenProperty, atLocation);
+      if (!thenType) return typeParserIssue("not a promise - missing then property", type, atLocation);
+      for (const callSignature of thenType.getCallSignatures()) {
+        const parameter = callSignature.parameters[0];
+        if (!parameter) continue;
+        const parameterType = callSignature.getTypeParameterAtPosition(0);
+        if (!parameterType) continue;
+        let callbackCallSignatures = [];
+        let toTest = [parameterType];
+        while (toTest.length > 0) {
+          const type2 = toTest.shift();
+          if (!type2) continue;
+          const callSignatures = type2.getCallSignatures();
+          callbackCallSignatures = callbackCallSignatures.concat(callSignatures);
+          if (type2.isUnion()) {
+            toTest = toTest.concat(type2.types);
+          }
+        }
+        for (const callableType of callbackCallSignatures) {
+          const callbackParameter = callableType.parameters[0];
+          if (!callbackParameter) {
+            continue;
+          }
+          const callbackParameterType = callableType.getTypeParameterAtPosition(0);
+          if (!callbackParameterType) {
+            continue;
+          }
+          return succeed({
+            type: callbackParameterType
+          });
+        }
+      }
+      return typeParserIssue("not a promise", type, atLocation);
+    },
+    "TypeParser.promiseLike",
+    (type) => type
+  );
   return {
     effectType,
     strictEffectType,
@@ -2728,7 +2915,8 @@ function make3(ts, typeChecker) {
     contextTag,
     pipeableType,
     pipeCall,
-    scopeType
+    scopeType,
+    promiseLike
   };
 }
 
@@ -2883,7 +3071,7 @@ var importFromBarrel = createDiagnostic({
     const typeChecker = yield* service(TypeCheckerApi);
     const program = yield* service(TypeScriptProgram);
     const packageNamesToCheck = flatten(
-      yield* all(
+      yield* all2(
         ...languageServicePluginOptions.namespaceImportPackages.map(
           (packageName) => resolveModulePattern(sourceFile, packageName)
         )
@@ -3135,7 +3323,7 @@ var missingEffectContext = createDiagnostic({
     const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
     const checkForMissingContextTypes = (node, expectedType, valueNode, realType) => pipe(
-      all(
+      all2(
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
@@ -3201,7 +3389,7 @@ var missingEffectError = createDiagnostic({
       [ts.factory.createStringLiteral(message)]
     );
     const checkForMissingErrorTypes = (node, expectedType, valueNode, realType) => pipe(
-      all(
+      all2(
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
@@ -4200,102 +4388,251 @@ var completions = [
   schemaBrand
 ];
 
-// src/completions/middlewareAutoImports.ts
-var importablePackagesMetadataCache = /* @__PURE__ */ new Map();
-var makeImportablePackagesMetadata = fn("makeImportablePackagesMetadata")(function* (sourceFile) {
+// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/encoding/common.js
+var encoder = /* @__PURE__ */ new TextEncoder();
+
+// node_modules/.pnpm/effect@3.16.12/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.16.12/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.16.12/node_modules/effect/dist/esm/Encoding.js
+var encodeBase64Url = (input) => typeof input === "string" ? encode2(encoder.encode(input)) : encode2(input);
+
+// src/core/AutoImport.ts
+var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
   const ts = yield* service(TypeScriptApi);
   const program = yield* service(TypeScriptProgram);
   const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
   const host = program;
-  const namespaceByFileName = /* @__PURE__ */ new Map();
-  const excludedByFileName = /* @__PURE__ */ new Map();
-  const unbarreledModulePathByFileName = /* @__PURE__ */ new Map();
-  const barreledModulePathByFileName = /* @__PURE__ */ new Map();
-  const barreledFunctionPathByFileName = /* @__PURE__ */ new Map();
-  const packages = [
-    ...languageServicePluginOptions.namespaceImportPackages.map((packagePattern) => ({
-      packagePattern,
-      kind: "namespace"
-    })),
-    ...languageServicePluginOptions.barrelImportPackages.map((packagePattern) => ({
-      packagePattern,
-      kind: "barrel"
-    }))
-  ];
-  for (const { kind, packagePattern } of packages) {
-    for (const packageName of yield* resolveModulePattern(sourceFile, packagePattern)) {
-      const barrelModule = ts.resolveModuleName(packageName, sourceFile.fileName, program.getCompilerOptions(), host);
-      if (barrelModule.resolvedModule) {
-        const barrelPath = barrelModule.resolvedModule.resolvedFileName;
-        const barrelSource = program.getSourceFile(barrelPath) || ts.createSourceFile(barrelPath, host.readFile(barrelPath) || "", sourceFile.languageVersion, true);
-        if (barrelSource) {
-          for (const statement of barrelSource.statements) {
-            if (ts.isExportDeclaration(statement)) {
-              const exportClause = statement.exportClause;
-              const moduleSpecifier = statement.moduleSpecifier;
-              if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
-                const unbarreledModulePathResolved = ts.resolveModuleName(
-                  moduleSpecifier.text,
-                  barrelSource.fileName,
-                  program.getCompilerOptions(),
-                  host
-                );
-                if (unbarreledModulePathResolved.resolvedModule) {
-                  const unbarreledModulePath = unbarreledModulePathResolved.resolvedModule.resolvedFileName;
-                  if (exportClause && ts.isNamespaceExport(exportClause) && ts.isIdentifier(exportClause.name)) {
-                    if (kind === "namespace") {
-                      namespaceByFileName.set(unbarreledModulePath, exportClause.name.text);
-                      const existingUnbarreledModulePath = unbarreledModulePathByFileName.get(barrelSource.fileName) || [];
-                      existingUnbarreledModulePath.push({
-                        fileName: unbarreledModulePath,
-                        exportName: exportClause.name.text
-                      });
-                      unbarreledModulePathByFileName.set(barrelSource.fileName, existingUnbarreledModulePath);
-                    }
-                    if (kind === "barrel") {
-                      barreledModulePathByFileName.set(unbarreledModulePath, {
-                        fileName: barrelSource.fileName,
-                        exportName: exportClause.name.text,
-                        packageName
-                      });
-                    }
-                  }
-                  if (exportClause && ts.isNamedExports(exportClause)) {
-                    for (const element of exportClause.elements) {
-                      if (!ts.isIdentifier(element.name)) continue;
-                      const methodName = element.name.text;
-                      if (kind === "namespace") {
-                        const excludedMethods = excludedByFileName.get(methodName) || [];
-                        excludedMethods.push(unbarreledModulePath);
-                        excludedByFileName.set(methodName, excludedMethods);
-                      }
-                      if (kind === "barrel") {
-                        const previousBarreledFunctionPath = barreledFunctionPathByFileName.get(unbarreledModulePath) || [];
-                        previousBarreledFunctionPath.push({
-                          fileName: barrelSource.fileName,
-                          exportName: methodName,
-                          packageName
-                        });
-                        barreledFunctionPathByFileName.set(unbarreledModulePath, previousBarreledFunctionPath);
-                      }
+  const getModuleSpecifier = makeGetModuleSpecifier(ts);
+  function collectSourceFileReexports(sourceFile) {
+    const namespaceExports = [];
+    const namedExports = [];
+    for (const statement of sourceFile.statements) {
+      if (!ts.isExportDeclaration(statement)) continue;
+      if (!statement.exportClause) continue;
+      const moduleSpecifier = statement.moduleSpecifier;
+      if (!moduleSpecifier) continue;
+      if (!ts.isStringLiteral(moduleSpecifier)) continue;
+      const exportClause = statement.exportClause;
+      if (ts.isNamespaceExport(exportClause)) {
+        if (!exportClause.name) continue;
+        if (!ts.isIdentifier(exportClause.name)) continue;
+        namespaceExports.push({
+          moduleSpecifier,
+          exportClause,
+          name: exportClause.name.text
+        });
+      }
+      if (ts.isNamedExports(exportClause)) {
+        for (const exportSpecifier of exportClause.elements) {
+          const exportName = exportSpecifier.propertyName || exportSpecifier.name;
+          if (!ts.isIdentifier(exportName)) continue;
+          if (!ts.isIdentifier(exportSpecifier.name)) continue;
+          namedExports.push({
+            moduleSpecifier,
+            exportClause,
+            name: exportName.text,
+            aliasName: exportSpecifier.name.text
+          });
+        }
+      }
+    }
+    return { namespaceExports, namedExports };
+  }
+  function getPackageInfo(fromFileName, packageName) {
+    try {
+      const packageJsonInfo = ts.resolvePackageNameToPackageJson(
+        packageName,
+        fromFileName,
+        program.getCompilerOptions(),
+        host
+      );
+      if (!packageJsonInfo) return;
+      const _entrypoints = ts.getEntrypointsFromPackageJsonInfo(
+        packageJsonInfo,
+        program.getCompilerOptions(),
+        host
+      );
+      if (!_entrypoints) return;
+      if (!isArray(_entrypoints)) return;
+      if (!every2(Predicate_exports.isString)) return;
+      const entrypoints = _entrypoints.map((_) => String(_));
+      const info = parsePackageContentNameAndVersionFromScope({ packageJsonScope: packageJsonInfo });
+      if (!info) return { entrypoints, exportedKeys: [] };
+      return { entrypoints, exportedKeys: info.exportsKeys };
+    } catch (_) {
+      return void 0;
+    }
+  }
+  const mapFromBarrelToNamespace = /* @__PURE__ */ new Map();
+  const mapFromNamespaceToBarrel = /* @__PURE__ */ new Map();
+  const mapFilenameToModuleAlias = /* @__PURE__ */ new Map();
+  const mapFilenameToExportExcludes = /* @__PURE__ */ new Map();
+  const mapFilenameToModuleName = /* @__PURE__ */ new Map();
+  const collectModuleNames = (packageName, exportedKey) => {
+    const appendPart = exportedKey === "." ? "" : exportedKey.startsWith("./") ? exportedKey.slice(1) : exportedKey;
+    const absoluteName = packageName + appendPart;
+    const absoluteFileName = ts.resolveModuleName(
+      absoluteName,
+      fromSourceFile.fileName,
+      program.getCompilerOptions(),
+      host
+    );
+    if (!absoluteFileName) return;
+    if (!absoluteFileName.resolvedModule) return;
+    const realPath = host.realpath ? host.realpath(absoluteFileName.resolvedModule.resolvedFileName) : absoluteFileName.resolvedModule.resolvedFileName;
+    if (mapFilenameToModuleName.has(realPath)) return;
+    mapFilenameToModuleName.set(realPath, absoluteName);
+  };
+  const collectImportCache = fn("TypeScriptApi")(
+    function* (packagePatterns, kind) {
+      for (const packagePattern of packagePatterns) {
+        const packageNames = yield* resolveModulePattern(fromSourceFile, packagePattern);
+        for (const packageName of packageNames) {
+          const packageInfo = getPackageInfo(fromSourceFile.fileName, packageName);
+          if (!packageInfo) continue;
+          for (const exportedKey of packageInfo.exportedKeys) {
+            collectModuleNames(packageName, exportedKey);
+          }
+          for (const _fileName of packageInfo.entrypoints) {
+            const realFileName = host.realpath ? host.realpath(_fileName) : _fileName;
+            const isPackageRoot = mapFilenameToModuleName.get(realFileName) === packageName;
+            const barrelSourceFile = program.getSourceFile(realFileName) || ts.createSourceFile(realFileName, host.readFile(realFileName) || "", fromSourceFile.languageVersion, true);
+            const reExports = collectSourceFileReexports(barrelSourceFile);
+            if (!reExports) continue;
+            if (reExports.namespaceExports.length === 0) continue;
+            for (const namespaceReexport of reExports.namespaceExports) {
+              const reexportedFile = ts.resolveModuleName(
+                namespaceReexport.moduleSpecifier.text,
+                barrelSourceFile.fileName,
+                program.getCompilerOptions(),
+                host
+              );
+              if (!reexportedFile) continue;
+              if (!reexportedFile.resolvedModule) continue;
+              switch (kind) {
+                case "namespace": {
+                  mapFromBarrelToNamespace.set(
+                    barrelSourceFile.fileName,
+                    {
+                      ...mapFromBarrelToNamespace.get(barrelSourceFile.fileName) || {},
+                      [namespaceReexport.name]: reexportedFile.resolvedModule.resolvedFileName
                     }
-                  }
+                  );
+                  mapFilenameToModuleAlias.set(
+                    reexportedFile.resolvedModule.resolvedFileName,
+                    namespaceReexport.name
+                  );
+                  continue;
                 }
+                case "barrel": {
+                  mapFromNamespaceToBarrel.set(reexportedFile.resolvedModule.resolvedFileName, {
+                    fileName: barrelSourceFile.fileName,
+                    alias: namespaceReexport.name
+                  });
+                }
+              }
+            }
+            if (isPackageRoot) {
+              for (const namedExport of reExports.namedExports) {
+                mapFilenameToExportExcludes.set(barrelSourceFile.fileName, [
+                  ...mapFilenameToExportExcludes.get(barrelSourceFile.fileName) || [],
+                  namedExport.name
+                ]);
+                break;
               }
             }
           }
         }
       }
     }
-  }
-  return {
-    getImportNamespaceByFileName: (fileName) => namespaceByFileName.get(fileName),
-    isExcludedFromNamespaceImport: (fileName, exportName) => (excludedByFileName.get(exportName) || []).includes(fileName),
-    getUnbarreledModulePath: (fileName, exportName) => unbarreledModulePathByFileName.get(fileName)?.find((_) => _.exportName === exportName)?.fileName,
-    getBarreledModulePath: (fileName) => barreledModulePathByFileName.get(fileName),
-    getBarreledFunctionPath: (fileName, exportName) => barreledFunctionPathByFileName.get(fileName)?.find((_) => _.exportName === exportName)
+  );
+  yield* collectImportCache(languageServicePluginOptions.namespaceImportPackages, "namespace");
+  yield* collectImportCache(languageServicePluginOptions.barrelImportPackages, "barrel");
+  const resolveModuleName = (fileName) => {
+    const fixedModuleName = mapFilenameToModuleName.get(fileName);
+    if (fixedModuleName) return fixedModuleName;
+    if (!getModuleSpecifier) return fileName;
+    const moduleSpecifier = getModuleSpecifier(
+      program.getCompilerOptions(),
+      fromSourceFile,
+      fromSourceFile.fileName,
+      fileName,
+      host
+    );
+    if (!moduleSpecifier) return fileName;
+    return moduleSpecifier;
+  };
+  return (exportFileName, exportName) => {
+    const excludedExports = mapFilenameToExportExcludes.get(exportFileName);
+    if (excludedExports && excludedExports.includes(exportName)) return;
+    const mapToNamespace = mapFromBarrelToNamespace.get(exportFileName);
+    if (mapToNamespace && exportName in mapToNamespace) {
+      const namespacedFileName = mapToNamespace[exportName];
+      if (namespacedFileName) {
+        const introducedAlias2 = mapFilenameToModuleAlias.get(namespacedFileName);
+        if (introducedAlias2) {
+          return {
+            _tag: "NamespaceImport",
+            fileName: namespacedFileName,
+            moduleName: resolveModuleName(namespacedFileName),
+            name: introducedAlias2,
+            introducedPrefix: void 0
+          };
+        }
+      }
+    }
+    const introducedAlias = mapFilenameToModuleAlias.get(exportFileName);
+    if (introducedAlias) {
+      return {
+        _tag: "NamespaceImport",
+        fileName: exportFileName,
+        moduleName: resolveModuleName(exportFileName),
+        name: introducedAlias,
+        introducedPrefix: introducedAlias
+      };
+    }
+    const mapToBarrel = mapFromNamespaceToBarrel.get(exportFileName);
+    if (mapToBarrel) {
+      return {
+        _tag: "NamedImport",
+        fileName: mapToBarrel.fileName,
+        moduleName: resolveModuleName(mapToBarrel.fileName),
+        name: mapToBarrel.alias,
+        introducedPrefix: mapToBarrel.alias
+      };
+    }
   };
 });
+
+// src/completions/middlewareAutoImports.ts
+var importProvidersCache = /* @__PURE__ */ new Map();
 var appendEffectCompletionEntryData = fn("appendEffectCompletionEntryData")(
   function* (_sourceFile, applicableCompletions) {
     const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
@@ -4349,8 +4686,9 @@ var isAutoImportOnlyCodeActions = fn("isAutoImportOnlyCodeActions")(
     }
   }
 );
-var getImportFromNamespaceCodeActions = fn("getImportFromNamespaceCodeActions")(function* (formatOptions, preferences, languageServiceHost, sourceFile, effectReplaceSpan, effectNamespaceName, effectUnbarreledModulePath, newModuleSpecifier) {
+var addImportCodeAction = fn("getImportFromNamespaceCodeActions")(function* (formatOptions, preferences, languageServiceHost, sourceFile, effectReplaceSpan, effectAutoImport) {
   const ts = yield* service(TypeScriptApi);
+  let description = "auto-import";
   const formatContext = ts.formatting.getFormatContext(
     formatOptions || {},
     languageServiceHost
@@ -4362,113 +4700,104 @@ var getImportFromNamespaceCodeActions = fn("getImportFromNamespaceCodeActions")(
       preferences: preferences || {}
     },
     (changeTracker) => {
-      ts.insertImports(
-        changeTracker,
-        sourceFile,
-        ts.factory.createImportDeclaration(
-          void 0,
-          ts.factory.createImportClause(
-            false,
-            void 0,
-            ts.factory.createNamespaceImport(ts.factory.createIdentifier(effectNamespaceName))
-          ),
-          ts.factory.createStringLiteral(newModuleSpecifier)
-        ),
-        true,
-        preferences || {}
-      );
-      if (!effectUnbarreledModulePath) {
+      if (effectAutoImport.introducedPrefix) {
         changeTracker.insertText(
           sourceFile,
           effectReplaceSpan.start,
-          effectNamespaceName + "."
+          effectAutoImport.introducedPrefix + "."
         );
       }
-    }
-  );
-  return [
-    {
-      description: "Import * as " + effectNamespaceName + " from " + newModuleSpecifier,
-      changes
-    }
-  ];
-});
-var getImportFromBarrelCodeActions = fn("getImportFromBarrelCodeActions")(function* (formatOptions, preferences, languageServiceHost, sourceFile, effectReplaceSpan, newModuleSpecifier, barrelExportName, shouldPrependExportName) {
-  const ts = yield* service(TypeScriptApi);
-  const formatContext = ts.formatting.getFormatContext(
-    formatOptions || {},
-    languageServiceHost
-  );
-  const changes = ts.textChanges.ChangeTracker.with(
-    {
-      formatContext,
-      host: languageServiceHost,
-      preferences: preferences || {}
-    },
-    (changeTracker) => {
-      let foundImportDeclaration = false;
-      for (const statement of sourceFile.statements) {
-        if (ts.isImportDeclaration(statement)) {
-          const moduleSpecifier = statement.moduleSpecifier;
-          if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier) && moduleSpecifier.text === newModuleSpecifier) {
-            const importClause = statement.importClause;
-            if (importClause && importClause.namedBindings && ts.isNamedImports(importClause.namedBindings)) {
-              const namedImports = importClause.namedBindings;
-              const existingImportSpecifier = namedImports.elements.find(
-                (element) => element.name.text.toLowerCase() === barrelExportName.toLowerCase()
-              );
-              if (existingImportSpecifier) {
-                foundImportDeclaration = true;
-                break;
+      switch (effectAutoImport._tag) {
+        case "NamespaceImport": {
+          const importModule = effectAutoImport.moduleName || effectAutoImport.fileName;
+          description = `Import * as ${effectAutoImport.name} from "${importModule}"`;
+          ts.insertImports(
+            changeTracker,
+            sourceFile,
+            ts.factory.createImportDeclaration(
+              void 0,
+              ts.factory.createImportClause(
+                false,
+                void 0,
+                ts.factory.createNamespaceImport(ts.factory.createIdentifier(effectAutoImport.name))
+              ),
+              ts.factory.createStringLiteral(importModule)
+            ),
+            true,
+            preferences || {}
+          );
+          break;
+        }
+        case "NamedImport": {
+          const importModule = effectAutoImport.moduleName || effectAutoImport.fileName;
+          description = `Import { ${effectAutoImport.name} } from "${importModule}"`;
+          let foundImportDeclaration = false;
+          for (const statement of sourceFile.statements) {
+            if (ts.isImportDeclaration(statement)) {
+              const moduleSpecifier = statement.moduleSpecifier;
+              if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier) && moduleSpecifier.text === importModule) {
+                const importClause = statement.importClause;
+                if (importClause && importClause.namedBindings && ts.isNamedImports(importClause.namedBindings)) {
+                  const namedImports = importClause.namedBindings;
+                  const existingImportSpecifier = namedImports.elements.find(
+                    (element) => element.name.text === effectAutoImport.name
+                  );
+                  if (existingImportSpecifier) {
+                    foundImportDeclaration = true;
+                    break;
+                  }
+                  changeTracker.replaceNode(
+                    sourceFile,
+                    namedImports,
+                    ts.factory.createNamedImports(
+                      namedImports.elements.concat([
+                        ts.factory.createImportSpecifier(
+                          false,
+                          void 0,
+                          ts.factory.createIdentifier(effectAutoImport.name)
+                        )
+                      ])
+                    )
+                  );
+                  foundImportDeclaration = true;
+                  break;
+                }
               }
-              changeTracker.replaceNode(
-                sourceFile,
-                namedImports,
-                ts.factory.createNamedImports(
-                  namedImports.elements.concat([
-                    ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier(barrelExportName))
-                  ])
-                )
-              );
-              foundImportDeclaration = true;
-              break;
             }
           }
+          if (!foundImportDeclaration) {
+            ts.insertImports(
+              changeTracker,
+              sourceFile,
+              ts.factory.createImportDeclaration(
+                void 0,
+                ts.factory.createImportClause(
+                  false,
+                  void 0,
+                  ts.factory.createNamedImports(
+                    [
+                      ts.factory.createImportSpecifier(
+                        false,
+                        void 0,
+                        ts.factory.createIdentifier(effectAutoImport.name)
+                      )
+                    ]
+                  )
+                ),
+                ts.factory.createStringLiteral(importModule)
+              ),
+              true,
+              preferences || {}
+            );
+          }
+          break;
         }
       }
-      if (!foundImportDeclaration) {
-        ts.insertImports(
-          changeTracker,
-          sourceFile,
-          ts.factory.createImportDeclaration(
-            void 0,
-            ts.factory.createImportClause(
-              false,
-              void 0,
-              ts.factory.createNamedImports(
-                [
-                  ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier(barrelExportName))
-                ]
-              )
-            ),
-            ts.factory.createStringLiteral(newModuleSpecifier)
-          ),
-          true,
-          preferences || {}
-        );
-      }
-      if (shouldPrependExportName) {
-        changeTracker.insertText(
-          sourceFile,
-          effectReplaceSpan.start,
-          barrelExportName + "."
-        );
-      }
     }
   );
   return [
     {
-      description: "Import { " + barrelExportName + " } from " + newModuleSpecifier,
+      description,
       changes
     }
   ];
@@ -4477,10 +4806,6 @@ var postprocessCompletionEntryDetails = fn("postprocessCompletionEntryDetails")(
   function* (sourceFile, data, applicableCompletionEntryDetails, formatOptions, preferences, languageServiceHost) {
     const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
     if (languageServicePluginOptions.namespaceImportPackages.length === 0 && languageServicePluginOptions.barrelImportPackages.length === 0) return applicableCompletionEntryDetails;
-    const ts = yield* service(TypeScriptApi);
-    const program = yield* service(TypeScriptProgram);
-    const getModuleSpecifier = makeGetModuleSpecifier(ts);
-    if (!getModuleSpecifier) return applicableCompletionEntryDetails;
     if (!applicableCompletionEntryDetails) return applicableCompletionEntryDetails;
     if (!data) return applicableCompletionEntryDetails;
     const { exportName, fileName, moduleSpecifier } = data;
@@ -4495,78 +4820,22 @@ var postprocessCompletionEntryDetails = fn("postprocessCompletionEntryDetails")(
       exportName
     );
     if (!result) return applicableCompletionEntryDetails;
-    const packagesMetadata = importablePackagesMetadataCache.get(sourceFile.fileName) || (yield* makeImportablePackagesMetadata(sourceFile));
-    importablePackagesMetadataCache.set(sourceFile.fileName, packagesMetadata);
-    const isExcluded = packagesMetadata.isExcludedFromNamespaceImport(
-      fileName,
-      exportName
-    );
-    if (isExcluded) return applicableCompletionEntryDetails;
-    const asBarrelFunctionImport = packagesMetadata.getBarreledFunctionPath(fileName, exportName);
-    if (asBarrelFunctionImport) {
-      const codeActions = yield* getImportFromBarrelCodeActions(
-        formatOptions,
-        preferences,
-        languageServiceHost,
-        sourceFile,
-        effectReplaceSpan,
-        asBarrelFunctionImport.packageName,
-        asBarrelFunctionImport.exportName,
-        false
-      );
-      return {
-        ...applicableCompletionEntryDetails,
-        codeActions
-      };
-    }
-    const asBarrelModuleImport = packagesMetadata.getBarreledModulePath(fileName);
-    if (asBarrelModuleImport) {
-      const codeActions = yield* getImportFromBarrelCodeActions(
-        formatOptions,
-        preferences,
-        languageServiceHost,
-        sourceFile,
-        effectReplaceSpan,
-        asBarrelModuleImport.packageName,
-        asBarrelModuleImport.exportName,
-        true
-      );
-      return {
-        ...applicableCompletionEntryDetails,
-        codeActions
-      };
-    }
-    const effectUnbarreledModulePath = packagesMetadata.getUnbarreledModulePath(
-      fileName,
-      exportName
-    );
-    const asNamespaceImport = packagesMetadata.getImportNamespaceByFileName(
-      effectUnbarreledModulePath || fileName
+    const packagesMetadata = importProvidersCache.get(sourceFile.fileName) || (yield* makeAutoImportProvider(sourceFile));
+    importProvidersCache.set(sourceFile.fileName, packagesMetadata);
+    const effectAutoImport = packagesMetadata(fileName, exportName);
+    if (!effectAutoImport) return applicableCompletionEntryDetails;
+    const codeActions = yield* addImportCodeAction(
+      formatOptions,
+      preferences,
+      languageServiceHost,
+      sourceFile,
+      effectReplaceSpan,
+      effectAutoImport
     );
-    if (asNamespaceImport) {
-      const newModuleSpecifier = effectUnbarreledModulePath ? getModuleSpecifier(
-        program.getCompilerOptions(),
-        sourceFile,
-        sourceFile.fileName,
-        String(effectUnbarreledModulePath || fileName),
-        program
-      ) : moduleSpecifier;
-      const codeActions = yield* getImportFromNamespaceCodeActions(
-        formatOptions,
-        preferences,
-        languageServiceHost,
-        sourceFile,
-        effectReplaceSpan,
-        asNamespaceImport,
-        effectUnbarreledModulePath,
-        newModuleSpecifier
-      );
-      return {
-        ...applicableCompletionEntryDetails,
-        codeActions
-      };
-    }
-    return applicableCompletionEntryDetails;
+    return {
+      ...applicableCompletionEntryDetails,
+      codeActions
+    };
   }
 );
 
@@ -4793,41 +5062,6 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
   );
 }
 
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/encoding/common.js
-var encoder = /* @__PURE__ */ new TextEncoder();
-
-// node_modules/.pnpm/effect@3.16.12/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.16.12/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.16.12/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;
@@ -9048,7 +9282,7 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
       const maybeLayer = yield* option(typeParser.layerType(type, node));
       if (isSome2(maybeLayer)) {
         const argNodes = yield* option(
-          all(...node.arguments.map((_) => processLayerGraphNode(ctx, _, void 0)))
+          all2(...node.arguments.map((_) => processLayerGraphNode(ctx, _, void 0)))
         );
         if (isSome2(argNodes) && argNodes.value.length === node.arguments.length) {
           const { allIndexes: outTypes } = yield* appendToUniqueTypesMap(
@@ -9092,7 +9326,7 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
             );
             if (ts.isCallExpression(node)) {
               const argNodes = yield* option(
-                all(...node.arguments.map((_) => processLayerGraphNode(ctx, _, void 0)))
+                all2(...node.arguments.map((_) => processLayerGraphNode(ctx, _, void 0)))
               );
               if (isSome2(argNodes) && argNodes.value.length === node.arguments.length) {
                 return new GraphNodeCompoundTransform(
@@ -9222,7 +9456,7 @@ function processNodeMermaid(graph, ctx, ctxL) {
         return subgraphDefs;
       }
       case "GraphNodeCompoundTransform": {
-        const childs = flatten(yield* all(...graph.args.map((_) => processNodeMermaid(_, ctx, ctxL))));
+        const childs = flatten(yield* all2(...graph.args.map((_) => processNodeMermaid(_, ctx, ctxL))));
         let currentEdges = [];
         const connectedNodes = /* @__PURE__ */ new Set();
         for (const requiredServiceKey of graph.rin) {
@@ -10007,7 +10241,7 @@ var pipeableToDatafirst = createRefactor({
       for (let i = 0; i < callSignatures.length; i++) {
         const callSignature = callSignatures[i];
         if (callSignature.parameters.length === node2.arguments.length + 1) {
-          return some2(
+          return some3(
             ts.factory.createCallExpression(
               node2.expression,
               [],
@@ -10049,7 +10283,7 @@ var pipeableToDatafirst = createRefactor({
             }
           }
         }
-        return didSomething ? some2([node2, newNode2]) : none2();
+        return didSomething ? some3([node2, newNode2]) : none2();
       }),
       filter(isSome2),
       map3((_) => _.value),
@@ -10377,17 +10611,17 @@ var makeSchemaGenContext = fn("SchemaGen.makeSchemaGenContext")(function* (sourc
           case "Pick":
           case "Omit":
           case "Record":
-            return some2(name.text);
+            return some3(name.text);
           case "ReadonlyArray":
           case "Array":
-            return some2("Array");
+            return some3("Array");
         }
         return none2();
       }
       if (!ts.isIdentifier(name.left)) return none2();
       for (const moduleName in moduleToImportedName) {
         if (name.left.text === moduleToImportedName[moduleName] && name.right.text === moduleName) {
-          return some2(moduleName);
+          return some3(moduleName);
         }
       }
       return none2();
@@ -10426,7 +10660,7 @@ var parseAllLiterals = fn(
       }
     }
     if (ts.isUnionTypeNode(node)) {
-      return flatten(yield* all(...node.types.map((_) => parseAllLiterals(_))));
+      return flatten(yield* all2(...node.types.map((_) => parseAllLiterals(_))));
     }
     if (ts.isParenthesizedTypeNode(node)) {
       return yield* parseAllLiterals(node.type);
@@ -10473,11 +10707,11 @@ var processNode = (node, isVirtualTypeNode) => gen(function* () {
   if (ts.isUnionTypeNode(node)) {
     const allLiterals = yield* option(parseAllLiterals(node));
     if (isSome2(allLiterals)) return createApiCall("Literal", allLiterals.value);
-    const members = yield* all(...node.types.map((_) => processNode(_, isVirtualTypeNode)));
+    const members = yield* all2(...node.types.map((_) => processNode(_, isVirtualTypeNode)));
     return createApiCall("Union", members);
   }
   if (ts.isIntersectionTypeNode(node)) {
-    const [firstSchema, ...otherSchemas] = yield* all(
+    const [firstSchema, ...otherSchemas] = yield* all2(
       ...node.types.map((_) => processNode(_, isVirtualTypeNode))
     );
     if (otherSchemas.length === 0) return firstSchema;
@@ -10533,13 +10767,13 @@ var processNode = (node, isVirtualTypeNode) => gen(function* () {
         case "Option":
         case "Chunk":
         case "Array": {
-          const elements = yield* all(
+          const elements = yield* all2(
             ...node.typeArguments ? node.typeArguments.map((_) => processNode(_, isVirtualTypeNode)) : []
           );
           return createApiCall(parsedName.value, elements);
         }
         case "Record": {
-          const elements = yield* all(
+          const elements = yield* all2(
             ...node.typeArguments ? node.typeArguments.map((_) => processNode(_, isVirtualTypeNode)) : []
           );
           if (elements.length >= 2) {
@@ -10553,7 +10787,7 @@ var processNode = (node, isVirtualTypeNode) => gen(function* () {
           return createUnsupportedNodeComment(ts, sourceFile, node);
         }
         case "Either": {
-          const elements = yield* all(
+          const elements = yield* all2(
             ...node.typeArguments ? node.typeArguments.map((_) => processNode(_, isVirtualTypeNode)) : []
           );
           if (elements.length >= 2) {
@@ -10891,6 +11125,273 @@ 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,
@@ -10908,7 +11409,8 @@ var refactors = [
   wrapWithEffectGen,
   wrapWithPipe,
   effectGenToFn,
-  togglePipeStyle
+  togglePipeStyle,
+  writeTagClassAccessors
 ];
 
 // src/index.ts
@@ -10956,8 +11458,7 @@ var init = (modules) => {
       );
     }
     const effectCodeFixesForFile = /* @__PURE__ */ new Map();
-    proxy.getSemanticDiagnostics = (fileName, ...args2) => {
-      const applicableDiagnostics = languageService.getSemanticDiagnostics(fileName, ...args2);
+    const runDiagnosticsAndCacheCodeFixes = (fileName) => {
       const program = languageService.getProgram();
       if (languageServicePluginOptions.diagnostics && program) {
         effectCodeFixesForFile.delete(fileName);
@@ -10968,13 +11469,17 @@ var init = (modules) => {
             runNano(program),
             map(({ codeFixes, diagnostics: diagnostics2 }) => {
               effectCodeFixesForFile.set(fileName, codeFixes);
-              return diagnostics2.concat(applicableDiagnostics);
+              return diagnostics2;
             }),
-            getOrElse(() => applicableDiagnostics)
+            getOrElse(() => [])
           );
         }
       }
-      return applicableDiagnostics;
+      return [];
+    };
+    proxy.getSemanticDiagnostics = (fileName, ...args2) => {
+      const applicableDiagnostics = languageService.getSemanticDiagnostics(fileName, ...args2);
+      return runDiagnosticsAndCacheCodeFixes(fileName).concat(applicableDiagnostics);
     };
     proxy.getSupportedCodeFixes = (...args2) => languageService.getSupportedCodeFixes(...args2).concat(
       diagnosticsErrorCodes.map((_) => "" + _)
@@ -10989,41 +11494,47 @@ var init = (modules) => {
         preferences,
         ...args2
       );
-      return pipe(
-        sync(() => {
-          const effectCodeFixes = [];
-          const applicableFixes = (effectCodeFixesForFile.get(fileName) || []).filter(
-            (_) => _.start === start && _.end === end && errorCodes.indexOf(_.code) > -1
-          );
-          const formatContext = modules.typescript.formatting.getFormatContext(
-            formatOptions,
-            info.languageServiceHost
-          );
-          for (const applicableFix of applicableFixes) {
-            const changes = modules.typescript.textChanges.ChangeTracker.with(
-              {
-                formatContext,
-                host: info.languageServiceHost,
-                preferences: preferences || {}
-              },
-              (changeTracker) => pipe(
-                applicableFix.apply,
-                provideService(ChangeTracker, changeTracker),
-                run
-              )
+      if (languageServicePluginOptions.diagnostics) {
+        return pipe(
+          sync(() => {
+            const effectCodeFixes = [];
+            if (!effectCodeFixesForFile.has(fileName)) {
+              runDiagnosticsAndCacheCodeFixes(fileName);
+            }
+            const applicableFixes = (effectCodeFixesForFile.get(fileName) || []).filter(
+              (_) => _.start === start && _.end === end && errorCodes.indexOf(_.code) > -1
             );
-            effectCodeFixes.push({
-              fixName: applicableFix.fixName,
-              description: applicableFix.description,
-              changes
-            });
-          }
-          return effectCodeFixes;
-        }),
-        run,
-        map((effectCodeFixes) => applicableCodeFixes.concat(effectCodeFixes)),
-        getOrElse(() => applicableCodeFixes)
-      );
+            const formatContext = modules.typescript.formatting.getFormatContext(
+              formatOptions,
+              info.languageServiceHost
+            );
+            for (const applicableFix of applicableFixes) {
+              const changes = modules.typescript.textChanges.ChangeTracker.with(
+                {
+                  formatContext,
+                  host: info.languageServiceHost,
+                  preferences: preferences || {}
+                },
+                (changeTracker) => pipe(
+                  applicableFix.apply,
+                  provideService(ChangeTracker, changeTracker),
+                  run
+                )
+              );
+              effectCodeFixes.push({
+                fixName: applicableFix.fixName,
+                description: applicableFix.description,
+                changes
+              });
+            }
+            return effectCodeFixes;
+          }),
+          run,
+          map((effectCodeFixes) => applicableCodeFixes.concat(effectCodeFixes)),
+          getOrElse(() => applicableCodeFixes)
+        );
+      }
+      return applicableCodeFixes;
     };
     proxy.getApplicableRefactors = (...args2) => {
       const applicableRefactors = languageService.getApplicableRefactors(...args2);