@effect/language-service 0.76.0 → 0.77.0

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Pipeable.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Pipeable.js
 var pipeArguments = (self, args3) => {
   switch (args3.length) {
     case 0:
@@ -44,7 +44,7 @@ var Class = /* @__PURE__ */ (function() {
   return PipeableBase;
 })();
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Function.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Function.js
 var dual = function(arity, body) {
   if (typeof arity === "function") {
     return function() {
@@ -92,7 +92,7 @@ function pipe(a, ...args3) {
   return pipeArguments(a, args3);
 }
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Equivalence.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Equivalence.js
 var make = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
 function Array2(item) {
   return make((self, that) => {
@@ -104,7 +104,7 @@ function Array2(item) {
   });
 }
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/internal/equal.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/internal/equal.js
 var getAllObjectKeys = (obj) => {
   const keys2 = new Set(Reflect.ownKeys(obj));
   if (obj.constructor === Object) return keys2;
@@ -127,7 +127,7 @@ var getAllObjectKeys = (obj) => {
 };
 var byReferenceInstances = /* @__PURE__ */ new WeakSet();
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Predicate.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Predicate.js
 function isString(input) {
   return typeof input === "string";
 }
@@ -148,7 +148,7 @@ function isObjectKeyword(input) {
 }
 var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObjectKeyword(self) && property in self);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Hash.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Hash.js
 var symbol = "~effect/interfaces/Hash";
 var hash = (self) => {
   switch (typeof self) {
@@ -267,7 +267,7 @@ function withVisitedTracking(obj, fn2) {
   return result;
 }
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Equal.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Equal.js
 var symbol2 = "~effect/interfaces/Equal";
 function equals() {
   if (arguments.length === 1) {
@@ -429,7 +429,7 @@ var compareSets = /* @__PURE__ */ makeCompareSet(compareBoth);
 var isEqual = (u) => hasProperty(u, symbol2);
 var asEquivalence = () => equals;
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Redactable.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Redactable.js
 var symbolRedactable = /* @__PURE__ */ Symbol.for("~effect/Inspectable/redactable");
 var isRedactable = (u) => hasProperty(u, symbolRedactable);
 function redact(u) {
@@ -448,7 +448,7 @@ var emptyServiceMap = {
   }
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Formatter.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Formatter.js
 function format(input, options) {
   const space = options?.space ?? 0;
   const seen = /* @__PURE__ */ new WeakSet();
@@ -527,7 +527,7 @@ function safeToString(input) {
   }
 }
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Inspectable.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var toJson = (input) => {
   try {
@@ -571,7 +571,7 @@ var Class2 = class {
   }
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Utils.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Utils.js
 var GenKindTypeId = "~effect/Utils/GenKind";
 var GenKindImpl = class {
   value;
@@ -639,7 +639,7 @@ var internalCall = isNotOptimizedAway ? standard[InternalTypeId] : forced[Intern
 var genConstructor = function* () {
 }.constructor;
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/internal/core.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/internal/core.js
 var EffectTypeId = `~effect/Effect`;
 var ExitTypeId = `~effect/Exit`;
 var effectVariance = {
@@ -986,7 +986,7 @@ var DoneVoid = {
   value: void 0
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/internal/option.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/internal/option.js
 var TypeId = "~effect/data/Option";
 var CommonProto = {
   [TypeId]: {
@@ -1051,7 +1051,7 @@ var some = (value) => {
   return a;
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/internal/result.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/internal/result.js
 var TypeId2 = "~effect/data/Result";
 var CommonProto2 = {
   [TypeId2]: {
@@ -1122,7 +1122,7 @@ var succeed = (success) => {
   return a;
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Result.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Result.js
 var succeed2 = succeed;
 var fail2 = fail;
 var isFailure2 = isFailure;
@@ -1130,7 +1130,7 @@ var isSuccess2 = isSuccess;
 var map = /* @__PURE__ */ dual(2, (self, f) => isSuccess2(self) ? succeed2(f(self.success)) : fail2(self.failure));
 var getOrElse = /* @__PURE__ */ dual(2, (self, onFailure) => isFailure2(self) ? onFailure(self.failure) : self.success);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Order.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Order.js
 function make2(compare) {
   return (self, that) => self === that ? 0 : compare(self, that);
 }
@@ -1153,7 +1153,7 @@ var combine2 = /* @__PURE__ */ dual(2, (self, that) => make2((a1, a2) => {
 }));
 var mapInput = /* @__PURE__ */ dual(2, (self, f) => make2((b1, b2) => self(f(b1), f(b2))));
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Option.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Option.js
 var none2 = () => none;
 var some2 = some;
 var isNone2 = isNone;
@@ -1164,7 +1164,7 @@ var fromNullishOr = (a) => a == null ? none2() : some2(a);
 var getOrUndefined = /* @__PURE__ */ getOrElse2(constUndefined);
 var map2 = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some2(f(self.value)));
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Filter.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Filter.js
 var apply = (filter2, input, ...args3) => {
   const result = filter2(input, ...args3);
   if (result === true) return succeed2(input);
@@ -1172,10 +1172,10 @@ var apply = (filter2, input, ...args3) => {
   return result;
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/internal/array.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/internal/array.js
 var isArrayNonEmpty = (self) => self.length > 0;
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Record.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Record.js
 var map3 = /* @__PURE__ */ dual(2, (self, f) => {
   const out = {
     ...self
@@ -1187,7 +1187,7 @@ var map3 = /* @__PURE__ */ dual(2, (self, f) => {
 });
 var keys = (self) => Object.keys(self);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Array.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Array.js
 var Array3 = globalThis.Array;
 var fromIterable = (collection) => Array3.isArray(collection) ? collection : Array3.from(collection);
 var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
@@ -1292,7 +1292,7 @@ var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
 var dedupe = (self) => dedupeWith(self, asEquivalence());
 var join = /* @__PURE__ */ dual(2, (self, sep) => fromIterable(self).join(sep));
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Data.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Data.js
 var Class3 = class extends Class {
   constructor(props) {
     super();
@@ -1303,7 +1303,7 @@ var Class3 = class extends Class {
 };
 var TaggedError2 = TaggedError;
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Encoding.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Encoding.js
 var EncodingErrorTypeId = "~effect/encoding/EncodingError";
 var EncodingError = class extends (/* @__PURE__ */ TaggedError2("EncodingError")) {
   /**
@@ -1339,7 +1339,7 @@ var base64EncodeUint8Array = (bytes) => {
 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", "+", "/"];
 var base64UrlEncodeUint8Array = (data) => base64EncodeUint8Array(data).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Graph.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Graph.js
 var TypeId3 = "~effect/collections/Graph";
 var Edge = class extends Class3 {
 };
@@ -5270,6 +5270,73 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     "TypeParser.extendsEffectSqlModelClass",
     (atLocation) => atLocation
   );
+  const isEffectSchemaModelTypeSourceFile = cachedBy(
+    fn("TypeParser.isEffectSchemaModelTypeSourceFile")(function* (sourceFile) {
+      const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return yield* typeParserIssue("Node has no symbol", void 0, sourceFile);
+      const classSymbol = typeChecker.tryGetMemberInModuleExports("Class", moduleSymbol);
+      if (!classSymbol) return yield* typeParserIssue("Model's Class type not found", void 0, sourceFile);
+      const generatedSymbol = typeChecker.tryGetMemberInModuleExports("Generated", moduleSymbol);
+      if (!generatedSymbol) {
+        return yield* typeParserIssue("Model's Generated type not found", void 0, sourceFile);
+      }
+      const fieldOptionSymbol = typeChecker.tryGetMemberInModuleExports("FieldOption", moduleSymbol);
+      if (!fieldOptionSymbol) {
+        return yield* typeParserIssue("Model's FieldOption type not found", void 0, sourceFile);
+      }
+      return sourceFile;
+    }),
+    "TypeParser.isEffectSchemaModelTypeSourceFile",
+    (sourceFile) => sourceFile
+  );
+  const isNodeReferenceToEffectSchemaModelModuleApi = (memberName) => cachedBy(
+    fn("TypeParser.isNodeReferenceToEffectSchemaModelModuleApi")(function* (node) {
+      return yield* isNodeReferenceToExportOfPackageModule(
+        node,
+        "effect",
+        isEffectSchemaModelTypeSourceFile,
+        memberName
+      );
+    }),
+    `TypeParser.isNodeReferenceToEffectSchemaModelModuleApi(${memberName})`,
+    (node) => node
+  );
+  const extendsEffectSchemaModelClass = cachedBy(
+    fn("TypeParser.extendsEffectSchemaModelClass")(function* (atLocation) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const heritageClauses = atLocation.heritageClauses;
+      if (!heritageClauses) {
+        return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
+      }
+      for (const heritageClause of heritageClauses) {
+        for (const typeX of heritageClause.types) {
+          if (ts.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression;
+            if (ts.isCallExpression(expression)) {
+              const schemaCall = expression.expression;
+              if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                const isEffectSchemaModelModuleApi = yield* pipe(
+                  isNodeReferenceToEffectSchemaModelModuleApi("Class")(schemaCall.expression),
+                  orUndefined
+                );
+                if (isEffectSchemaModelModuleApi) {
+                  return {
+                    className: atLocation.name,
+                    selfTypeNode: schemaCall.typeArguments[0]
+                  };
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend effect's Model.Class", void 0, atLocation);
+    }),
+    "TypeParser.extendsEffectSchemaModelClass",
+    (atLocation) => atLocation
+  );
   const isEffectLayerTypeSourceFile = cachedBy(
     fn("TypeParser.isEffectLayerTypeSourceFile")(function* (sourceFile) {
       const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
@@ -5642,6 +5709,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     isNodeReferenceToEffectDataModuleApi,
     isNodeReferenceToEffectContextModuleApi,
     isNodeReferenceToEffectSqlModelModuleApi,
+    isNodeReferenceToEffectSchemaModelModuleApi,
     isNodeReferenceToEffectLayerModuleApi,
     isNodeReferenceToEffectSchemaParserModuleApi,
     isServiceMapTypeSourceFile,
@@ -5679,6 +5747,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     extendsSchemaTaggedRequest,
     extendsSchemaRequestClass,
     extendsEffectSqlModelClass,
+    extendsEffectSchemaModelClass,
     lazyExpression,
     emptyFunction,
     pipingFlows,
@@ -7200,6 +7269,7 @@ var classSelfMismatch = createDiagnostic({
             )
           ),
           orElse2(() => typeParser.extendsEffectSqlModelClass(node)),
+          orElse2(() => typeParser.extendsEffectSchemaModelClass(node)),
           orElse2(() => void_)
         );
         if (result) {
@@ -9592,6 +9662,765 @@ var nonObjectEffectServiceType = createDiagnostic({
   })
 });
 
+// src/diagnostics/outdatedApi.db.ts
+var asUnchanged = {
+  _tag: "Unchanged"
+};
+var asRenamedSameBehaviour = (newName) => ({
+  _tag: "RenamedSameBehaviour",
+  newName
+});
+var asRenamedAndNeedsOptions = (newName, optionsInstructions) => ({
+  _tag: "RenamedAndNeedsOptions",
+  newName,
+  optionsInstructions
+});
+var asRemoved = (alternativePattern) => ({
+  _tag: "Removed",
+  alternativePattern
+});
+var effectModuleMigrationDb = {
+  // Common APIs (in both v3 and v4, unchanged)
+  "acquireRelease": asUnchanged,
+  "acquireUseRelease": asUnchanged,
+  "addFinalizer": asUnchanged,
+  "all": asUnchanged,
+  "andThen": asUnchanged,
+  "annotateCurrentSpan": asUnchanged,
+  "annotateLogs": asUnchanged,
+  "annotateSpans": asUnchanged,
+  "as": asUnchanged,
+  "asSome": asUnchanged,
+  "asVoid": asUnchanged,
+  "cached": asUnchanged,
+  "cachedInvalidateWithTTL": asUnchanged,
+  "cachedWithTTL": asUnchanged,
+  "catch": asUnchanged,
+  "catchIf": asUnchanged,
+  "catchTag": asUnchanged,
+  "catchTags": asUnchanged,
+  "clockWith": asUnchanged,
+  "currentParentSpan": asUnchanged,
+  "currentSpan": asUnchanged,
+  "delay": asUnchanged,
+  "die": asUnchanged,
+  "ensuring": asUnchanged,
+  "eventually": asUnchanged,
+  "exit": asUnchanged,
+  "fail": asUnchanged,
+  "failCause": asUnchanged,
+  "failCauseSync": asUnchanged,
+  "failSync": asUnchanged,
+  "fiberId": asUnchanged,
+  "filter": asUnchanged,
+  "filterMap": asRemoved(
+    "Use Effect.filter or Effect.map with Option instead."
+  ),
+  "filterOrElse": asUnchanged,
+  "filterOrFail": asUnchanged,
+  "flatMap": asUnchanged,
+  "flatten": asUnchanged,
+  "flip": asUnchanged,
+  "fn": asUnchanged,
+  "fnUntraced": asUnchanged,
+  "forEach": asUnchanged,
+  "forever": asUnchanged,
+  "forkIn": asUnchanged,
+  "forkScoped": asUnchanged,
+  "gen": asUnchanged,
+  "ignore": asUnchanged,
+  "interrupt": asUnchanged,
+  "interruptible": asUnchanged,
+  "interruptibleMask": asUnchanged,
+  "isEffect": asUnchanged,
+  "isFailure": asUnchanged,
+  "isSuccess": asUnchanged,
+  "linkSpans": asUnchanged,
+  "log": asUnchanged,
+  "logDebug": asUnchanged,
+  "logError": asUnchanged,
+  "logFatal": asUnchanged,
+  "logInfo": asUnchanged,
+  "logTrace": asUnchanged,
+  "logWarning": asUnchanged,
+  "logWithLevel": asUnchanged,
+  "makeLatch": asRemoved(
+    "Use Latch.make instead of Effect.makeLatch."
+  ),
+  "makeSemaphore": asRemoved(
+    "Use Semaphore.make instead of Effect.makeSemaphore."
+  ),
+  "makeSpan": asUnchanged,
+  "makeSpanScoped": asUnchanged,
+  "map": asUnchanged,
+  "mapBoth": asUnchanged,
+  "mapError": asUnchanged,
+  "match": asUnchanged,
+  "matchCause": asUnchanged,
+  "matchCauseEffect": asUnchanged,
+  "matchEffect": asUnchanged,
+  "never": asUnchanged,
+  "onError": asUnchanged,
+  "onExit": asUnchanged,
+  "onInterrupt": asUnchanged,
+  "option": asUnchanged,
+  "orDie": asUnchanged,
+  "orElseSucceed": asUnchanged,
+  "promise": asUnchanged,
+  "provide": asUnchanged,
+  "provideService": asUnchanged,
+  "provideServiceEffect": asUnchanged,
+  "race": asUnchanged,
+  "raceAll": asUnchanged,
+  "raceFirst": asUnchanged,
+  "repeat": asUnchanged,
+  "repeatOrElse": asUnchanged,
+  "replicate": asUnchanged,
+  "replicateEffect": asUnchanged,
+  "request": asUnchanged,
+  "retry": asUnchanged,
+  "retryOrElse": asUnchanged,
+  "runCallback": asUnchanged,
+  "runFork": asUnchanged,
+  "runPromise": asUnchanged,
+  "runPromiseExit": asUnchanged,
+  "runSync": asUnchanged,
+  "runSyncExit": asUnchanged,
+  "sandbox": asUnchanged,
+  "schedule": asUnchanged,
+  "scheduleFrom": asUnchanged,
+  "scope": asUnchanged,
+  "scoped": asUnchanged,
+  "scopedWith": asUnchanged,
+  "serviceOption": asUnchanged,
+  "sleep": asUnchanged,
+  "spanAnnotations": asUnchanged,
+  "spanLinks": asUnchanged,
+  "succeed": asUnchanged,
+  "succeedNone": asUnchanged,
+  "succeedSome": asUnchanged,
+  "suspend": asUnchanged,
+  "sync": asUnchanged,
+  "tap": asUnchanged,
+  "tapDefect": asUnchanged,
+  "tapError": asUnchanged,
+  "tapErrorTag": asUnchanged,
+  "timed": asUnchanged,
+  "timeout": asUnchanged,
+  "timeoutOption": asUnchanged,
+  "tracer": asUnchanged,
+  "try": asUnchanged,
+  "tryPromise": asUnchanged,
+  "uninterruptible": asUnchanged,
+  "uninterruptibleMask": asUnchanged,
+  "updateService": asUnchanged,
+  "useSpan": asUnchanged,
+  "void": asUnchanged,
+  "when": asUnchanged,
+  "whileLoop": asUnchanged,
+  "withConcurrency": asUnchanged,
+  "withExecutionPlan": asUnchanged,
+  "withLogSpan": asUnchanged,
+  "withParentSpan": asUnchanged,
+  "withSpan": asUnchanged,
+  "withSpanScoped": asUnchanged,
+  "withTracer": asUnchanged,
+  "withTracerEnabled": asUnchanged,
+  "withTracerTiming": asUnchanged,
+  "yieldNow": asUnchanged,
+  "zip": asUnchanged,
+  "zipWith": asUnchanged,
+  // Renamed APIs (v3 name → v4 name)
+  "catchAll": asRenamedSameBehaviour("catch"),
+  "catchAllCause": asRenamedSameBehaviour("catchCause"),
+  "catchAllDefect": asRenamedSameBehaviour("catchDefect"),
+  "catchSome": asRemoved(
+    "Use Effect.catchIf instead. Note: the API shape changed from returning Option<Effect> to taking a predicate and handler separately."
+  ),
+  "catchSomeCause": asRemoved(
+    "Use Effect.catchCauseIf instead. Note: the API shape changed from returning Option<Effect> to taking a predicate and handler separately."
+  ),
+  "ensureErrorType": asRenamedSameBehaviour("satisfiesErrorType"),
+  "ensureRequirementsType": asRenamedSameBehaviour("satisfiesServicesType"),
+  "ensureSuccessType": asRenamedSameBehaviour("satisfiesSuccessType"),
+  "fork": asRenamedSameBehaviour("forkChild"),
+  "forkDaemon": asRenamedSameBehaviour("forkDetach"),
+  "scopeWith": asRenamedSameBehaviour("scopedWith"),
+  "serviceOptional": asRenamedSameBehaviour("serviceOption"),
+  "tapErrorCause": asRenamedSameBehaviour("tapCause"),
+  // Removed APIs
+  "annotateLogsScoped": asUnchanged,
+  "awaitAllChildren": asUnchanged,
+  "bind": asUnchanged,
+  "bindTo": asUnchanged,
+  "Do": asUnchanged,
+  "let": asUnchanged,
+  "partition": asUnchanged,
+  "validate": asUnchanged,
+  "catchSomeDefect": asRemoved(
+    "Use Effect.catchDefect or Effect.matchCause to handle specific defects."
+  ),
+  "forkAll": asRemoved(
+    "Fork effects individually with Effect.forEach and Effect.forkChild, or use Effect.all with concurrency options."
+  ),
+  "forkWithErrorHandler": asRemoved(
+    "Fork the effect with Effect.forkChild and observe the fiber result via Fiber.join or Fiber.await."
+  ),
+  "Tag": asRemoved(
+    "Use ServiceMap.Service instead of Effect.Tag."
+  ),
+  "Service": asRemoved(
+    "Use ServiceMap.Service instead of Effect.Service."
+  ),
+  "runtime": asRemoved(
+    "Runtime has been removed in Effect v4. Use Effect.services to grab services and then run using Effect.runPromiseWith."
+  ),
+  "bindAll": asRemoved(
+    "Use Effect.gen instead of Effect.bindAll."
+  ),
+  "EffectTypeId": asRemoved(
+    "EffectTypeId has been removed in Effect v4."
+  ),
+  "acquireReleaseInterruptible": asRemoved(
+    "Use Effect.acquireRelease instead."
+  ),
+  "allSuccesses": asRemoved(
+    "Use Effect.all with the { mode: 'either' } option and filter successes."
+  ),
+  "allWith": asRemoved(
+    "Use Effect.all with options instead."
+  ),
+  "allowInterrupt": asRemoved(
+    "Use Effect.yieldNow instead."
+  ),
+  "ap": asRemoved(
+    "Use Effect.map and Effect.flatMap to apply functions instead."
+  ),
+  "asSomeError": asRemoved(
+    "Use Effect.mapError(Option.some) instead."
+  ),
+  "async": asRenamedAndNeedsOptions("callback", "Note: in v4 the callback receives a Scheduler as 'this' context."),
+  "asyncEffect": asRemoved(
+    "Use Effect.suspend combined with Effect.promise instead."
+  ),
+  "blocked": asRemoved(
+    "The request batching API has been reworked in Effect v4."
+  ),
+  "cacheRequestResult": asRemoved(
+    "The request batching API has been reworked in Effect v4."
+  ),
+  "cachedFunction": asRemoved(
+    "Use Effect.cached or implement caching with a Ref instead."
+  ),
+  "cause": asRemoved(
+    "Use Effect.matchCause or Effect.sandbox to access the cause."
+  ),
+  "checkInterruptible": asRemoved(
+    "Interruption checking has been removed in Effect v4."
+  ),
+  "clock": asRemoved(
+    "Use Effect.clockWith instead."
+  ),
+  "configProviderWith": asRemoved(
+    "ConfigProvider access has been reworked in Effect v4."
+  ),
+  "console": asRemoved(
+    "Use Effect.consoleWith or the Console service directly."
+  ),
+  "consoleWith": asRemoved(
+    "Console access has been reworked in Effect v4."
+  ),
+  "context": asRemoved(
+    "Use Effect.context is removed. Access services directly via yield* or Effect.provideService."
+  ),
+  "contextWith": asRemoved(
+    "Use Effect.map with service access instead."
+  ),
+  "contextWithEffect": asRemoved(
+    "Use Effect.flatMap with service access instead."
+  ),
+  "custom": asRemoved(
+    "Use Effect.suspend or Effect.sync to create custom effects."
+  ),
+  "daemonChildren": asRemoved(
+    "Use Effect.forkDetach to fork detached fibers instead."
+  ),
+  "descriptor": asRemoved(
+    "Fiber descriptor access has been removed in Effect v4."
+  ),
+  "descriptorWith": asRemoved(
+    "Fiber descriptor access has been removed in Effect v4."
+  ),
+  "dieMessage": asRemoved(
+    "Use Effect.die(new Error(message)) instead."
+  ),
+  "dieSync": asRemoved(
+    "Use Effect.die with a lazily evaluated value instead."
+  ),
+  "diffFiberRefs": asRemoved(
+    "FiberRef has been replaced by ServiceMap.Reference in Effect v4."
+  ),
+  "disconnect": asRemoved(
+    "Fiber disconnect has been removed in Effect v4."
+  ),
+  "dropUntil": asRemoved(
+    "Use Array.dropUntil and Effect.forEach instead."
+  ),
+  "dropWhile": asRemoved(
+    "Use Array.dropWhile and Effect.forEach instead."
+  ),
+  "either": asRenamedAndNeedsOptions(
+    "result",
+    "Note: returns Result.Result<A, E> instead of Either<E, A>. Use the Result module to work with the result."
+  ),
+  "ensuringChild": asRemoved(
+    "Use Effect.onExit to manage child fiber cleanup instead."
+  ),
+  "ensuringChildren": asRemoved(
+    "Use Effect.onExit to manage child fiber cleanup instead."
+  ),
+  "every": asRemoved(
+    "Use Effect.forEach with a predicate check instead."
+  ),
+  "exists": asRemoved(
+    "Use Effect.forEach with a predicate check instead."
+  ),
+  "fiberIdWith": asRemoved(
+    "Use Effect.fiberId instead."
+  ),
+  "filterEffectOrElse": asRemoved(
+    "Use Effect.filterOrElse with an effectful predicate instead."
+  ),
+  "filterEffectOrFail": asRemoved(
+    "Use Effect.filterOrFail with an effectful predicate instead."
+  ),
+  "filterOrDie": asRemoved(
+    "Use Effect.filterOrFail and Effect.orDie instead."
+  ),
+  "filterOrDieMessage": asRemoved(
+    "Use Effect.filterOrFail and Effect.orDie instead."
+  ),
+  "finalizersMask": asRemoved(
+    "Finalizer masking has been removed in Effect v4."
+  ),
+  "findFirst": asRemoved(
+    "Use Effect.forEach with early return instead."
+  ),
+  "firstSuccessOf": asRemoved(
+    "Use Effect.raceAll instead."
+  ),
+  "flipWith": asRemoved(
+    "Use Effect.flip combined with the desired transformation instead."
+  ),
+  "fromFiber": asRemoved(
+    "Use Fiber.join instead."
+  ),
+  "fromFiberEffect": asRemoved(
+    "Use Effect.flatMap with Fiber.join instead."
+  ),
+  "fromNullable": asRemoved(
+    "Use Effect.suspend with null checks instead."
+  ),
+  "functionWithSpan": asRemoved(
+    "Use Effect.withSpan instead."
+  ),
+  "getFiberRefs": asRemoved(
+    "FiberRef has been replaced by ServiceMap.Reference in Effect v4."
+  ),
+  "getRuntimeFlags": asRemoved(
+    "Runtime flags have been removed in Effect v4."
+  ),
+  "head": asRemoved(
+    "Use Array.head and Effect.flatMap instead."
+  ),
+  "if": asRemoved(
+    "Use Effect.when instead of Effect.if."
+  ),
+  "ignoreLogged": asRemoved(
+    "Logging configuration has been reworked in Effect v4."
+  ),
+  "inheritFiberRefs": asRemoved(
+    "FiberRef has been replaced by ServiceMap.Reference in Effect v4."
+  ),
+  "interruptWith": asRemoved(
+    "Use Effect.interrupt instead."
+  ),
+  "intoDeferred": asRemoved(
+    "Use Deferred.complete instead."
+  ),
+  "iterate": asRemoved(
+    "Use Effect.whileLoop or recursion with Effect.suspend instead."
+  ),
+  "labelMetrics": asRemoved(
+    "Metric labeling has been reworked in Effect v4."
+  ),
+  "labelMetricsScoped": asRemoved(
+    "Metric labeling has been reworked in Effect v4."
+  ),
+  "liftPredicate": asRemoved(
+    "Use Effect.filterOrFail instead."
+  ),
+  "linkSpanCurrent": asRemoved(
+    "Use Effect.linkSpans instead."
+  ),
+  "locally": asRemoved(
+    "FiberRef.locally has been removed. Use Effect.provideService with ServiceMap.Reference instead."
+  ),
+  "locallyScoped": asRemoved(
+    "FiberRef.locally has been removed. Use Effect.provideService with ServiceMap.Reference instead."
+  ),
+  "locallyScopedWith": asRemoved(
+    "FiberRef.locally has been removed. Use Effect.provideService with ServiceMap.Reference instead."
+  ),
+  "locallyWith": asRemoved(
+    "FiberRef.locally has been removed. Use Effect.provideService with ServiceMap.Reference instead."
+  ),
+  "logAnnotations": asRemoved(
+    "Use Effect.annotateLogs instead."
+  ),
+  "loop": asRemoved(
+    "Use Effect.whileLoop or recursion with Effect.suspend instead."
+  ),
+  "mapAccum": asRemoved(
+    "Use Effect.gen with a mutable accumulator instead."
+  ),
+  "mapErrorCause": asRemoved(
+    "Use Effect.sandbox and Effect.mapError instead."
+  ),
+  "mapInputContext": asRemoved(
+    "Use Effect.provide with a layer instead."
+  ),
+  "merge": asRemoved(
+    "Use Effect.match or Effect.exit instead."
+  ),
+  "mergeAll": asRemoved(
+    "Use Effect.forEach with a mutable accumulator instead."
+  ),
+  "metricLabels": asRemoved(
+    "Metric labeling has been reworked in Effect v4."
+  ),
+  "negate": asRemoved(
+    "Use Effect.map with boolean negation instead."
+  ),
+  "none": asRemoved(
+    "Use Effect.filterOrFail or Effect.option instead."
+  ),
+  "once": asRemoved(
+    "Use Effect.cached instead."
+  ),
+  "optionFromOptional": asRemoved(
+    "Use Effect.option instead."
+  ),
+  "orDieWith": asRemoved(
+    "Use Effect.orDie or Effect.mapError combined with Effect.orDie instead."
+  ),
+  "orElse": asRemoved(
+    "Use Effect.catch or Effect.matchEffect instead."
+  ),
+  "orElseFail": asRemoved(
+    "Use Effect.mapError instead."
+  ),
+  "parallelErrors": asRemoved(
+    "Use Effect.all with concurrency options instead."
+  ),
+  "parallelFinalizers": asRemoved(
+    "Finalizer ordering configuration has been removed in Effect v4."
+  ),
+  "patchFiberRefs": asRemoved(
+    "FiberRef has been replaced by ServiceMap.Reference in Effect v4."
+  ),
+  "patchRuntimeFlags": asRemoved(
+    "Runtime flags have been removed in Effect v4."
+  ),
+  "raceWith": asRemoved(
+    "Use Effect.race or Effect.raceFirst instead."
+  ),
+  "random": asRemoved(
+    "Use Effect.randomWith instead."
+  ),
+  "randomWith": asRemoved(
+    "Random access has been reworked in Effect v4."
+  ),
+  "reduce": asRemoved(
+    "Use Effect.forEach with a mutable accumulator or Effect.gen instead."
+  ),
+  "reduceEffect": asRemoved(
+    "Use Effect.forEach with a mutable accumulator or Effect.gen instead."
+  ),
+  "reduceRight": asRemoved(
+    "Use Effect.forEach with a mutable accumulator or Effect.gen instead."
+  ),
+  "reduceWhile": asRemoved(
+    "Use Effect.gen with early return instead."
+  ),
+  "repeatN": asRemoved(
+    "Use Effect.repeat with a schedule instead."
+  ),
+  "runRequestBlock": asRemoved(
+    "The request batching API has been reworked in Effect v4."
+  ),
+  "scheduleForked": asRemoved(
+    "Use Effect.schedule combined with Effect.forkChild instead."
+  ),
+  "sequentialFinalizers": asRemoved(
+    "Finalizer ordering configuration has been removed in Effect v4."
+  ),
+  "serviceConstants": asRemoved(
+    "Service helpers have been removed. Use ServiceMap.Service and yield* to access services."
+  ),
+  "serviceFunction": asRemoved(
+    "Service helpers have been removed. Use ServiceMap.Service and yield* to access services."
+  ),
+  "serviceFunctionEffect": asRemoved(
+    "Service helpers have been removed. Use ServiceMap.Service and yield* to access services."
+  ),
+  "serviceFunctions": asRemoved(
+    "Service helpers have been removed. Use ServiceMap.Service and yield* to access services."
+  ),
+  "serviceMembers": asRemoved(
+    "Service helpers have been removed. Use ServiceMap.Service and yield* to access services."
+  ),
+  "setFiberRefs": asRemoved(
+    "FiberRef has been replaced by ServiceMap.Reference in Effect v4."
+  ),
+  "step": asRemoved(
+    "The request batching API has been reworked in Effect v4."
+  ),
+  "summarized": asRemoved(
+    "Use Effect.gen to capture before/after state instead."
+  ),
+  "supervised": asRemoved(
+    "Supervision has been reworked in Effect v4."
+  ),
+  "tagMetrics": asRemoved(
+    "Metric labeling has been reworked in Effect v4."
+  ),
+  "tagMetricsScoped": asRemoved(
+    "Metric labeling has been reworked in Effect v4."
+  ),
+  "takeUntil": asRemoved(
+    "Use Array.takeUntil and Effect.forEach instead."
+  ),
+  "takeWhile": asRemoved(
+    "Use Array.takeWhile and Effect.forEach instead."
+  ),
+  "tapBoth": asRemoved(
+    "Use Effect.tap and Effect.tapError instead."
+  ),
+  "timedWith": asRemoved(
+    "Use Effect.timed instead."
+  ),
+  "timeoutFail": asRemoved(
+    "Use Effect.timeout combined with Effect.catchTag for TimeoutException instead."
+  ),
+  "timeoutFailCause": asRemoved(
+    "Use Effect.timeout combined with Effect.sandbox instead."
+  ),
+  "timeoutTo": asRemoved(
+    "Use Effect.timeoutOption and Effect.map instead."
+  ),
+  "tracerWith": asRemoved(
+    "Use Effect.tracer instead."
+  ),
+  "transplant": asRemoved(
+    "Fiber transplanting has been removed in Effect v4."
+  ),
+  "transposeMapOption": asRemoved(
+    "Use Effect.map with Option operations instead."
+  ),
+  "transposeOption": asRemoved(
+    "Use Effect.option instead."
+  ),
+  "tryMap": asRemoved(
+    "Use Effect.map inside Effect.try instead."
+  ),
+  "tryMapPromise": asRemoved(
+    "Use Effect.tryPromise instead."
+  ),
+  "unless": asRemoved(
+    "Use Effect.when with a negated condition instead."
+  ),
+  "unlessEffect": asRemoved(
+    "Use Effect.when with a negated effectful condition instead."
+  ),
+  "unsafeMakeLatch": asRemoved(
+    "Use Effect.makeLatch instead."
+  ),
+  "unsafeMakeSemaphore": asRemoved(
+    "Use Effect.makeSemaphore instead."
+  ),
+  "unsandbox": asRemoved(
+    "Use Effect.catchCause instead."
+  ),
+  "updateFiberRefs": asRemoved(
+    "FiberRef has been replaced by ServiceMap.Reference in Effect v4."
+  ),
+  "using": asRemoved(
+    "Use Effect.scoped instead."
+  ),
+  "validateAll": asRemoved(
+    "Use Effect.all with { mode: 'validate' } instead."
+  ),
+  "validateFirst": asRemoved(
+    "Use Effect.all with { mode: 'validate' } instead."
+  ),
+  "validateWith": asRemoved(
+    "Use Effect.all with { mode: 'validate' } instead."
+  ),
+  "whenEffect": asRemoved(
+    "Use Effect.when with an effectful condition via Effect.flatMap instead."
+  ),
+  "whenFiberRef": asRemoved(
+    "FiberRef has been replaced by ServiceMap.Reference in Effect v4."
+  ),
+  "whenLogLevel": asRemoved(
+    "Log level checking has been reworked in Effect v4."
+  ),
+  "whenRef": asRemoved(
+    "Use Ref.get and Effect.when instead."
+  ),
+  "withClock": asRemoved(
+    "Clock configuration has been reworked in Effect v4."
+  ),
+  "withClockScoped": asRemoved(
+    "Clock configuration has been reworked in Effect v4."
+  ),
+  "withConfigProvider": asRemoved(
+    "ConfigProvider configuration has been reworked in Effect v4."
+  ),
+  "withConfigProviderScoped": asRemoved(
+    "ConfigProvider configuration has been reworked in Effect v4."
+  ),
+  "withConsole": asRemoved(
+    "Console configuration has been reworked in Effect v4."
+  ),
+  "withConsoleScoped": asRemoved(
+    "Console configuration has been reworked in Effect v4."
+  ),
+  "withEarlyRelease": asRemoved(
+    "Use Effect.scoped with manual resource management instead."
+  ),
+  "withFiberRuntime": asRenamedAndNeedsOptions(
+    "withFiber",
+    "Note: in v4, only the Fiber is provided (not the full FiberRuntime with status). The callback receives (fiber: Fiber<unknown, unknown>) instead of (fiber: FiberRuntime<A, E>, status: FiberStatus)."
+  ),
+  "withMaxOpsBeforeYield": asRemoved(
+    "Use ServiceMap.Reference for MaxOpsBeforeYield configuration instead."
+  ),
+  "withMetric": asRemoved(
+    "Metric configuration has been reworked in Effect v4."
+  ),
+  "withRandom": asRemoved(
+    "Random configuration has been reworked in Effect v4."
+  ),
+  "withRandomFixed": asRemoved(
+    "Random configuration has been reworked in Effect v4."
+  ),
+  "withRandomScoped": asRemoved(
+    "Random configuration has been reworked in Effect v4."
+  ),
+  "withRequestBatching": asRemoved(
+    "Request batching configuration has been reworked in Effect v4."
+  ),
+  "withRequestCache": asRemoved(
+    "Request caching configuration has been reworked in Effect v4."
+  ),
+  "withRequestCaching": asRemoved(
+    "Request caching configuration has been reworked in Effect v4."
+  ),
+  "withRuntimeFlagsPatch": asRemoved(
+    "Runtime flags have been removed in Effect v4."
+  ),
+  "withRuntimeFlagsPatchScoped": asRemoved(
+    "Runtime flags have been removed in Effect v4."
+  ),
+  "withScheduler": asRemoved(
+    "Use ServiceMap.Reference for Scheduler configuration instead."
+  ),
+  "withSchedulingPriority": asRemoved(
+    "Scheduling priority configuration has been removed in Effect v4."
+  ),
+  "withTracerScoped": asRemoved(
+    "Use Effect.withTracer instead."
+  ),
+  "withUnhandledErrorLogLevel": asRemoved(
+    "Use ServiceMap.Reference for UnhandledLogLevel configuration instead."
+  ),
+  "zipLeft": asRemoved(
+    "Use Effect.tap instead of Effect.zipLeft."
+  ),
+  "zipRight": asRemoved(
+    "Use Effect.andThen instead of Effect.zipRight."
+  )
+};
+
+// src/diagnostics/outdatedApi.ts
+var outdatedApi = createDiagnostic({
+  name: "outdatedApi",
+  code: 48,
+  description: "Detects usage of APIs that have been removed or renamed in Effect v4",
+  severity: "warning",
+  apply: fn("outdatedApi.apply")(function* (sourceFile, report) {
+    const typeParser = yield* service(TypeParser);
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    if (typeParser.supportedEffect() === "v3") return;
+    let hasReported = false;
+    function reportMigration(propertyAccess, propertyName, _migration) {
+      hasReported = true;
+      report({
+        location: propertyAccess.name,
+        messageText: `${propertyName} is an Effect v3 API, but the project is using Effect v4.`,
+        fixes: []
+      });
+    }
+    const checkPropertyAccessMigration = (propertyAccess, checkRightNode, migrationDb) => {
+      if (!ts.isPropertyAccessExpression(propertyAccess)) return;
+      const identifier2 = propertyAccess.name;
+      if (!ts.isIdentifier(identifier2)) return;
+      const identifierName = ts.idText(identifier2);
+      const migration = migrationDb[identifierName];
+      if (!migration) return;
+      if (migration._tag === "Unchanged") return;
+      const targetType = typeCheckerUtils.getTypeAtLocation(propertyAccess.expression);
+      if (!targetType) return;
+      const targetPropertySymbol = typeChecker.getPropertyOfType(targetType, identifierName);
+      if (targetPropertySymbol) return;
+      return pipe(
+        checkRightNode(propertyAccess.expression),
+        map5(() => reportMigration(propertyAccess, identifierName, migration)),
+        ignore
+      );
+    };
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      const checkEffectMigration = checkPropertyAccessMigration(
+        node,
+        typeParser.importedEffectModule,
+        effectModuleMigrationDb
+      );
+      if (checkEffectMigration) {
+        yield* ignore(checkEffectMigration);
+      }
+    }
+    if (hasReported) {
+      report({
+        location: { pos: 0, end: 0 },
+        messageText: "This project targets Effect v4, but is using Effect v3 APIs. To find the correct API to use, clone and consult the github.com/effect-ts/effect-smol repository for the corresponding v4 replacement.",
+        fixes: []
+      });
+    }
+  })
+});
+
 // src/diagnostics/outdatedEffectCodegen.ts
 var outdatedEffectCodegen = createDiagnostic({
   name: "outdatedEffectCodegen",
@@ -10962,6 +11791,7 @@ var unsupportedServiceAccessors = createDiagnostic({
 
 // src/diagnostics.ts
 var diagnostics = [
+  outdatedApi,
   anyUnknownInErrorContext,
   instanceOfSchema,
   catchAllToMapError,
@@ -11130,7 +11960,7 @@ var effectSchemaSelfInClasses = createCompletion({
       );
       if (hasTaggedErrorCompletion) {
         completions2.push({
-          name: `TaggedError<${name}>`,
+          name: `TaggedErrorClass<${name}>`,
           kind: ts.ScriptElementKind.constElement,
           insertText: isFullyQualified ? `${schemaIdentifier}.TaggedErrorClass<${name}>()("${errorTagKey}", {${"${0}"}}){}` : `TaggedErrorClass<${name}>()("${errorTagKey}", {${"${0}"}}){}`,
           replacementSpan,
@@ -11187,6 +12017,33 @@ var effectSchemaSelfInClasses = createCompletion({
         });
       }
     }
+    if (typeParser.supportedEffect() === "v4") {
+      const modelIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect/unstable/schema",
+        "Model"
+      ) || tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect/unstable",
+        "Model"
+      ) || "Model";
+      const isModelFullyQualified = modelIdentifier === ts.idText(accessedObject);
+      const hasModelClassCompletion = isModelFullyQualified || isSome2(
+        yield* pipe(
+          typeParser.isNodeReferenceToEffectSchemaModelModuleApi("Class")(accessedObject),
+          option
+        )
+      );
+      if (hasModelClassCompletion) {
+        completions2.push({
+          name: `Class<${name}>`,
+          kind: ts.ScriptElementKind.constElement,
+          insertText: isModelFullyQualified ? `${modelIdentifier}.Class<${name}>("${name}")({${"${0}"}}){}` : `Class<${name}>("${name}")({${"${0}"}}){}`,
+          replacementSpan,
+          isSnippet: true
+        });
+      }
+    }
     return completions2;
   })
 });