@effect/tsgo

Patch Changes

• 1ab5264: effect-tsgo diagnostics now reports a diagnostic's related locations. They used to be dropped in every format, so missingEffectContext never showed which layer could provide the missing service and apiStabilityLeak never showed where the unstable declaration lives.

  With --format json, each diagnostic that has related locations gets a relatedInformation array. Each entry has the same location fields as the diagnostic, plus its own code and message. Diagnostics without related locations are unchanged.

  {
    "line": 23,
    "column": 3,
    "code": 377004,
    "name": "missingEffectContext",
    "message": "This Effect requires a service that is missing from the expected Effect context: `Db | Fs`.",
    "relatedInformation": [
      {
        "file": ".../src/index.ts",
        "start": 662,
        "length": 14,
        "line": 22,
        "column": 3,
        "endLine": 22,
        "endColumn": 17,
        "code": 377059,
        "message": "Adjusting this layer composition could provide the missing service."
      }
    ]
  }

  With --format pretty, the related locations are printed under the diagnostic, each with its own code snippet, as tsc --pretty does:

  src/index.ts:23:3 - error effect(missingEffectContext): This Effect requires a service that is missing from the expected Effect context: `Db | Fs`.
  
  23   Effect.runPromise
       ~~~~~~~~~~~~~~~~~
  
    src/index.ts:22:3 - Adjusting this layer composition could provide the missing service.
      22   Effect.provide(live),
           ~~~~~~~~~~~~~~

  The ~ markers in pretty output are also aligned again on lines 10 and above. They used to sit one column to the left of the code.

• 4672ba1: Make globalDate and globalDateInEffect do less work per file. Their shared walker used to look up the Effect context flags of every node it visited, although only call expressions (Date.now()) and new expressions (new Date()) can produce a diagnostic. It now looks up the flags only on those two node kinds, like globalFetch, globalConsole, globalTimers, globalRandom and cryptoRandomUUID already do.

  Reported diagnostics are unchanged.

• b5df4e9: Speed up apiStabilityLeak by reusing one stability analysis per file.

  The rule used to allocate a fresh analysis, with its maps and work queues, for every export of a file. It now keeps one analysis per file and resets it before each export. The reset analysis behaves exactly like a fresh one, so the reported diagnostics are unchanged. A published surface that a later export reads from the shared cache is no longer queued for publication again, and a published surface without retained findings no longer allocates a findings map.

  On packages/effect of effect 4.0.5 with every rule enabled, the rule allocates 252 MB → 140 MB.

• d3b53a7: Make the Effect diagnostics write less to the checker's per-node caches. Rules run on the checker goroutine right after each file is checked, and on the Effect monorepo most of their cost was cache traffic (map misses, nil inserts, map growth) and the garbage collection it caused, not type computation.

  • Reference checks such as "is this node Effect.gen?" no longer probe or fill the symbol cache for statements, blocks, clauses and tokens, which can never resolve to a symbol.

  • The analysis that tracks whether code runs inside Effect.gen, Effect.fn or an Effect thunk stores an entry only where the answer changes, about 2% of nodes, instead of two entries for every node of every file.

  • Type lookups reject nodes that can never have a type before touching the cache, the strict Effect type check caches only types named Effect, and whether a file has been checked is asked once per file instead of on every query.

  Reported diagnostics are unchanged.

Patch Changes

• c75c219: Make apiStabilityLeak allocate less. The rule used to create an empty findings map for every type, signature and symbol it inspected, and to copy the stored findings into a new map every time it re-checked an unresolved result. Most results never get a finding, and most re-checks add nothing. A result's map is now created when it gets its first finding, and a re-check that adds nothing keeps the stored map instead of copying it.

  For example, on the Effect monorepo the rule allocated 605 MB in 5.3 M objects before and 496 MB in 3.4 M objects after. Its CPU went from 3.4 s to 3.2 s.

  Reported diagnostics are unchanged.

• 0076e24: Make apiStabilityLeak faster on namespace exports. The rule checks each member of a namespace export in one shared analysis, and every member used to re-check every unresolved result that earlier members left behind. A namespace with thousands of members did millions of repeated checks. Each member now re-checks only the results its own check reached.

  For example, on the Effect monorepo the Generated namespace export of @effect/ai-openai has 3,603 members. Across the whole repository the rule used 22.8 s of CPU before and 3.4 s after.

  Reported diagnostics are unchanged.

• 410f21e: Rules now read the type the checker computed for an expression while it checked the file, instead of asking the checker again afterwards. Asking again repeated work, such as flow analysis, and in a few cases gave a different type than the check used. For example, a return literal checked while its enclosing generic call was still resolving:

  export const takeWhileDefined = dual(2, <A>(self: Iterable<A>, f: (input: A) => A | undefined) => ({
    [Symbol.iterator]() {
      const iterator = self[Symbol.iterator]()
      return {
        next() {
          const result = iterator.next()
          if (result.done) {
            // the check typed this as { done: boolean; value: undefined }
            // asking again gave { done: true; value: undefined }
            return { done: true, value: undefined }
          }
          return { done: false, value: f(result.value) }
        }
      }
    }
  }))

  Rules now see { done: boolean; value: undefined }, the type the rest of the check is based on.

• c5d3d7a: Resolve Effect API references once per symbol. IsNodeReferenceToModuleExport used to answer "is this symbol exported as gen?" one member name at a time, caching each answer in a per-symbol map. It now computes, once per symbol, the names its declaring module exports it under, from a per-module index of exports keyed the way the checker compares symbols, and answers every member name from that list. export = modules keep the direct lookup.

  For example, checking whether a callee is Effect.gen, Effect.fn or Effect.sync now reads one cached list (["gen"] for Effect.gen) instead of hashing three cache keys.

  With 125 rules enabled on the Effect monorepo, wall time, CPU time and peak memory are unchanged within noise, and the reported diagnostics are unchanged.

• f02bf75: Skip Effect type queries for more expressions that always produce a primitive or a RegExp. NodeCannotBeEffectLibraryType now also rules out true, false, null, regular expression literals, prefix unary expressions such as !x and -x, void x and typeof x. The undefined identifier still goes through the checker, because a local binding can shadow it.

  For example, for return true inside Effect.gen, returnEffectInGen no longer asks the checker for the type of true.

  Reported diagnostics are unchanged.

• 67d58fc: Add a Perf workflow that compares each pull request against its base for every supported TypeScript channel. Each job runs stock and Effect-patched tsgo on a pinned Effect checkout with every rule executing, and a sticky PR comment reports the change in symbols, types, instantiations, allocations, and check and total time over stock. Run it locally with repoctl perf ci and repoctl perf report.

• 01f337a: Report each problem once in effectInFailure, anyUnknownInErrorContext and promiseInEffectSuccess. These rules check the type of every node in a file, and the checker gives some pairs of nodes the same type. A declaration and its name share a type, and so do a.b and its name b. The rules now check one node of each pair.

  A variable whose initializer has the problem used to get two warnings, one on the variable name and one on the initializer. Now only the initializer is reported:

  // before: warnings on `shouldReport` and on `Effect.try(...)`
  // after: one warning on `Effect.try(...)`
  export const shouldReport = Effect.try({
    try: () => JSON.parse("{"),
    catch: (e) => Effect.log(e)
  })

  A property access is now reported over the whole expression promiseEffectHolder.current instead of the name current.

  anyUnknownInErrorContext keeps only the innermost warning when nested expressions report the same problem. It used to drop an outer warning whenever any warning inside it reported something. Now it drops the outer warning only when an inner warning reports every channel the outer one does, with the same any or unknown. An outer unknown error channel that comes from an explicit type argument is still reported when the inner expressions only have any:

  declare const anyFailure: Effect.Effect<number, any>
  // warnings on `Effect.withFiber(...)` (unknown in the error channel) and on `anyFailure` (any)
  export const keepsDifferentKind = Effect.withFiber<number, unknown>(() => anyFailure)

Minor Changes

• 13a46c9: The deterministicKeys rule and the key completions now compute a key for files without a package.json, or whose nearest package.json has no name. The key is built as usual, but without the package name. The sub-directory segment is relative to the package.json directory if one is found, otherwise to the tsconfig.json directory, otherwise to the program's common source directory.

  Projects that enabled deterministicKeys without a package.json will now see reports. This differs from the upstream @effect/language-service, which skips these files.

  {
    "name": "@effect/language-service",
    "keyPatterns": [{ "target": "service", "pattern": "default" }]
  }

  // src/services/AuthService.ts, no package.json, tsconfig.json at the project root
  // reports: the expected key is `services/AuthService/MyService`
  export class MyService extends Context.Service<MyService, {}>()("MyService") {}

• d8c489b: Add errorPayloadShadowsName to detect inline name payload fields on Effect error classes. For example, Data.TaggedError("ToolNotFound")<{ name: string }> copies the payload's name onto the error instance and hides the error type in logs. Rename the field to toolName. The rule inspects inline payloads only and allows a field whose value is the literal the error already uses as its name.

• 13a46c9: Add an "identifier" pattern to keyPatterns for the deterministicKeys rule. With it, the expected key is the class name alone.

  {
    "name": "@effect/language-service",
    "keyPatterns": [{ "target": "error", "pattern": "identifier" }]
  }

  // reports: the expected key is `KeybindingsConfigError`
  export class KeybindingsConfigError extends Data.TaggedError("KeybindingsConfigParseError")<{}> {}

• b1ed4ba: Add preferNamespaceImport and preferBarrelImport, two diagnostics that report existing imports that contradict the import style configured with namespaceImportPackages and barrelImportPackages. Auto-import already follows these options; the new rules also cover imports written by hand. Both are off by default and have no quick fix.

  preferNamespaceImport reports named imports from packages in namespaceImportPackages:

  // "namespaceImportPackages": ["effect"]
  import { Effect } from "effect" // expected: import * as Effect from "effect/Effect"
  import { map } from "effect/Array" // expected: import * as Array from "effect/Array"
  import { pipe } from "effect" // reported only with "topLevelNamedReexports": "follow"

  preferBarrelImport reports imports of individual modules from packages in barrelImportPackages:

  // "barrelImportPackages": ["effect"]
  import * as Record from "effect/Record" // expected: import { Record } from "effect"
  import * as HttpClient from "effect/http/HttpClient" // expected: import { HttpClient } from "effect/http"

  Both the rules and auto-import find a barrel from the package files, for any package, instead of from a built-in list of Effect paths. A module's barrel is the nearest index module above it that forwards it with export * as Name, and Name is the import name used. Barrel files are read from disk when no file in the program imports them yet. Auto-import with barrelImportPackages uses the same lookup, so it no longer rewrites a module that no barrel forwards, and no longer rewrites an import that already comes from a barrel (such as pipe from "effect") into import { effect } from "effect".

• b1ed4ba: Allow namespaceImportPackages, barrelImportPackages, importAliases, and topLevelNamedReexports in per-file overrides. Auto-import, the import quick fixes, and the preferNamespaceImport and preferBarrelImport diagnostics use the value resolved for the current file, and a scoped value replaces the base value.

  {
    "namespaceImportPackages": ["effect"],
    "overrides": [{
      "include": ["src/legacy/**/*.ts"],
      "options": {
        "namespaceImportPackages": [],
        "barrelImportPackages": ["effect"]
      }
    }]
  }

Patch Changes

• 61eb79c: Compute Effect diagnostics with less work. Rules and the type parser now test node kinds, shapes and argument counts before they query types, symbols or signatures, and they compute types only for steps that can still report:

  • IsNodeReferenceToModuleExport answers symbols with no declaration in the requested module from a per-symbol bitmask instead of a per-symbol map.

  • DataFirstOrLastCall checks the cached signature shape before it types call arguments, and caches its result per call.

  • missedPipeableOpportunity, catchDieToOrDie and preferTypedSchemaDecoder type piping-flow steps only when a step matches.

  • The experimentalApiUsage and unstableApiUsage rules reuse their own symbol lookup instead of repeating it.

  With every rule enabled, tsc -b of the Effect monorepo drops from 33.9s to 32.1s (stock TypeScript-Go: 20.4s). The reported diagnostics are unchanged.

• cb5739d: Update the TypeScript next tag to typescript@next, which ships typescript-go commit b5c34ba0c61a756c8abaf133236dddf982c27f45, and update the TypeScript latest tag to typescript@latest. Refresh the Oxlint configuration schema from the selected package.

Minor Changes

• 3e4a55d: Route Effect contextual-type queries through TypeParser.GetContextualType and enforce the wrapper with customlint. For example, use tp.GetContextualType(node, checker.ContextFlagsNone) instead of the checker method. Query behavior stays unchanged, with one place to add contextual-type safety guards in future changes.

• 0269634: Add effectSleepZeroToYieldNow, a style suggestion with a quick fix for zero-duration Effect.sleep calls.

  For example, Effect.sleep(0) becomes Effect.yieldNow() in Effect v3 and Effect.yieldNow in Effect v4. The rule also recognizes safe zero-duration strings, tuples, and Duration constructors. The replacement yields through the fiber scheduler instead of the Clock service.

• 181b2b3: Add the flatMapToTap style suggestion and quick fix for Effect v3 and v4. Callbacks that run an effect and restore their unchanged parameter with terminal Effect.as or Effect.map can use Effect.tap instead. The fix preserves callback statements and earlier effect transformations.

• 7d051dd: Route internal symbol and type location queries through TypeParser and enforce this with customlint. Reuse the existing TypeParser throughout pipeable signature comparison.

  Prevent false TS2790 diagnostics for valid index-signature deletes such as declare const map: { [key: string]: number }; delete map.x;. Symbol queries skip deleted property accesses and their names, including parenthesized and optional targets. Receiver and computed-key queries remain available, and invalid required-property and readonly deletes still report compiler errors.

• f178ff2: Add the opt-in preferEffectArray diagnostic in effectNative for native Array method calls and references. It suggests 16 corresponding Effect Array APIs and explains migration differences, such as values.find(predicate) becoming Array.findFirst(values, predicate) with an Option result.

  The rule is disabled by default and enabled as a warning by the effect-native preset. It supports readonly arrays, tuples, aliases, and literal bracket access. Native Array recognition uses a lazy cache shared per checker. Conversion autofixes are not included.

• f59b4b8: Add the opt-in preferEffectRecord diagnostic in effectNative for native Object calls and references. It suggests Record.keys, Record.values, Record.toEntries, Record.fromEntries, and Record.has, including native hasOwnProperty references.

  Each suggestion explains input typing or runtime differences. For example, Object.entries(data) suggests Record.toEntries(data) with typed keys and a caveat about getter or proxy mutations. data.hasOwnProperty(key) suggests passing the receiver explicitly to Record.has(data, key).

  The rule defaults to off and the effect-native preset enables it as a warning. Both Effect v3 and v4 are supported. Only suppression quick fixes are available.

• 2672190: Add the opt-in preferSchemaTaggedError diagnostic for Effect v3 and v4. It suggests Schema.TaggedError for class declarations that extend Data.TaggedError, including anonymous default exports. For example, class NotFound extends Data.TaggedError("NotFound")<{ id: string }> {} reports a warning when the rule is enabled.

• ab20f55: Expose parser results through getters and readonly collection views. For Go consumers, result.A becomes result.A(), and flow.Transformations[i] becomes flow.Transformations().At(i). Collection views support iteration and explicit owned copies. Compiler AST and type pointers remain borrowed.

• c4aa628: Include { readonly brand: unique symbol } in Effect v4 Schema class completions for Class, TaggedClass, Error, and TaggedError. Add a branded completion for Schema.Opaque.

  For example, the Class<Person> completion inserts Schema.Class<Person, { readonly brand: unique symbol }>("Person"). Effect v3 and Model.Class completions keep their existing type arguments.

• 22f6106: Add schemaClassMissingBrand, a correctness suggestion enabled by default for Effect v4 schema classes, errors, and opaque classes.

  The diagnostic suggests adding a brand when the second brand type argument is omitted. For example, Schema.Class<Person>("Person") triggers a suggestion, while Schema.Class<Person, { readonly brand: unique symbol }>("Person") supplies a nominal brand. An explicit {} keeps structural typing and suppresses the suggestion. Effect v3 is excluded.

• d565ab8: Recognize Predicate.isTagged(value, "Foo") and Predicate.isTagged("Foo")(value) as tag comparisons in dispatch analysis. Existing catch-tag diagnostics and quick fixes now handle both forms in Effect v3 and v4.

Patch Changes

• 4ceb27f: Reduce repeated type inference when checking experimental and unstable properties in generic object literals.

• e57688f: Clear an inherited Effect plugin when a child tsconfig defines an empty or replacement plugins list.

• 9696634: Report experimental and unstable properties supplied in contextually typed object literals, including shorthand properties. For example, x({ test: 42 }) and x({ test }) now warn when the parameter type marks test with @stability experimental, even if the function and interface are stable.

• 0dfc0be: Fix a crash in the "Convert to Effect.fn" refactor when gen is a named import or a local alias.

  import { gen } from "effect/Effect"
  export const foo = () => gen(function*() { return 1 })

  Requesting code actions on gen used to fail the whole textDocument/codeAction request with a nil pointer panic. The refactor now rewrites to Effect.fn, using the file's existing Effect import name when there is one:

  import { gen } from "effect/Effect"
  export const foo = Effect.fn("foo")(function* () { return 1; });

  The refactor does not add a missing Effect import. The user adds it.

• 6107975: Update the shim generator's Go tools dependency to support Go 1.27.2 export data and restore compiler setup.

  Preserve pointers to unexported structs in generated shim mirrors so fields that follow them retain their offsets and accessors return the correct values.

• 8e0b5bf: Resolve the types carried by typeparser results only when a rule reads them, and reuse the resolved type on later reads. For example, a piping flow no longer queries the type of every transformation up front, so a rule that filters flows by callee skips those queries. Diagnostics are unchanged.

• 6512cfb: Cache module export checks per symbol. Rules check whether most identifiers and callees refer to a module export, such as gen, fn, or map from the effect package's Effect module. Each symbol now gets a slot in a paged array indexed by symbol id, the layout the TypeScript 7.1 checker uses for its own symbol caches. The slot holds a small map of answers keyed by module and member name. Before, every answer shared one large hash map. For example, tsc -b on the Effect monorepo with every rule enabled runs about 1% faster with identical diagnostics. On TypeScript 7.0.2, which lacks block-allocated symbol ids, the per-symbol slots stay in a hash map.

• b780f66: Fix the Effect.fn and async-to-Effect refactors for functions nested inside another declaration's value. A function in a catch binding default no longer makes the code action request fail, and a function in an object, array, call argument, class field, or later declarator is now replaced in place instead of overwriting the whole value. For example, converting task in export const inObject = { task: () => Effect.gen(function*() { return 1 }) } now produces export const inObject = { task: Effect.fn(function* () { return 1; }) }.

• 959570b: Store the Effect caches that cover most nodes of a file in paged arrays indexed by node id, the layout the TypeScript 7.1 checker uses for its own hottest node caches. A lookup now indexes an array instead of hashing a node pointer. For example, tsc -b on the Effect monorepo runs about 2% faster with identical diagnostics. On TypeScript 7.0.2, which lacks block-allocated node ids, these caches stay hash maps.

• 60eac10: Run Effect diagnostics after TypeScript checks unused identifiers so plugin symbol queries cannot suppress TS6133. For example, with noUnusedParameters enabled, export function unusedPredicate(value: unknown): value is number { return true; } now reports the unused value parameter with the plugin enabled, just as it does with the plugin disabled.

• removed

  7450a52: Remove the debug plugin option and the debug-only Flows group from the document outline.

• 3e4a55d: Cache object-literal contextual types per checker across experimental and unstable API diagnostics. Keep normal and inference-blocked queries separate, including nil results, to avoid repeating the same contextual-type queries.

• 4d9fba4: Ship the latest TypeScript compiler once in each platform package. It was packaged twice, as lib/tsc and as artifacts/typescript/<latest>/tsc, each with its own lib.*.d.ts files. It now ships only as lib/tsc, which makes @effect/tsgo-darwin-arm64 29 MB smaller unpacked.

  get-exe-path, diagnostics, patch and getExePath() resolve the latest TypeScript version to lib/tsc and other versions to artifacts/typescript/<version>/tsc. Tools that run lib/tsc directly keep working.

• 3e4a55d: Prevent false TypeScript iterator and object-spread diagnostics when experimental or unstable API checks query generic constraints inside inferred generator function expressions. Skip inference-blocked contextual queries in these expressions while retaining normal contextual lookups. This conservative fallback can omit constraint-based property warnings inside inferred generators.

• da2f46d: Skip type queries for expressions that can never have an Effect library type, such as literals, functions and, on Effect v4, plain object literals. Diagnostics are unchanged, but they are cheaper to compute: on the Effect monorepo a tsc -b build is about 1.3s faster with the default rules and about 2.4s faster with every rule except apiStabilityLeak enabled.

  For example, rules such as effectInVoidSuccess no longer ask the checker for the type of the array and object literal arguments here, because neither can be an Effect:

  Effect.forEach([1, 2, 3], (n) => Effect.log(n), { concurrency: 2 })

• 1c7cbf9: Update Effect v4 dependencies and test fixtures from 4.0.0-rc.118 to stable 4.0.2. Align @effect/platform-node, @effect/platform-node-shared, and @effect/vitest with the same release.

• fea53cc: Use the configured keyPatterns for Data.TaggedError and Schema.TaggedError completions, so the inserted tag already matches the key expected by deterministicKeys.

  For example, with { "target": "error", "pattern": "package-identifier" } in keyPatterns, completing class NotFound extends Data. in src/errors.ts of package @app/core now inserts Data.TaggedError("@app/core/errors/NotFound")<{}>{} instead of Data.TaggedError("NotFound")<{}>{}. Without an error key pattern the completion still uses the class name.

• cb7567e: Support both field-based and method-based compiler symbols through generated shim helpers.

• 7450a52: Update the TypeScript next tag to typescript@next, which ships typescript-go commit d61a7d235906e78be9b111de0ba060e28e67ecfa, and update the TypeScript latest tag to typescript@latest.

Minor Changes

• b67ef81: Update the Effect v4 integration to 4.0.0-rc.118 and use its public module paths. Namespace auto-imports for nested modules now resolve to paths such as effect/cli/Prompt.

• 66668e2: Add the experimentalApiUsage and unstableApiUsage diagnostics for APIs marked with @stability experimental or @stability unstable. Both rules warn by default. For example, a reference to an unstable API now reports that breaking changes may happen between versions.

Patch Changes

• 8067475: Fix getExePath rejecting the schema version shipped by platform packages.

  Discover installed Oxlint musl bindings without rejecting them before component selection, so TypeScript-only commands work when Oxlint is installed on Alpine Linux. Report unsupported Oxlint replacements during patch preparation instead, allowing --skip-missing and restoring original binaries with unpatch.

• 2e215ce: Update the TypeScript next tag to typescript@next, which ships typescript-go commit 4f5ddae224b9529a69b571f631fe3a2cb283162f, and update the TypeScript latest tag to typescript@latest. Refresh the Oxlint configuration schema from the selected package.

Patch Changes

• 09644ee: effect-tsgo diagnostics now reports files it skipped because their tsconfig does not enable the @effect/language-service plugin, instead of only printing Checked 0 files out of N files. The JSON summary gains a matching filesWithoutPlugin count.

  Checked 0 files out of 8 files.
  Skipped 8 files because their tsconfig does not enable the @effect/language-service plugin.
  0 errors, 0 warnings and 0 messages.

• dfa24e8: Fix effectFnOpportunity conversions to preserve enclosing expressions, sibling declarations, comments, literal spelling, and source formatting. Avoid suggesting conversions for function declarations referenced before their declaration.

  Wrap non-call pipe arguments in unary callbacks so they do not receive the converted function's arguments. For example, .pipe(Effect.ignore) becomes an Effect.fn pipeable _ => Effect.ignore(_), while factory calls such as Effect.map(f) are retained.

• 8d89b43: Deduplicate strictBooleanExpressions diagnostics when multiple union members display the same type name.

• 7611be0: Preserve Effect plugin options in the Oxlint integration when tsconfig.json uses extends, whether the options are inherited or declared locally. For example, effectFn: ["span", "inferred-span", "suggested-span"] now enables the same effect-fn-opportunity reports as an inline configuration without extends.

Minor Changes

• 6db6fa6: Add the catchIfTagToCatchTag diagnostic and quick fix for replacing direct _tag equality predicates in Effect.catchIf with Effect.catchTag.

• ae1ed02: Add the v4-only catchRefailToTapError diagnostic. It suggests Effect.tapError when an Effect.catch handler sequences an effect with Effect.andThen or a zero-argument Effect.flatMap callback and then fails with the original, unmodified error. Generator handlers and selective catches are excluded.

• 437b17e: Retain the latest three stable Oxlint releases and the Oxlint runtimes required by the latest three stable Vite+ releases, including their compiler dependencies. Add versioned compatibility profiles so CI tests every distinct retained runtime pair.

  The refreshed upstream metadata supports Oxlint 1.77.0, 1.79.0, 1.80.0, 1.81.0, and 1.82.0, covering Vite+ 0.2.9, 0.3.0, and 0.3.1, and advances TypeScript next to 7.1.0-dev.20260911.1.

• 223f9fa: Add the flatMapIgnoredParamToAndThen diagnostic and quick fix for replacing zero-parameter Effect.flatMap callbacks that return an existing constant Effect value with Effect.andThen. Existing diagnostics now also recognize Effect APIs referenced through constant aliases, and their quick fixes rebuild the replacement API from the source file's imported module name without modifying the shared alias.

• 7173762: Add a strict diagnostic preset that promotes every default-enabled diagnostic to an error. Expose the complete preset catalog consistently through TypeScript setup and the generated Oxlint presets.

• 9652243: Warn when diagnosticSeverity contains an unknown Effect rule name, including in overrides and inherited configurations. For example, "floatingEfect": "error" now reports effect(unknownRuleName) instead of being silently ignored.

  The check uses the fully merged configuration. Set "unknownRuleName": "off" to disable it or "unknownRuleName": "error" to raise its severity. Local keys are underlined in tsconfig; inherited keys without local syntax produce a diagnostic without a source location.

Patch Changes

• f110e11: Restore compatibility with TypeScript 7.1.0-dev.20260924.1 by updating diagnostic generation and plugin parsing patches, adapting single-file diagnostic requests to the upstream snapshot API, and regenerating compiler shims and Nix inputs.

• 7c0ddbc: Update the TypeScript next tag to typescript@next, which ships TypeScript commit f29aeb9f825d96feea27841f3f7342dbf0df68a8, and update the repository toolchain to Go 1.27.

Minor Changes

• a64e17d: Add obsoleteMatchImport diagnostic (TS377127) to warn when importing @effect/match in projects targeting Effect v4. In Effect v4, pattern matching is built directly into effect (import { Match } from "effect" or import * as Match from "effect/Match").

• 63331b6: Add obsoleteSchemaImport diagnostic (TS377128) to warn when importing @effect/schema or @effect/schema/* in projects targeting Effect v4. In Effect v4, Schema is built directly into effect (import { Schema } from "effect" or import * as Schema from "effect/Schema").

• 29733f1: Add the timeoutCatchTagToTimeoutOrElse diagnostic and quick fixes for Effect v4. Suggest Effect.timeoutOrElse for Effect.timeout followed by Effect.catchTag("TimeoutError", ...), and Effect.timeoutOption for the corresponding Some/None pattern. Only suggest a rewrite when the input error channel excludes TimeoutError and the handler does not use the caught error.

Patch Changes

• a05d76b: Reuse the normalized piping-flow shape and sequence matchers across existing diagnostics.

• d990b0a: Fix cryptoRandomUUID and cryptoRandomUUIDInEffect diagnostic messages and rule descriptions in Effect v4 to recommend the Effect Crypto module instead of Random. In Effect v4, Random does not provide randomUUID and uses non-cryptographic Math.random, whereas cryptographic UUID generation is provided by Crypto.Crypto (such as yield* crypto.randomUUIDv4).

• 7993db9: Update the TypeScript next tag to typescript@next, which ships typescript-go commit 1f70213d4922b434345f639b441681e470c7cfc1, and update the TypeScript latest tag to typescript@latest.

Minor Changes

• 7565750: Add the matchEffectToMapBoth style diagnostic and quick fix for replacing Effect.matchEffect handlers that return Effect.fail and Effect.succeed with Effect.mapBoth.

• a09feae: Add the catchAllTagDispatchToCatchTag style diagnostic and quick fix for replacing manual tagged-error dispatch with Effect.catchTag or Effect.catchTags.

• 2d501a2: Add the provideLayerSucceedToProvideService diagnostic and quick fix for replacing inline Layer.succeed and Layer.effect provision with direct service provision.

• 46c6e68: Add the matchEffectToMatch style diagnostic and quick fix for replacing Effect.matchEffect or Effect.matchCauseEffect whose handlers only return Effect.succeed with their non-effectful counterparts.

  Make lazy-expression parsing synchronous and non-generator by default, with flags for callers that explicitly accept thunks, async functions, or generators.

• 59c5fff: Adopt the piping flow parser in more diagnostics.

  • promiseInEffectSuccess: an explicit promise-success annotation (type arguments on Effect.succeed/as/map/zipWith) now suppresses the diagnostic from any position in the surrounding pipe, not only the last argument. base.pipe(Effect.as<Promise<number>>(promiseValue), Effect.as(promiseValue)) no longer reports, matching the reversed order that was already accepted.

  • allOfMapToForEach: now also detects the data-last form expressed through piping flows, e.g. pipe(values.map(effectful), Effect.all) and pipe(values.map(effectful), Effect.all, Effect.asVoid), which were previously invisible to the call-expression walk. These matches are diagnostic-only: the existing quick fix remains limited to the standalone Effect.all(xs.map(f), options?) call it can safely rewrite.

  • The piping flow parser now keeps the type arguments of parenthesized pipe arguments, e.g. pipe(x, (Effect.as<...>(v))).

  • The piping flow parser now normalizes curried pipeable applications, so Effect.catch(handler)(effect) has effect as its subject, Effect.catch as its callee, and handler as its transformation argument. The normalization is limited to calls whose signatures verify that they are the pipeable counterpart of a data-first overload of the same combinator, leaving unrelated curried APIs such as Effect.fn("name")(body) unchanged.

• db28a74: Add the runOfExitToRunExit diagnostic, which replaces Effect.runPromise applied to Effect.exit with the dedicated Effect.runPromiseExit runner.

Patch Changes

• 348021d: Update TypeScript next to 7.1.0-dev.20260906.1 and adapt diagnostics snapshot cleanup to its new API while preserving compatibility with stable TypeScript.

• 928506b: Update the TypeScript next tag to typescript@next, which ships typescript-go commit 1f70213d4922b434345f639b441681e470c7cfc1, and update the TypeScript latest tag to typescript@latest. Refresh the Oxlint configuration schema from the selected package.

Minor Changes

• 7e30dc9: Add the acquireReleaseDisposable rule to replace manual disposal finalizers passed to Effect.acquireRelease with Effect.acquireDisposable.

• f134c31: Add the optionMatchToFromOption diagnostic and quick fix for Option-to-Effect conversions that can use Effect.fromOption.

  The rule recognizes supported Option.match call styles and Option.isSome / Option.isNone conditional expressions whose branches only wrap the value with Effect.succeed or produce Effect.fail. It suggests the one-argument Effect.fromOption form for the default Cause.NoSuchElementError, and preserves custom failures in a lazy callback.

• 90c884e: Expose piping-flow extraction through the etsgoapi Go API.

  The type parser already understands "piping flows" — a subject expression followed by an ordered list of transformations, unifying the pipe(...), pipeable .pipe(...), data-first, data-last and Effect.fn forms — but that analysis was only reachable from internal packages. etsgoapi.TypeParser now surfaces it so external Go integrations can consume it without importing internal/....

  tp := etsgoapi.NewTypeParser(program, checker)
  for _, flow := range tp.PipingFlows(sourceFile, true /* includeEffectFn */) {
      // flow.Subject.Node / flow.Subject.OutType — the starting expression and its type
      for _, step := range flow.Transformations {
          // step.Kind (pipe | pipeable | dataFirst | dataLast | call | effectFn | effectFnUntraced)
          // step.Callee / step.Args / step.OutType
      }
  }

  Adds the public PipingFlow, PipingFlowSubject, PipingFlowTransformation and TransformationKind types alongside the new (*TypeParser).PipingFlows method.

• 804c2a9: Add the flatMapConditionalToFilterOrFail diagnostic and quick fix, which replaces identity-succeed Effect.flatMap conditionals with Effect.filterOrFail or Effect.filterOrElse.

• 4e14641: Add the preferSucceedSomeOrNone diagnostic and autofix for replacing Effect.succeed(Option.none()) and Effect.succeed(Option.some(value)), including equivalent pipe forms, with Effect.succeedNone and Effect.succeedSome(value).

Patch Changes

• fcc641e: Keep the Nix TypeScript source pin synchronized with the TypeScript next metadata so Nix builds compile generated shims against the matching compiler revision.

• 36f2524: Update the TypeScript next tag to typescript@next, which ships typescript-go commit 9a8581c393a38961489cc8409ae4dfbe97fc25ec, and update the TypeScript latest tag to typescript@latest.

Minor Changes

• 773b245: Add the allOfMapToForEach style diagnostic, which suggests replacing
  Effect.all(values.map(callback), options) with the equivalent
  Effect.forEach(values, callback, options) form.

• fe7a29e: Add the catchAllDieToOrDie style diagnostic, which suggests replacing
  Effect.catch or Effect.catchAll with Effect.orDie when the catch-all
  handler forwards its typed failure unchanged to Effect.die.

• 32c575a: Add the catchConditionalRefailToCatchIf diagnostic for conditional Effect.catch and Effect.catchCause handlers that re-fail their untouched input, suggesting Effect.catchIf, Effect.catchCauseIf, or Effect.catchTag as appropriate.

• 41ec458: Detect the data-first form of effectMapVoid by driving detection off piping flows.

  effectMapVoid previously matched only the data-last / pipeable form of the pattern, so a data-first Effect.map(self, () => {}) was missed. Detection now runs over the piping-flow transformations, which normalize the subject away, so both forms are reported uniformly and the quick fix rewrites each one correctly.

  For example, the data-first call:

  Effect.map(Effect.succeed(1), () => {})

  is now flagged and fixed to:

  Effect.asVoid(Effect.succeed(1))

  while the existing data-last form (pipe(self, Effect.map(() => {}))) continues to be fixed to a bare Effect.asVoid.

• 1ab4380: Improve dual function detection by matching alpha-equivalent data-first and pipeable overload declarations without instantiating their generic signatures.

  For example, data-first calls such as Option.match(value, handlers) now normalize to the same piping-flow representation as value.pipe(Option.match(handlers)), even when the overloads reorder generic parameters or return a generic union.

• 2ae20c4: Refactor the mapSomeToAsSome mapper detection onto the shared UnwrapIdentityForwarder helper. The diagnostic and quick fix now also recognize identity-forwarding function expressions:

  // now triggers, alongside Effect.map(Option.some) and Effect.map((v) => Option.some(v))
  numberEffect.pipe(
    Effect.map(function (value) {
      return Option.some(value)
    })
  )

  Annotated or optional mapper parameters and explicit type arguments on the inner Option.some call still do not trigger, since they can intentionally widen the resulting Option type.

• 2a02aae: Add the mapSomeToAsSome diagnostic and quick fix, which replaces Effect.map(Option.some) and its exact eta-expanded form with Effect.asSome in pipeable and data-first flows.

Patch Changes

• 68a603e: Bound CI Go caches with a resolved cache identity

  repoctl upstream resolve now emits a Go cache identity derived from upstream.json: the typescript component owns and saves its Go caches, oxlint-tsgolint restores the compiler objects already cached by the typescript jobs under its TypeScript dependency version (Go's build cache is content-addressed, so the shared compiler packages hit directly), and the Rust-based oxlint component skips Go caching entirely instead of saving a duplicate GOCACHE snapshot.

  The go-build cache key no longer includes the commit SHA, so a multi-GB cache entry is written once per dependency state instead of on every push to main, and non-materialized setups are restore-only. Previously each push saved ~15GB of duplicate GOCACHE snapshots, evicting every other cache in the repository (GitHub caps repository caches at 10GB) and forcing all validation jobs to run cold.

  The generated shim cache key now also hashes _patches/typescript/**, so patch changes for the migrated TypeScript compiler repository invalidate cached shims correctly.

• e30bbdb: Fix supportedEffect metadata for two rules whose declaration disagreed with their actual behavior:

  • genericEffectServices declared ["v3", "v4"] but is gated to run only on Effect v3 projects. It now declares ["v3"], so v4 users no longer enable a rule that can never fire.

  • schemaSyncInEffect declared ["v3"] but fully supports Effect v4 (suggesting decodeEffect/encodeEffect variants). It now declares ["v3", "v4"].

  metadata.json and the generated rule docs were regenerated accordingly. No diagnostic behavior changed.

• 24cbb0d: Fix repoctl upstream update failing when a TypeScript commit is reachable from both supported provider repositories.

  Previously, resolveTypeScriptProvider and readRemoteTypeScriptGitlink in _tools/repoctl/src/upstream.ts errored out with TypeScript commit <sha> matched 2 supported repositories whenever a single revision existed in both microsoft/TypeScript (the canonical upstream) and the legacy microsoft/typescript-go fork. This blocked the daily "Update Upstreams" workflow for revisions shared between the two.

  Both functions now prefer microsoft/TypeScript when it matches and fall back to microsoft/typescript-go otherwise. A "no supported repository matched" error is still raised when neither matches.

• 7a07115: Update the TypeScript next tag to typescript@next, which ships typescript-go commit 5739027c9a7df24e27123f453a50c011b37717b6, and update the TypeScript latest tag to typescript@latest.

Minor Changes

• afb17ac: Support both the legacy microsoft/typescript-go compiler and the migrated
  microsoft/TypeScript/tsc compiler behind the canonical TypeScript shim
  namespace.

Patch Changes

• a3af171: Build the Nix package from the migrated TypeScript monorepo source and update the pinned compiler revision correctly.

• eba879b: Suppress the unnecessaryPipeChain diagnostic when merging chained pipe calls would exceed the available overload arity.

• 83b8e2a: Update the TypeScript next tag to typescript@next, which ships typescript-go commit e9e477458d7b975ed5e43117fb85f6bc87363a6a, and update the TypeScript latest tag to typescript@latest. Refresh the Oxlint configuration schema from the selected package.

Patch Changes

• 9ddab5d: Report unsupported target package versions with the current @effect/tsgo version and the supported alternatives.

• 922903b: Document the target package versions supported by each published release.

• ca311a5: Exclude type-only heritage nodes from execution flow graphs across supported TypeScript versions.

• 7c54018: Update the TypeScript next tag to typescript@next, which ships typescript-go commit 34ffe2a2531a226da0046d213899ae0b721229b0, and update the TypeScript latest tag to typescript@latest.

Minor Changes

• f25821b: Generate detailed upstream update pull request descriptions with explicit version changes and the TypeScript-Go commits introduced by the update.

Patch Changes

• 3fe06c8: Avoid false positive TS2731 diagnostics for symbol-valued interpolations in tagged template literals when Effect diagnostic rules traverse the template expression.

• 989964b: Prevent preferTypedSchemaDecoder from panicking when a decoder input is produced by a preceding call or pipe transformation.

• 86c30b1: Persist Effect plugin options in TypeScript build information so incremental builds recheck semantic diagnostics when extended tsconfig plugin settings change.

• b8e7314: Update the TypeScript next tag to typescript@next, which ships typescript-go commit 86cc4767d4ebadb9b7845d0ab8eb2b05785c3fee, and update the TypeScript latest tag to typescript@latest.

Minor Changes

• 974513e: Add a non-interactive setup workflow with explicit project, integration, diagnostic, editor, preview, and apply options. Setup now also recommends running the package manager install command whenever it changes package.json.

Patch Changes

• ba4ec9a: Cache generated TypeScript-Go shims by their effective inputs during local repository setup and CI runs.

• 6d0ffda: Remove unused internal helpers and add dead-code analysis to the repository lint workflow.

• 892021a: Use absolute GitHub URLs for links in the published README so documentation links remain clickable on npm.

Minor Changes

• ae0d537: Add the preferTypedSchemaDecoder style suggestion, which recommends typed Schema decoder APIs when an input is assignable to the schema's encoded type.

Patch Changes

• 42534d2: Reuse Go build cache entries across shim generation by preparing package-loading inputs at stable, content-addressed paths.

• cfea036: Update Effect v4 dependencies and embedded test fixtures to 4.0.0-beta.104, update Schema class completions for the Error and TaggedError renames, and suppress auto-imports from blocked Effect internal modules.

• ec0b11f: Update the TypeScript next tag to typescript@next, which ships typescript-go commit 12318e599d21f516defea3b20e5d44b9369da723, and update the TypeScript latest tag to typescript@latest.