@effect/language-service 0.41.1 → 0.43.0

package/index.js

@@ -717,6 +717,9 @@ var isRight2 = isRight;
 var map = /* @__PURE__ */ dual(2, (self, f) => isRight2(self) ? right2(f(self.right)) : left2(self.left));
 var getOrElse = /* @__PURE__ */ dual(2, (self, onLeft) => isLeft2(self) ? onLeft(self.left) : self.right);
 
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/internal/array.js
+var isNonEmptyArray = (self) => self.length > 0;
+
 // node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/Order.js
 var make2 = (compare) => (self, that) => self === that ? 0 : compare(self, that);
 var string2 = /* @__PURE__ */ make2((self, that) => self < that ? -1 : 1);
@@ -732,6 +735,116 @@ var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nu
 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.8/node_modules/effect/dist/esm/Record.js
+var map3 = /* @__PURE__ */ dual(2, (self, f) => {
+  const out = {
+    ...self
+  };
+  for (const key of keys(self)) {
+    out[key] = f(self[key], key);
+  }
+  return out;
+});
+var keys = (self) => Object.keys(self);
+
+// node_modules/.pnpm/effect@3.17.8/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 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 partition = /* @__PURE__ */ dual(2, (self, predicate) => {
+  const left3 = [];
+  const right3 = [];
+  const as = fromIterable(self);
+  for (let i = 0; i < as.length; i++) {
+    if (predicate(as[i], i)) {
+      right3.push(as[i]);
+    } else {
+      left3.push(as[i]);
+    }
+  }
+  return [left3, right3];
+});
+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) {
@@ -903,13 +1016,13 @@ var OnSuccessProto = {
     return this[args];
   }
 };
-var flatMap = dual(2, (fa, f) => {
+var flatMap2 = dual(2, (fa, f) => {
   const nano = Object.create(OnSuccessProto);
   nano[args] = fa;
   nano[contA] = f;
   return nano;
 });
-var map3 = dual(2, (fa, f) => flatMap(fa, (_) => succeed(f(_))));
+var map5 = dual(2, (fa, f) => flatMap2(fa, (_) => succeed(f(_))));
 var SyncProto = {
   ...PrimitiveProto,
   [evaluate](fiber) {
@@ -1060,6 +1173,78 @@ var all = fn("all")(
   }
 );
 
+// src/core/LanguageServicePluginOptions.ts
+var LanguageServicePluginOptions = Tag("PluginOptions");
+function parseDiagnosticSeverity(config) {
+  if (!isRecord(config)) return {};
+  return Object.fromEntries(
+    pipe(
+      Object.entries(config),
+      filter(([key, value]) => isString(key) && isString(value)),
+      map4(([key, value]) => [String(key).toLowerCase(), String(value).toLowerCase()]),
+      filter(
+        ([_, value]) => value === "off" || value === "error" || value === "warning" || value === "message" || value === "suggestion"
+      )
+    )
+  );
+}
+var defaults = {
+  refactors: true,
+  diagnostics: true,
+  diagnosticSeverity: {},
+  quickinfo: true,
+  quickinfoEffectParameters: "whentruncated",
+  quickinfoMaximumLength: -1,
+  completions: true,
+  goto: true,
+  inlays: true,
+  allowedDuplicatedPackages: [],
+  namespaceImportPackages: [],
+  topLevelNamedReexports: "ignore",
+  barrelImportPackages: [],
+  importAliases: {},
+  renames: true,
+  noExternal: false,
+  keyPatterns: [{
+    target: "service",
+    pattern: "default",
+    skipLeadingPath: ["src/"]
+  }]
+};
+function parseKeyPatterns(patterns) {
+  const result = [];
+  for (const entry of patterns) {
+    if (!isObject(entry)) continue;
+    result.push({
+      target: hasProperty(entry, "target") && isString(entry.target) && ["service", "error"].includes(entry.target.toLowerCase()) ? entry.target.toLowerCase() : "service",
+      pattern: hasProperty(entry, "pattern") && isString(entry.pattern) && ["package-identifier", "default"].includes(entry.pattern.toLowerCase()) ? entry.pattern.toLowerCase() : "default",
+      skipLeadingPath: hasProperty(entry, "skipLeadingPath") && isArray(entry.skipLeadingPath) && entry.skipLeadingPath.every(isString) ? entry.skipLeadingPath : ["src/"]
+    });
+  }
+  return result;
+}
+function parse(config) {
+  return {
+    refactors: isObject(config) && hasProperty(config, "refactors") && isBoolean(config.refactors) ? config.refactors : defaults.refactors,
+    diagnostics: isObject(config) && hasProperty(config, "diagnostics") && isBoolean(config.diagnostics) ? config.diagnostics : defaults.diagnostics,
+    diagnosticSeverity: isObject(config) && hasProperty(config, "diagnosticSeverity") && isRecord(config.diagnosticSeverity) ? parseDiagnosticSeverity(config.diagnosticSeverity) : defaults.diagnosticSeverity,
+    quickinfo: isObject(config) && hasProperty(config, "quickinfo") && isBoolean(config.quickinfo) ? config.quickinfo : defaults.quickinfo,
+    quickinfoEffectParameters: isObject(config) && hasProperty(config, "quickinfoEffectParameters") && isString(config.quickinfoEffectParameters) && ["always", "never", "whentruncated"].includes(config.quickinfoEffectParameters.toLowerCase()) ? config.quickinfoEffectParameters.toLowerCase() : defaults.quickinfoEffectParameters,
+    quickinfoMaximumLength: isObject(config) && hasProperty(config, "quickinfoMaximumLength") && isNumber(config.quickinfoMaximumLength) ? config.quickinfoMaximumLength : defaults.quickinfoMaximumLength,
+    completions: isObject(config) && hasProperty(config, "completions") && isBoolean(config.completions) ? config.completions : defaults.completions,
+    goto: isObject(config) && hasProperty(config, "goto") && isBoolean(config.goto) ? config.goto : defaults.goto,
+    inlays: isObject(config) && hasProperty(config, "inlays") && isBoolean(config.inlays) ? config.inlays : defaults.inlays,
+    allowedDuplicatedPackages: isObject(config) && hasProperty(config, "allowedDuplicatedPackages") && isArray(config.allowedDuplicatedPackages) && config.allowedDuplicatedPackages.every(isString) ? config.allowedDuplicatedPackages.map((_) => _.toLowerCase()) : defaults.allowedDuplicatedPackages,
+    namespaceImportPackages: isObject(config) && hasProperty(config, "namespaceImportPackages") && isArray(config.namespaceImportPackages) && config.namespaceImportPackages.every(isString) ? config.namespaceImportPackages.map((_) => _.toLowerCase()) : defaults.namespaceImportPackages,
+    barrelImportPackages: isObject(config) && hasProperty(config, "barrelImportPackages") && isArray(config.barrelImportPackages) && config.barrelImportPackages.every(isString) ? config.barrelImportPackages.map((_) => _.toLowerCase()) : defaults.barrelImportPackages,
+    importAliases: isObject(config) && hasProperty(config, "importAliases") && isRecord(config.importAliases) ? map3(config.importAliases, (value) => String(value)) : defaults.importAliases,
+    topLevelNamedReexports: isObject(config) && hasProperty(config, "topLevelNamedReexports") && isString(config.topLevelNamedReexports) && ["ignore", "follow"].includes(config.topLevelNamedReexports.toLowerCase()) ? config.topLevelNamedReexports.toLowerCase() : defaults.topLevelNamedReexports,
+    renames: isObject(config) && hasProperty(config, "renames") && isBoolean(config.renames) ? config.renames : defaults.renames,
+    noExternal: isObject(config) && hasProperty(config, "noExternal") && isBoolean(config.noExternal) ? config.noExternal : defaults.noExternal,
+    keyPatterns: isObject(config) && hasProperty(config, "keyPatterns") && isArray(config.keyPatterns) ? parseKeyPatterns(config.keyPatterns) : defaults.keyPatterns
+  };
+}
+
 // src/core/TypeScriptApi.ts
 var TypeScriptApi = Tag("TypeScriptApi");
 var TypeScriptProgram = Tag("TypeScriptProgram");
@@ -1127,124 +1312,11 @@ function makeGetEntrypointsFromPackageJsonInfo(ts) {
   }
 }
 
-// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/internal/array.js
-var isNonEmptyArray = (self) => self.length > 0;
-
-// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/Record.js
-var map4 = /* @__PURE__ */ dual(2, (self, f) => {
-  const out = {
-    ...self
-  };
-  for (const key of keys(self)) {
-    out[key] = f(self[key], key);
-  }
-  return out;
-});
-var keys = (self) => Object.keys(self);
-
-// node_modules/.pnpm/effect@3.17.8/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 map5 = /* @__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 partition = /* @__PURE__ */ dual(2, (self, predicate) => {
-  const left3 = [];
-  const right3 = [];
-  const as = fromIterable(self);
-  for (let i = 0; i < as.length; i++) {
-    if (predicate(as[i], i)) {
-      right3.push(as[i]);
-    } else {
-      left3.push(as[i]);
-    }
-  }
-  return [left3, right3];
-});
-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))))
+  flatMap2((ts) => pipe(fa, provideService(TypeScriptUtils, makeTypeScriptUtils(ts))))
 );
 function makeTypeScriptUtils(ts) {
   const getTemporaryModuleResolutionState = makeGetTemporaryModuleResolutionState(ts);
@@ -1314,7 +1386,7 @@ function makeTypeScriptUtils(ts) {
     return pipe(
       referencedPackages.concat(packageJsonScope?.referencedPackages || []),
       dedupe,
-      map5((packageName) => packageName.toLowerCase()),
+      map4((packageName) => packageName.toLowerCase()),
       filter(
         (packageName) => pattern.endsWith("*") && packageName.startsWith(pattern.toLowerCase().substring(0, pattern.length - 1))
       )
@@ -1728,57 +1800,64 @@ function makeTypeScriptUtils(ts) {
   };
 }
 
-// src/core/LanguageServicePluginOptions.ts
-var LanguageServicePluginOptions = Tag("PluginOptions");
-function parseDiagnosticSeverity(config) {
-  if (!isRecord(config)) return {};
-  return Object.fromEntries(
-    pipe(
-      Object.entries(config),
-      filter(([key, value]) => isString(key) && isString(value)),
-      map5(([key, value]) => [String(key).toLowerCase(), String(value).toLowerCase()]),
-      filter(
-        ([_, value]) => value === "off" || value === "error" || value === "warning" || value === "message" || value === "suggestion"
-      )
-    )
+// src/core/KeyBuilder.ts
+var makeKeyBuilder = fn("KeyBuilder")(
+  function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const program = yield* service(TypeScriptProgram);
+    const options = yield* service(LanguageServicePluginOptions);
+    const packageInfo = tsUtils.resolveModuleWithPackageInfoFromSourceFile(program, sourceFile);
+    function createString2(classNameText, kind) {
+      if (!packageInfo) return;
+      for (const keyPattern of options.keyPatterns) {
+        if (keyPattern.target !== kind) continue;
+        if (keyPattern.pattern === "package-identifier") {
+          return packageInfo.name + "/" + classNameText;
+        }
+        const dirPath = getDirectoryPath(ts, sourceFile.fileName);
+        if (!dirPath.startsWith(packageInfo.packageDirectory)) return;
+        let subDirectory = dirPath.slice(packageInfo.packageDirectory.length);
+        if (subDirectory.startsWith("/")) subDirectory = subDirectory.slice(1);
+        const lastIndex = sourceFile.fileName.lastIndexOf("/");
+        let subModule = lastIndex === -1 ? "" : sourceFile.fileName.slice(lastIndex + 1);
+        for (const extension of [".ts", ".tsx", ".js", ".jsx"]) {
+          if (subModule.toLowerCase().endsWith(extension)) {
+            subModule = subModule.slice(0, -extension.length);
+            break;
+          }
+        }
+        if (subModule.toLowerCase().endsWith("/index")) subModule = subModule.slice(0, -6);
+        if (subModule.startsWith("/")) subModule = subModule.slice(1);
+        for (const prefix of keyPattern.skipLeadingPath) {
+          if (subDirectory.startsWith(prefix)) {
+            subDirectory = subDirectory.slice(prefix.length);
+            break;
+          }
+        }
+        const parts = [packageInfo.name, subDirectory, subModule].concat(
+          subModule.toLowerCase() === classNameText.toLowerCase() ? [] : [classNameText]
+        );
+        return parts.filter((_) => String(_).trim().length > 0).join("/");
+      }
+    }
+    return {
+      createString: createString2
+    };
+  }
+);
+var keyBuilderCache = /* @__PURE__ */ new Map();
+var getOrMakeKeyBuilder = fn("getOrMakeKeyBuilder")(function* (sourceFile) {
+  const keyBuilder = keyBuilderCache.get(sourceFile.fileName) || (yield* makeKeyBuilder(sourceFile));
+  keyBuilderCache.set(sourceFile.fileName, keyBuilder);
+  return keyBuilder;
+});
+function createString(sourceFile, identifier, kind) {
+  return map5(
+    getOrMakeKeyBuilder(sourceFile),
+    (identifierBuilder) => identifierBuilder.createString(identifier, kind)
   );
 }
-var defaults = {
-  refactors: true,
-  diagnostics: true,
-  diagnosticSeverity: {},
-  quickinfo: true,
-  quickinfoEffectParameters: "whentruncated",
-  completions: true,
-  goto: true,
-  inlays: true,
-  allowedDuplicatedPackages: [],
-  namespaceImportPackages: [],
-  topLevelNamedReexports: "ignore",
-  barrelImportPackages: [],
-  importAliases: {},
-  renames: true,
-  noExternal: false
-};
-function parse(config) {
-  return {
-    refactors: isObject(config) && hasProperty(config, "refactors") && isBoolean(config.refactors) ? config.refactors : defaults.refactors,
-    diagnostics: isObject(config) && hasProperty(config, "diagnostics") && isBoolean(config.diagnostics) ? config.diagnostics : defaults.diagnostics,
-    diagnosticSeverity: isObject(config) && hasProperty(config, "diagnosticSeverity") && isRecord(config.diagnosticSeverity) ? parseDiagnosticSeverity(config.diagnosticSeverity) : defaults.diagnosticSeverity,
-    quickinfo: isObject(config) && hasProperty(config, "quickinfo") && isBoolean(config.quickinfo) ? config.quickinfo : defaults.quickinfo,
-    quickinfoEffectParameters: isObject(config) && hasProperty(config, "quickinfoEffectParameters") && isString(config.quickinfoEffectParameters) && ["always", "never", "whentruncated"].includes(config.quickinfoEffectParameters.toLowerCase()) ? config.quickinfoEffectParameters.toLowerCase() : defaults.quickinfoEffectParameters,
-    completions: isObject(config) && hasProperty(config, "completions") && isBoolean(config.completions) ? config.completions : defaults.completions,
-    goto: isObject(config) && hasProperty(config, "goto") && isBoolean(config.goto) ? config.goto : defaults.goto,
-    inlays: isObject(config) && hasProperty(config, "inlays") && isBoolean(config.inlays) ? config.inlays : defaults.inlays,
-    allowedDuplicatedPackages: isObject(config) && hasProperty(config, "allowedDuplicatedPackages") && isArray(config.allowedDuplicatedPackages) && config.allowedDuplicatedPackages.every(isString) ? config.allowedDuplicatedPackages.map((_) => _.toLowerCase()) : defaults.allowedDuplicatedPackages,
-    namespaceImportPackages: isObject(config) && hasProperty(config, "namespaceImportPackages") && isArray(config.namespaceImportPackages) && config.namespaceImportPackages.every(isString) ? config.namespaceImportPackages.map((_) => _.toLowerCase()) : defaults.namespaceImportPackages,
-    barrelImportPackages: isObject(config) && hasProperty(config, "barrelImportPackages") && isArray(config.barrelImportPackages) && config.barrelImportPackages.every(isString) ? config.barrelImportPackages.map((_) => _.toLowerCase()) : defaults.barrelImportPackages,
-    importAliases: isObject(config) && hasProperty(config, "importAliases") && isRecord(config.importAliases) ? map4(config.importAliases, (value) => String(value)) : defaults.importAliases,
-    topLevelNamedReexports: isObject(config) && hasProperty(config, "topLevelNamedReexports") && isString(config.topLevelNamedReexports) && ["ignore", "follow"].includes(config.topLevelNamedReexports.toLowerCase()) ? config.topLevelNamedReexports.toLowerCase() : defaults.topLevelNamedReexports,
-    renames: isObject(config) && hasProperty(config, "renames") && isBoolean(config.renames) ? config.renames : defaults.renames,
-    noExternal: isObject(config) && hasProperty(config, "noExternal") && isBoolean(config.noExternal) ? config.noExternal : defaults.noExternal
-  };
-}
 
 // src/core/LSP.ts
 var RefactorNotApplicableError = class {
@@ -1830,7 +1909,7 @@ var getApplicableRefactors = fn("LSP.getApplicableRefactors")(function* (refacto
   for (const refactor of refactors2) {
     yield* pipe(
       refactor.apply(sourceFile, textRange),
-      map3(
+      map5(
         (result) => effectRefactors.push({
           name: refactorNameToFullyQualifiedName(refactor.name),
           description: refactor.description,
@@ -1940,7 +2019,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       const fixByDisableNextLine = (node) => ({
         fixName: rule.name + "_skipNextLine",
         description: "Disable " + rule.name + " for this line",
-        apply: flatMap(
+        apply: flatMap2(
           service(ChangeTracker),
           (changeTracker) => gen(function* () {
             const disableAtNode = findParentStatementForDisableNextLine(node);
@@ -1958,7 +2037,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       const fixByDisableEntireFile = {
         fixName: rule.name + "_skipFile",
         description: "Disable " + rule.name + " for this entire file",
-        apply: flatMap(
+        apply: flatMap2(
           service(ChangeTracker),
           (changeTracker) => sync(
             () => changeTracker.insertText(
@@ -2077,7 +2156,7 @@ var getEditsForCodegen = fn("LSP.getEditsForCodegen")(function* (codegens2, sour
   const edit = yield* codegen.apply(sourceFile, range);
   const updateHashComment = pipe(
     service(ChangeTracker),
-    map3((changeTracker) => {
+    map5((changeTracker) => {
       changeTracker.deleteRange(sourceFile, range);
       changeTracker.insertText(sourceFile, range.pos, `${codegen.name}:${edit.hash}`);
     })
@@ -2086,7 +2165,7 @@ var getEditsForCodegen = fn("LSP.getEditsForCodegen")(function* (codegens2, sour
     ...edit,
     apply: pipe(
       edit.apply,
-      flatMap(() => updateHashComment)
+      flatMap2(() => updateHashComment)
     ),
     ignore: updateHashComment
   };
@@ -2111,10 +2190,11 @@ var contextSelfInClasses = createCompletion({
     ) || "Context";
     if (contextIdentifier !== ts.idText(accessedObject)) return [];
     const name = ts.idText(className);
+    const tagKey = (yield* createString(sourceFile, name, "service")) || name;
     return [{
       name: `Tag("${name}")`,
       kind: ts.ScriptElementKind.constElement,
-      insertText: `${contextIdentifier}.Tag("${name}")<${name}, ${"${0}"}>(){}`,
+      insertText: `${contextIdentifier}.Tag("${tagKey}")<${name}, ${"${0}"}>(){}`,
       replacementSpan,
       isSnippet: true
     }];
@@ -2137,8 +2217,8 @@ function makeResolveExternalModuleName(typeChecker) {
 var TypeCheckerUtils = Tag("TypeCheckerUtils");
 var nanoLayer2 = (fa) => pipe(
   service(TypeScriptApi),
-  flatMap(
-    (ts) => flatMap(service(TypeCheckerApi), (typeChecker) => pipe(fa, provideService(TypeCheckerUtils, makeTypeCheckerUtils(ts, typeChecker))))
+  flatMap2(
+    (ts) => flatMap2(service(TypeCheckerApi), (typeChecker) => pipe(fa, provideService(TypeCheckerUtils, makeTypeCheckerUtils(ts, typeChecker))))
   )
 );
 function makeTypeCheckerUtils(ts, typeChecker) {
@@ -2517,7 +2597,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
     const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
     return invariantTypeArgument(propertyType);
   };
-  const effectVarianceStruct = (type, atLocation) => map3(
+  const effectVarianceStruct = (type, atLocation) => map5(
     all(
       varianceStructCovariantType(type, atLocation, "_A"),
       varianceStructCovariantType(type, atLocation, "_E"),
@@ -2525,7 +2605,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
     ),
     ([A, E, R]) => ({ A, E, R })
   );
-  const layerVarianceStruct = (type, atLocation) => map3(
+  const layerVarianceStruct = (type, atLocation) => map5(
     all(
       varianceStructContravariantType(type, atLocation, "_ROut"),
       varianceStructCovariantType(type, atLocation, "_E"),
@@ -2748,7 +2828,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
       }
       return pipe(
         importedEffectModule(propertyAccess.expression),
-        map3((effectModule) => ({
+        map5((effectModule) => ({
           node,
           effectModule,
           generatorFunction,
@@ -2795,7 +2875,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
       }
       return pipe(
         importedEffectModule(propertyAccess.expression),
-        map3((effectModule) => ({
+        map5((effectModule) => ({
           node,
           effectModule,
           generatorFunction,
@@ -2847,7 +2927,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
       }
       return pipe(
         importedEffectModule(propertyAccess.expression),
-        map3((effectModule) => ({
+        map5((effectModule) => ({
           node,
           generatorFunction,
           effectModule,
@@ -2920,7 +3000,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.unnecessaryEffectGen",
     (node) => node
   );
-  const effectSchemaVarianceStruct = (type, atLocation) => map3(
+  const effectSchemaVarianceStruct = (type, atLocation) => map5(
     all(
       varianceStructInvariantType(type, atLocation, "_A"),
       varianceStructInvariantType(type, atLocation, "_I"),
@@ -2952,7 +3032,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.effectSchemaType",
     (type) => type
   );
-  const contextTagVarianceStruct = (type, atLocation) => map3(
+  const contextTagVarianceStruct = (type, atLocation) => map5(
     all(
       varianceStructInvariantType(type, atLocation, "_Identifier"),
       varianceStructInvariantType(type, atLocation, "_Service")
@@ -3084,7 +3164,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
                   const expressionType = typeChecker.getTypeAtLocation(expression);
                   const parsedSchemaModule = yield* pipe(
                     effectSchemaType(expressionType, expression),
-                    flatMap(() => importedSchemaModule(schemaIdentifier.expression)),
+                    flatMap2(() => importedSchemaModule(schemaIdentifier.expression)),
                     option
                   );
                   if (isSome2(parsedSchemaModule)) {
@@ -3127,7 +3207,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
                   const expressionType = typeChecker.getTypeAtLocation(expression);
                   const parsedSchemaModule = yield* pipe(
                     effectSchemaType(expressionType, expression),
-                    flatMap(() => importedSchemaModule(schemaIdentifier.expression)),
+                    flatMap2(() => importedSchemaModule(schemaIdentifier.expression)),
                     option
                   );
                   if (isSome2(parsedSchemaModule)) {
@@ -3172,7 +3252,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
                   const expressionType = typeChecker.getTypeAtLocation(expression);
                   const parsedSchemaModule = yield* pipe(
                     effectSchemaType(expressionType, expression),
-                    flatMap(() => importedSchemaModule(schemaIdentifier.expression)),
+                    flatMap2(() => importedSchemaModule(schemaIdentifier.expression)),
                     option
                   );
                   if (isSome2(parsedSchemaModule)) {
@@ -3293,7 +3373,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
                   const expressionType = typeChecker.getTypeAtLocation(expression);
                   const parsedSchemaModule = yield* pipe(
                     effectSchemaType(expressionType, expression),
-                    flatMap(() => importedSchemaModule(schemaIdentifier.expression)),
+                    flatMap2(() => importedSchemaModule(schemaIdentifier.expression)),
                     option
                   );
                   if (isSome2(parsedSchemaModule)) {
@@ -3437,7 +3517,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
                   const type = typeChecker.getTypeOfSymbol(classSym);
                   const parsedContextTag = yield* pipe(
                     importedEffectModule(effectServiceIdentifier.expression),
-                    flatMap(() => contextTag(type, atLocation)),
+                    flatMap2(() => contextTag(type, atLocation)),
                     option
                   );
                   if (isSome2(parsedContextTag)) {
@@ -3580,7 +3660,7 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
   };
   const generateReturnType = (type, atLocation2, className2) => pipe(
     typeParser.effectType(type, atLocation2),
-    flatMap((returnedEffect) => {
+    flatMap2((returnedEffect) => {
       const contextType = returnedEffect.R.flags & ts.TypeFlags.Never ? ts.factory.createTypeReferenceNode(ts.idText(className2)) : ts.factory.createUnionTypeNode(
         [
           ts.factory.createTypeReferenceNode(ts.idText(className2)),
@@ -3611,7 +3691,7 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
     orElse2(
       () => pipe(
         typeParser.promiseLike(type, atLocation2),
-        flatMap(({ type: type2 }) => {
+        flatMap2(({ type: type2 }) => {
           const successType = typeChecker.typeToTypeNode(
             type2,
             atLocation2,
@@ -3679,7 +3759,7 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
     for (const signature of typeChecker.getSignaturesOfType(propertyType, ts.SignatureKind.Call)) {
       yield* pipe(
         proxySignature(signature, atLocation, className),
-        map3((sig) => {
+        map5((sig) => {
           callSignatures.push(sig);
         }),
         ignore
@@ -3712,7 +3792,7 @@ var parse2 = fn("writeTagClassAccessors.parse")(function* (node) {
   if (!ts.isClassDeclaration(node)) return yield* fail("not a class declaration");
   const { Service, accessors: accessors2, className } = yield* pipe(
     typeParser.extendsEffectService(node),
-    orElse2(() => map3(typeParser.extendsEffectTag(node), (_) => ({ accessors: true, ..._ }))),
+    orElse2(() => map5(typeParser.extendsEffectTag(node), (_) => ({ accessors: true, ..._ }))),
     orElse2(() => fail("not a class extending Effect.Service call"))
   );
   if (accessors2 !== true) return yield* fail("accessors are not enabled in the Effect.Service call");
@@ -3746,7 +3826,7 @@ var writeTagClassAccessors = createRefactor({
     const typeParser = yield* service(TypeParser);
     const parseNode = (node) => pipe(
       parse2(node),
-      map3(({ Service, atLocation, className, involvedMembers }) => ({
+      map5(({ Service, atLocation, className, involvedMembers }) => ({
         kind: "refactor.rewrite.effect.writeTagClassAccessors",
         description: "Implement Service accessors",
         apply: pipe(
@@ -3779,7 +3859,7 @@ var accessors = createCodegen({
     if (!nodeAndCommentRange) return yield* fail(new CodegenNotApplicableError("no node and comment range"));
     return yield* pipe(
       parse2(nodeAndCommentRange.node),
-      map3(
+      map5(
         (_) => ({
           hash: _.hash,
           description: "Generate accessors for the service",
@@ -3844,10 +3924,11 @@ var effectDataClasses = createCompletion({
     ) || "Data";
     if (effectDataIdentifier !== ts.idText(accessedObject)) return [];
     const name = ts.idText(className);
+    const errorTagKey = (yield* createString(sourceFile, name, "error")) || name;
     return [{
       name: `TaggedError("${name}")`,
       kind: ts.ScriptElementKind.constElement,
-      insertText: `${effectDataIdentifier}.TaggedError("${name}")<{${"${0}"}}>{}`,
+      insertText: `${effectDataIdentifier}.TaggedError("${errorTagKey}")<{${"${0}"}}>{}`,
       replacementSpan,
       isSnippet: true
     }, {
@@ -3959,6 +4040,67 @@ var classSelfMismatch = createDiagnostic({
   })
 });
 
+// src/diagnostics/deterministicKeys.ts
+var deterministicKeys = createDiagnostic({
+  name: "deterministicKeys",
+  code: 25,
+  severity: "off",
+  apply: fn("deterministicKeys.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(
+          pipe(
+            typeParser.extendsEffectService(node),
+            orElse2(() => typeParser.extendsContextTag(node)),
+            orElse2(() => typeParser.extendsEffectTag(node)),
+            map5(({ className, keyStringLiteral }) => ({ keyStringLiteral, className, target: "service" }))
+          ),
+          orElse2(
+            () => pipe(
+              typeParser.extendsDataTaggedError(node),
+              orElse2(() => typeParser.extendsSchemaTaggedError(node)),
+              map5(({ className, keyStringLiteral }) => ({ keyStringLiteral, className, target: "error" }))
+            )
+          ),
+          orElse2(() => void_)
+        );
+        if (result && result.keyStringLiteral) {
+          const { className, keyStringLiteral } = result;
+          const classNameText = ts.idText(className);
+          const expectedKey = yield* createString(sourceFile, classNameText, result.target);
+          if (!expectedKey) return;
+          const actualIdentifier = keyStringLiteral.text;
+          if (actualIdentifier !== expectedKey) {
+            report({
+              location: keyStringLiteral,
+              messageText: `Key should be '${expectedKey}'`,
+              fixes: [{
+                fixName: "deterministicKeys_fix",
+                description: `Replace '${actualIdentifier}' with '${expectedKey}'`,
+                apply: gen(function* () {
+                  const changeTracker = yield* service(ChangeTracker);
+                  const newStringLiteral = ts.factory.createStringLiteral(expectedKey);
+                  changeTracker.replaceNode(sourceFile, keyStringLiteral, newStringLiteral);
+                })
+              }]
+            });
+          }
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/duplicatePackage.ts
 var checkedPackagesCache = /* @__PURE__ */ new Map();
 var programResolvedCacheSize = /* @__PURE__ */ new Map();
@@ -4028,7 +4170,7 @@ var effectGenUsesAdapter = createDiagnostic({
       if (ts.isCallExpression(node)) {
         yield* pipe(
           typeParser.effectGen(node),
-          map3(({ generatorFunction }) => {
+          map5(({ generatorFunction }) => {
             if (generatorFunction.parameters.length > 0) {
               const adapter = generatorFunction.parameters[0];
               report({
@@ -4061,7 +4203,7 @@ var effectInVoidSuccess = createDiagnostic({
       if (expectedEffect.A.flags & ts.TypeFlags.Void) {
         const voidValueTypes = typeCheckerUtils.unrollUnionMembers(realEffect.A);
         const voidedEffect = yield* firstSuccessOf(
-          voidValueTypes.map((_) => map3(typeParser.strictEffectType(_, node), () => _))
+          voidValueTypes.map((_) => map5(typeParser.strictEffectType(_, node), () => _))
         );
         return { voidedEffect };
       }
@@ -4077,7 +4219,7 @@ var effectInVoidSuccess = createDiagnostic({
             valueNode,
             realType
           ),
-          map3(({ voidedEffect }) => {
+          map5(({ voidedEffect }) => {
             report(
               {
                 location: node,
@@ -4172,7 +4314,7 @@ var genericEffectServices = createDiagnostic({
       for (const [type, reportAt] of typesToCheck) {
         yield* pipe(
           typeParser.contextTag(type, node),
-          map3(() => {
+          map5(() => {
             report({
               location: reportAt,
               messageText: `Effect Services with type parameters are not supported because they cannot be properly discriminated at runtime, which may cause unexpected behavior.`,
@@ -4349,7 +4491,7 @@ var leakingRequirements = createDiagnostic({
             let effectContextType = void 0;
             yield* pipe(
               typeParser.effectType(servicePropertyType, atLocation),
-              map3((_) => effectContextType = _.R),
+              map5((_) => effectContextType = _.R),
               orElse2(() => {
                 const servicePropertyCallSignatures = typeChecker.getSignaturesOfType(
                   servicePropertyType,
@@ -4361,7 +4503,7 @@ var leakingRequirements = createDiagnostic({
                       typeChecker.getReturnTypeOfSignature(servicePropertyCallSignatures[0]),
                       atLocation
                     ),
-                    map3((_) => {
+                    map5((_) => {
                       effectContextType = _.R;
                     })
                   );
@@ -4379,7 +4521,7 @@ var leakingRequirements = createDiagnostic({
                   if (type.flags & ts.TypeFlags.Never) return succeed(true);
                   return pipe(
                     typeParser.scopeType(type, atLocation),
-                    map3(() => true),
+                    map5(() => true),
                     orElse2(() => succeed(false))
                   );
                 }
@@ -4435,10 +4577,10 @@ More info at https://effect.website/docs/requirements-management/layers/#avoidin
       for (const [type, reportAt] of typesToCheck) {
         yield* pipe(
           typeParser.contextTag(type, node),
-          flatMap(
+          flatMap2(
             ({ Service }) => pipe(
               parseLeakedRequirements(Service, node),
-              map3(
+              map5(
                 (requirements) => reportLeakingRequirements(reportAt, sort(requirements, typeCheckerUtils.deterministicTypeOrder))
               )
             )
@@ -4465,7 +4607,7 @@ var missingEffectContext = createDiagnostic({
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
-      map3(
+      map5(
         ([expectedEffect, realEffect]) => typeCheckerUtils.getMissingTypeEntriesInTargetType(
           realEffect.R,
           expectedEffect.R
@@ -4483,7 +4625,7 @@ var missingEffectContext = createDiagnostic({
             valueNode,
             realType
           ),
-          map3(
+          map5(
             (missingTypes) => missingTypes.length > 0 ? report(
               {
                 location: node,
@@ -4528,7 +4670,7 @@ var missingEffectError = createDiagnostic({
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
-      map3(
+      map5(
         ([expectedEffect, realEffect]) => pipe(
           typeCheckerUtils.getMissingTypeEntriesInTargetType(
             realEffect.E,
@@ -4549,7 +4691,7 @@ var missingEffectError = createDiagnostic({
             valueNode,
             realType
           ),
-          map3((result) => {
+          map5((result) => {
             if (result.missingErrorTypes.length === 0) return;
             const fixes = [];
             if (ts.isExpression(valueNode) && result.expectedErrorType.flags & ts.TypeFlags.Never) {
@@ -4576,17 +4718,17 @@ var missingEffectError = createDiagnostic({
             if (ts.isExpression(valueNode)) {
               const propertyAssignments = pipe(
                 result.missingErrorTypes,
-                map5((_) => typeChecker.getPropertyOfType(_, "_tag")),
+                map4((_) => typeChecker.getPropertyOfType(_, "_tag")),
                 filter((_) => !!_),
-                map5((_) => typeChecker.getTypeOfSymbolAtLocation(_, valueNode)),
+                map4((_) => typeChecker.getTypeOfSymbolAtLocation(_, valueNode)),
                 filter((_) => !!(_.flags & ts.TypeFlags.Literal)),
-                map5((_) => typeChecker.typeToTypeNode(_, void 0, ts.NodeBuilderFlags.NoTruncation)),
+                map4((_) => typeChecker.typeToTypeNode(_, void 0, ts.NodeBuilderFlags.NoTruncation)),
                 filter((_) => !!_ && ts.isLiteralTypeNode(_)),
-                map5((_) => _.literal),
+                map4((_) => _.literal),
                 filter((_) => ts.isLiteralExpression(_)),
-                map5((_) => _.text),
+                map4((_) => _.text),
                 sort(string2),
-                map5(
+                map4(
                   (_) => ts.factory.createPropertyAssignment(
                     ts.factory.createIdentifier(_),
                     ts.factory.createArrowFunction(
@@ -4823,7 +4965,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
             typeParser.effectGen(effectGenNode),
             orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
             orElse2(() => typeParser.effectFnGen(effectGenNode)),
-            map3(({ generatorFunction }) => {
+            map5(({ generatorFunction }) => {
               if (generatorFunction) {
                 brokenGenerators.add(ts.getTokenPosOfNode(generatorFunction, tsUtils.getSourceFileOfNode(node)));
               }
@@ -4892,8 +5034,8 @@ var multipleEffectProvide = createDiagnostic({
         const type = typeChecker.getTypeAtLocation(layer);
         return pipe(
           typeParser.importedEffectModule(node.expression.expression),
-          flatMap(() => typeParser.layerType(type, layer)),
-          map3(() => ({ layer, node })),
+          flatMap2(() => typeParser.layerType(type, layer)),
+          map5(() => ({ layer, node })),
           orElse2(() => void_)
         );
       }
@@ -5063,7 +5205,7 @@ var outdatedEffectCodegen = createDiagnostic({
     for (const { codegen, hash: hash2, range } of codegensWithRanges) {
       yield* pipe(
         getEditsForCodegen([codegen], sourceFile, range),
-        map3((applicable) => {
+        map5((applicable) => {
           if (applicable.hash !== hash2) {
             _report({
               location: range,
@@ -5123,7 +5265,7 @@ var overriddenSchemaConstructor = createDiagnostic({
               const typeAtLocation = typeChecker.getTypeAtLocation(type.expression);
               const isSchema = yield* pipe(
                 typeParser.effectSchemaType(typeAtLocation, type.expression),
-                map3(() => true),
+                map5(() => true),
                 orElse2(() => succeed(false))
               );
               if (isSchema) {
@@ -5194,7 +5336,7 @@ var returnEffectInGen = createDiagnostic({
               typeParser.effectGen(effectGenNode),
               orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
               orElse2(() => typeParser.effectFnGen(effectGenNode)),
-              map3(() => {
+              map5(() => {
                 const fix = node.expression ? [{
                   fixName: "returnEffectInGen_fix",
                   description: "Add yield* statement",
@@ -5257,7 +5399,7 @@ var scopeInLayerEffect = createDiagnostic({
       const entries = typeCheckerUtils.unrollUnionMembers(type);
       return pipe(
         firstSuccessOf(entries.map((type2) => typeParser.scopeType(type2, node))),
-        map3(
+        map5(
           () => report({
             location: node,
             messageText: `Seems like you are constructing a layer with a scope in the requirements.
@@ -5292,7 +5434,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),
-          flatMap(({ RIn }) => reportIfLayerRequireScope(RIn, node, layerEffectApiCall.methodIdentifier)),
+          flatMap2(({ RIn }) => reportIfLayerRequireScope(RIn, node, layerEffectApiCall.methodIdentifier)),
           ignore
         );
         continue;
@@ -5306,7 +5448,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),
-              flatMap(({ RIn }) => reportIfLayerRequireScope(RIn, node, void 0)),
+              flatMap2(({ RIn }) => reportIfLayerRequireScope(RIn, node, void 0)),
               ignore
             );
             continue;
@@ -5416,7 +5558,7 @@ var tryCatchInEffectGen = createDiagnostic({
             typeParser.effectGen(effectGenNode),
             orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
             orElse2(() => typeParser.effectFnGen(effectGenNode)),
-            map3(() => {
+            map5(() => {
               report({
                 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).",
@@ -5451,7 +5593,7 @@ var unnecessaryEffectGen = createDiagnostic({
       if (ts.isCallExpression(node)) {
         yield* pipe(
           typeParser.unnecessaryEffectGen(node),
-          map3(
+          map5(
             ({ replacementNode }) => report({
               location: node,
               messageText: `This Effect.gen contains a single return statement.`,
@@ -5494,7 +5636,7 @@ var unnecessaryPipe = createDiagnostic({
       if (ts.isCallExpression(node)) {
         yield* pipe(
           typeParser.pipeCall(node),
-          map3(({ args: args2, subject }) => {
+          map5(({ args: args2, subject }) => {
             if (args2.length === 0) {
               report({
                 location: node,
@@ -5539,10 +5681,10 @@ var unnecessaryPipeChain = createDiagnostic({
       if (ts.isCallExpression(node)) {
         yield* pipe(
           typeParser.pipeCall(node),
-          flatMap(
-            (pipeCall) => map3(typeParser.pipeCall(pipeCall.subject), (innerCall) => ({ pipeCall, innerCall }))
+          flatMap2(
+            (pipeCall) => map5(typeParser.pipeCall(pipeCall.subject), (innerCall) => ({ pipeCall, innerCall }))
           ),
-          map3(({ innerCall, pipeCall }) => {
+          map5(({ innerCall, pipeCall }) => {
             report({
               location: node,
               messageText: `Chained pipe calls can be simplified to a single pipe call`,
@@ -5674,7 +5816,8 @@ var diagnostics = [
   outdatedEffectCodegen,
   overriddenSchemaConstructor,
   unsupportedServiceAccessors,
-  nonObjectEffectServiceType
+  nonObjectEffectServiceType,
+  deterministicKeys
 ];
 
 // src/completions/effectDiagnosticsComment.ts
@@ -5726,6 +5869,7 @@ var effectSchemaSelfInClasses = createCompletion({
     ) || "Schema";
     if (schemaIdentifier !== ts.idText(accessedObject)) return [];
     const name = ts.idText(className);
+    const errorTagKey = (yield* createString(sourceFile, name, "error")) || name;
     return [{
       name: `Class<${name}>`,
       kind: ts.ScriptElementKind.constElement,
@@ -5735,7 +5879,7 @@ var effectSchemaSelfInClasses = createCompletion({
     }, {
       name: `TaggedError<${name}>`,
       kind: ts.ScriptElementKind.constElement,
-      insertText: `${schemaIdentifier}.TaggedError<${name}>("${name}")("${name}", {${"${0}"}}){}`,
+      insertText: `${schemaIdentifier}.TaggedError<${name}>("${errorTagKey}")("${errorTagKey}", {${"${0}"}}){}`,
       replacementSpan,
       isSnippet: true
     }, {
@@ -5770,16 +5914,17 @@ var effectSelfInClasses = createCompletion({
     ) || "Effect";
     if (effectIdentifier !== ts.idText(accessedObject)) return [];
     const name = ts.idText(className);
+    const tagKey = (yield* createString(sourceFile, name, "service")) || name;
     return [{
       name: `Service<${name}>`,
       kind: ts.ScriptElementKind.constElement,
-      insertText: `${effectIdentifier}.Service<${name}>()("${name}", {${"${0}"}}){}`,
+      insertText: `${effectIdentifier}.Service<${name}>()("${tagKey}", {${"${0}"}}){}`,
       replacementSpan,
       isSnippet: true
     }, {
       name: `Tag("${name}")`,
       kind: ts.ScriptElementKind.constElement,
-      insertText: `${effectIdentifier}.Tag("${name}")<${name}, {${"${0}"}}>(){}`,
+      insertText: `${effectIdentifier}.Tag("${tagKey}")<${name}, {${"${0}"}}>(){}`,
       replacementSpan,
       isSnippet: true
     }];
@@ -5805,7 +5950,7 @@ var fnFunctionStar = createCompletion({
     const maybeFnName = pipe(
       tsUtils.getAncestorNodesInRange(sourceFile, tsUtils.toTextRange(accessedObject.pos)),
       filter(ts.isVariableDeclaration),
-      map5((_) => _.name && ts.isIdentifier(_.name) ? ts.idText(_.name) : ""),
+      map4((_) => _.name && ts.isIdentifier(_.name) ? ts.idText(_.name) : ""),
       filter((_) => _.length > 0),
       head,
       map2((name) => [
@@ -5913,7 +6058,7 @@ var schemaBrand = createCompletion({
     return pipe(
       tsUtils.getAncestorNodesInRange(sourceFile, tsUtils.toTextRange(accessedObject.pos)),
       filter(ts.isVariableDeclaration),
-      map5((_) => _.name && ts.isIdentifier(_.name) ? ts.idText(_.name) : ""),
+      map4((_) => _.name && ts.isIdentifier(_.name) ? ts.idText(_.name) : ""),
       filter((_) => _.length > 0),
       head,
       map2((name) => [
@@ -6688,7 +6833,7 @@ var middlewareGenLike = fn("middlewareGenLike")(function* (sourceFile, _span, pr
         const possiblyGen = node.parent;
         yield* pipe(
           parseType(possiblyGen),
-          map3((_) => {
+          map5((_) => {
             const argsCloseParen = ts.findChildOfKind(_.generatorFunction, ts.SyntaxKind.CloseParenToken, sourceFile);
             if (argsCloseParen && _.body && inlayHint.position >= argsCloseParen.end && inlayHint.position <= _.body.getStart(sourceFile)) {
               shouldOmit = true;
@@ -6729,11 +6874,22 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
       const options = yield* service(LanguageServicePluginOptions);
       if (options.quickinfoEffectParameters === "never") return quickInfo2;
       function formatTypeForQuickInfo(channelType, channelName) {
-        const stringRepresentation = typeChecker.typeToString(
-          channelType,
-          void 0,
-          ts.TypeFormatFlags.NoTruncation
-        );
+        let stringRepresentation = "";
+        if (options.quickinfoMaximumLength > 0) {
+          const typeNode = typeChecker.typeToTypeNode(
+            channelType,
+            void 0,
+            ts.NodeBuilderFlags.None,
+            // @ts-expect-error
+            void 0,
+            void 0,
+            options.quickinfoMaximumLength
+          );
+          const printer = ts.createPrinter({});
+          stringRepresentation = typeNode ? printer.printNode(ts.EmitHint.Unspecified, typeNode, sourceFile) : "";
+        } else {
+          stringRepresentation = typeChecker.typeToString(channelType, void 0, ts.TypeFormatFlags.NoTruncation);
+        }
         return `type ${channelName} = ${stringRepresentation}`;
       }
       function makeSymbolDisplayParts(title, A, E, R) {
@@ -6784,7 +6940,7 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
           type,
           atLocation
         ),
-        map3((_) => makeSymbolDisplayParts("Effect Type Parameters", _.A, _.E, _.R)),
+        map5((_) => makeSymbolDisplayParts("Effect Type Parameters", _.A, _.E, _.R)),
         orElse2(() => {
           const callSignatues = typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call);
           if (callSignatues.length !== 1) return succeed([]);
@@ -6794,7 +6950,7 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
               returnType,
               atLocation
             ),
-            map3((_) => makeSymbolDisplayParts("Returned Effect Type Parameters", _.A, _.E, _.R))
+            map5((_) => makeSymbolDisplayParts("Returned Effect Type Parameters", _.A, _.E, _.R))
           );
         })
       );
@@ -11346,7 +11502,7 @@ function layerInfo(sourceFile, position, quickInfo2) {
       const { layerNode, node } = maybeNodes;
       const layerInfoDisplayParts = yield* pipe(
         parseLayerGraph(sourceFile, layerNode),
-        flatMap(
+        flatMap2(
           ({ mermaidCode, textualExplanation }) => gen(function* () {
             const linkParts = [];
             if (!options.noExternal) {
@@ -11778,11 +11934,11 @@ var effectGenToFn = createRefactor({
       parentNodes,
       filter((_) => ts.isVariableDeclaration(_) && _.initializer ? true : false),
       filter((_) => tsUtils.isNodeInRange(textRange)(_.name)),
-      map5((_) => _.initializer)
+      map4((_) => _.initializer)
     );
     const maybeNode = yield* pipe(
       nodesFromInitializers.concat(parentNodes),
-      map5(parseFunctionLikeReturnEffectGen),
+      map4(parseFunctionLikeReturnEffectGen),
       firstSuccessOf,
       option
     );
@@ -11972,7 +12128,7 @@ var layerMagic = createRefactor({
       if (ts.isArrayLiteralExpression(node)) {
         return pipe(
           all(...node.elements.map((element) => extractLayers(element, false))),
-          map3(flatten)
+          map5(flatten)
         );
       }
       return TypeParserIssue.issue;
@@ -11981,7 +12137,7 @@ var layerMagic = createRefactor({
       if (ts.isExpression(node)) {
         return pipe(
           typeParser.layerType(typeChecker.getTypeAtLocation(node), node),
-          map3((_) => [{ node, ..._ }])
+          map5((_) => [{ node, ..._ }])
         );
       }
       return TypeParserIssue.issue;
@@ -11992,7 +12148,7 @@ var layerMagic = createRefactor({
       ) > -1) {
         return pipe(
           all(...node.arguments.map((element) => extractLayers(element, false))),
-          map3(flatten)
+          map5(flatten)
         );
       }
       return TypeParserIssue.issue;
@@ -12000,10 +12156,10 @@ var layerMagic = createRefactor({
     const extractPipeSequencing = (node) => {
       return pipe(
         typeParser.pipeCall(node),
-        flatMap((_) => {
+        flatMap2((_) => {
           return all(...[_.subject, ..._.args].map((element) => extractLayers(element, true)));
         }),
-        map3(flatten)
+        map5(flatten)
       );
     };
     const extractLayers = cachedBy(
@@ -12031,10 +12187,10 @@ var layerMagic = createRefactor({
       const atLocation = adjustedNode(node);
       return pipe(
         extractLayers(atLocation, false),
-        flatMap(
+        flatMap2(
           (extractedLayer) => extractedLayer.length < 1 ? TypeParserIssue.issue : succeed(extractedLayer)
         ),
-        map3((extractedLayers) => ({
+        map5((extractedLayers) => ({
           kind: "refactor.rewrite.effect.layerMagicPrepare",
           description: "Prepare layers for automatic composition",
           apply: pipe(
@@ -12050,7 +12206,7 @@ var layerMagic = createRefactor({
               }
               const previouslyProvided = yield* pipe(
                 typeParser.layerType(typeChecker.getTypeAtLocation(atLocation), atLocation),
-                map3((_) => _.ROut),
+                map5((_) => _.ROut),
                 option
               );
               const [existingBefore, newlyIntroduced] = pipe(
@@ -12062,13 +12218,13 @@ var layerMagic = createRefactor({
               );
               const typeReferences = pipe(
                 newlyIntroduced,
-                map5((_) => typeChecker.typeToTypeNode(_, void 0, ts.NodeBuilderFlags.NoTruncation)),
+                map4((_) => typeChecker.typeToTypeNode(_, void 0, ts.NodeBuilderFlags.NoTruncation)),
                 filter((_) => !!_)
               );
               const providesUnion = typeReferences.length === 0 ? ts.factory.createTypeReferenceNode("never") : ts.factory.createUnionTypeNode(typeReferences);
               const typeStrings = pipe(
                 existingBefore,
-                map5((_) => typeChecker.typeToString(_, void 0, ts.TypeFormatFlags.NoTruncation)),
+                map4((_) => typeChecker.typeToString(_, void 0, ts.TypeFormatFlags.NoTruncation)),
                 filter((_) => !!_)
               );
               const unionWithComment = typeStrings.length === 0 ? providesUnion : ts.addSyntheticTrailingComment(
@@ -12103,7 +12259,7 @@ var layerMagic = createRefactor({
         if (ts.isAsExpression(expression) && expression.type.kind === ts.SyntaxKind.AnyKeyword) {
           return pipe(
             typeParser.layerType(typeChecker.getTypeAtLocation(node.type), node.type),
-            map3((_) => ({ node, ..._, castedStructure: expression.expression }))
+            map5((_) => ({ node, ..._, castedStructure: expression.expression }))
           );
         }
       }
@@ -12113,14 +12269,14 @@ var layerMagic = createRefactor({
       const atLocation = adjustedNode(node);
       return pipe(
         parseAsAnyAsLayer(atLocation),
-        flatMap(
+        flatMap2(
           (_targetLayer) => pipe(
             extractArrayLiteral(_targetLayer.castedStructure),
             orElse2(() => extractLayers(_targetLayer.castedStructure, false)),
-            flatMap(
+            flatMap2(
               (extractedLayer) => extractedLayer.length < 1 ? TypeParserIssue.issue : succeed(extractedLayer)
             ),
-            map3((extractedLayers) => ({
+            map5((extractedLayers) => ({
               kind: "refactor.rewrite.effect.layerMagicBuild",
               description: "Compose layers automatically with target output services",
               apply: gen(function* () {
@@ -12237,7 +12393,7 @@ var _findSchemaVariableDeclaration = fn(
     );
     return yield* pipe(
       tsUtils.getAncestorNodesInRange(sourceFile, textRange),
-      map5(findSchema),
+      map4(findSchema),
       firstSuccessOf,
       option
     );
@@ -12523,7 +12679,7 @@ var pipeableToDatafirst = createRefactor({
       filter(
         (node2) => node2.arguments.length > 0
       ),
-      map5((node2) => {
+      map4((node2) => {
         let newNode2 = node2.arguments[0];
         let didSomething = false;
         for (let i = 1; i < node2.arguments.length; i++) {
@@ -12550,7 +12706,7 @@ var pipeableToDatafirst = createRefactor({
         return didSomething ? some2([node2, newNode2]) : none2();
       }),
       filter(isSome2),
-      map5((_) => _.value),
+      map4((_) => _.value),
       head
     );
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
@@ -12744,7 +12900,7 @@ var toggleReturnTypeAnnotation = createRefactor({
         description: "Toggle return type annotation",
         apply: pipe(
           service(ChangeTracker),
-          map3((changeTracker) => removeReturnTypeAnnotation(sourceFile, changeTracker, node))
+          map5((changeTracker) => removeReturnTypeAnnotation(sourceFile, changeTracker, node))
         )
       };
     }
@@ -12761,7 +12917,7 @@ var toggleReturnTypeAnnotation = createRefactor({
       description: "Toggle return type annotation",
       apply: pipe(
         service(ChangeTracker),
-        map3(
+        map5(
           (changeTracker) => addReturnTypeAnnotation(sourceFile, changeTracker, node, tsUtils.simplifyTypeNode(returnTypeNode))
         )
       )
@@ -13356,16 +13512,17 @@ var wrapWithEffectGen = createRefactor({
     const findEffectToWrap = fn("wrapWithEffectGen.apply.findEffectToWrap")(
       function* (node) {
         if (!ts.isExpression(node)) return yield* fail("is not an expression");
+        if (node.parent && ts.isHeritageClause(node.parent)) return yield* fail("is in a heritage clause");
         const parent = node.parent;
         if (parent != null && ts.isVariableDeclaration(parent) && parent.initializer !== node) return yield* fail("is LHS of variable declaration");
         const type = typeChecker.getTypeAtLocation(node);
-        yield* typeParser.effectType(type, node);
+        yield* typeParser.strictEffectType(type, node);
         return node;
       }
     );
     const maybeNode = yield* pipe(
       tsUtils.getAncestorNodesInRange(sourceFile, textRange),
-      map5(findEffectToWrap),
+      map4(findEffectToWrap),
       firstSuccessOf,
       option
     );
@@ -13450,19 +13607,19 @@ var renameKeyStrings = (sourceFile, position, _findInStrings, _findInComments, _
     const parentClass = node.parent;
     if (ts.isClassDeclaration(parentClass) && parentClass.name === node) {
       const baseIdentifier = yield* pipe(
-        map3(typeParser.extendsContextTag(parentClass), (_) => [_.keyStringLiteral]),
-        orElse2(() => map3(typeParser.extendsEffectService(parentClass), (_) => [_.keyStringLiteral])),
-        orElse2(() => map3(typeParser.extendsEffectTag(parentClass), (_) => [_.keyStringLiteral])),
+        map5(typeParser.extendsContextTag(parentClass), (_) => [_.keyStringLiteral]),
+        orElse2(() => map5(typeParser.extendsEffectService(parentClass), (_) => [_.keyStringLiteral])),
+        orElse2(() => map5(typeParser.extendsEffectTag(parentClass), (_) => [_.keyStringLiteral])),
         orElse2(
-          () => map3(typeParser.extendsSchemaTaggedClass(parentClass), (_) => [_.keyStringLiteral, _.tagStringLiteral])
+          () => map5(typeParser.extendsSchemaTaggedClass(parentClass), (_) => [_.keyStringLiteral, _.tagStringLiteral])
         ),
         orElse2(
-          () => map3(typeParser.extendsSchemaTaggedError(parentClass), (_) => [_.keyStringLiteral, _.tagStringLiteral])
+          () => map5(typeParser.extendsSchemaTaggedError(parentClass), (_) => [_.keyStringLiteral, _.tagStringLiteral])
         ),
-        orElse2(() => map3(typeParser.extendsDataTaggedError(parentClass), (_) => [_.keyStringLiteral])),
-        orElse2(() => map3(typeParser.extendsDataTaggedClass(parentClass), (_) => [_.keyStringLiteral])),
+        orElse2(() => map5(typeParser.extendsDataTaggedError(parentClass), (_) => [_.keyStringLiteral])),
+        orElse2(() => map5(typeParser.extendsDataTaggedClass(parentClass), (_) => [_.keyStringLiteral])),
         orElse2(
-          () => map3(
+          () => map5(
             typeParser.extendsSchemaTaggedRequest(parentClass),
             (_) => [_.keyStringLiteral, _.tagStringLiteral]
           )
@@ -13607,7 +13764,7 @@ var init = (modules) => {
               }
               return effectCodeFixes;
             }),
-            flatMap(
+            flatMap2(
               (effectCodeFixes) => pipe(
                 middlewareAutoImportQuickfixes(
                   sourceFile,
@@ -13616,7 +13773,7 @@ var init = (modules) => {
                   preferences,
                   applicableCodeFixes
                 ),
-                map3((modifiedCodeFixes) => effectCodeFixes.concat(modifiedCodeFixes))
+                map5((modifiedCodeFixes) => effectCodeFixes.concat(modifiedCodeFixes))
               )
             ),
             runNano(program),
@@ -13725,7 +13882,7 @@ var init = (modules) => {
           if (sourceFile) {
             return pipe(
               appendEffectCompletionEntryData(sourceFile, applicableCompletions),
-              flatMap(
+              flatMap2(
                 (augmentedCompletions) => pipe(
                   getCompletionsAtPosition(
                     completions,
@@ -13734,7 +13891,7 @@ var init = (modules) => {
                     options,
                     formattingSettings
                   ),
-                  map3(
+                  map5(
                     (effectCompletions) => augmentedCompletions ? {
                       ...augmentedCompletions,
                       entries: effectCompletions.concat(augmentedCompletions.entries)
@@ -13868,7 +14025,7 @@ var init = (modules) => {
               if (sourceFile) {
                 return pipe(
                   effectApiGetLayerGraph(sourceFile, line, character),
-                  map3((response) => ({
+                  map5((response) => ({
                     response: {
                       success: true,
                       ...response