Update dependency @effect/tsgo to v0.44.0

[renovate]

This PR contains the following updates:

Package	Change	Age	Adoption	Passing	Confidence
@effect/tsgo (source)	0.36.1 → 0.44.0

---

Warning

Some dependencies could not be looked up. Check the warning logs for more information.

---

Release Notes

Effect-TS/tsgo (@​effect/tsgo)

v0.44.0

Compare Source

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.

v0.43.0

Compare Source

Minor Changes

• 956b8d6: Extend nodeBuiltinImport to recommend Effect-native alternatives for console, timers, timers/promises, stream, stream/promises, and stream/web, including their node: forms.

  For Effect v4, also flag crypto and node:crypto imports and recommend Crypto from effect. For example, import { randomUUID } from "node:crypto" is now diagnosed; use the Crypto service's randomUUIDv4 effect instead. Effect v3 crypto imports remain allowed because that version has no corresponding Crypto service.

  Correct the Effect v4 child_process recommendation to point to effect/unstable/process. The rule remains disabled by default; configure nodeBuiltinImport with error severity to prohibit covered imports.

v0.42.0

Compare Source

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.

v0.41.0

Compare Source

Minor Changes

• d095234: Normalize piping-flow transformations around their callee, arguments, and explicit type arguments without exposing a representation-dependent transformation node. Add shared rewriter operations for replacing transformations and flow prefixes while preserving data-first, data-last, pipe(...), and .pipe(...) source forms.
• d3efa70: Remove the AST location parameter from type-only TypeParser operations. Effect, Layer, Stream, Schema, service, Context.Tag, Scope, and related type predicates now derive instantiated property types directly from the supplied checker type.

Patch Changes

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

v0.40.0

Compare Source

Minor Changes

• 815273c: Add the Effect v4 raceFirstWithSleepToTimeout style diagnostic, which suggests Effect.timeoutOrElse when a first-completion race has exactly one Effect.sleep- or Effect.delay-based timer arm.

  Reclassify acquireReleaseDisposable as style and unsafeEffectTypeAssertion as correctness.

Patch Changes

• c1ac8e5: Avoid reporting the schemaNumber diagnostic when Schema.Number is refined with the built-in isFinite or isInt checks, including pipe-style refinements.
• 0fba9d1: Update the TypeScript next tag to typescript@next, which ships typescript-go commit 43a90f4c105bc9db7cb7aa299beddafbabe1d23e, and update the TypeScript latest tag to typescript@latest.

v0.39.1

Compare Source

Patch Changes

• c2e4353: Update the TypeScript next tag to 7.1.0-dev.20260901.1, update Oxlint to 1.81.0, and refresh the generated configuration schemas. Support SchemaStore's draft-07 nullable schema representation when injecting the Effect language-service plugin schema.

v0.39.0

Compare Source

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.

v0.38.0

Compare Source

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.

v0.37.0

Compare Source

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.

v0.36.5

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.

v0.36.4

Patch Changes

• 7a616ec: Allow declaration emit with noEmitOnError when all diagnostics are ignored Effect diagnostics.

v0.36.3

Patch Changes

• 73f7f28: Refresh patched binaries when an updated @effect/tsgo package provides a different replacement artifact.
• 9190801: Update Effect v4 dependencies and embedded test fixtures to 4.0.0-beta.107.

v0.36.2

Compare Source

Patch Changes

• 8362acc: Extend the walker-rule prefilter to call expressions.

  A call expression's type is its resolved signature's return type, and both the signature and that return type are already cached from the main check phase. NodeCouldBeStrictEffect now consults them for call nodes and skips the expensive flow-analysis re-check when the declared return type conclusively cannot be a strict Effect. Signature-less calls, optional chains, and every inconclusive return type stay conservative, and promiseInEffectSuccess no longer computes a location type for calls only to discard it. Emitted diagnostics are unchanged; on a large Effect monorepo build this removes a further ~4.6% of wall time on top of the reference-node prefilter, bringing the total Effect diagnostics overhead versus a pristine tsgo build of the same commit down to ~17%.

• 9020153: Skip diagnostic rules below the minimum visible severity before executing them.

  In tsc CLI mode without includeSuggestionsInTsc, suggestion- and message-severity diagnostics are dropped from the output after rules run. The rule runner now receives the minimum severity the caller can surface and skips such rules up front, avoiding their type-checker queries entirely. A rule below the threshold still runs when any directive in the file references it (for example // @effect-diagnostics ruleName:error or a wildcard), since directives can raise its severity and must be tracked for unusedDirective reporting. Emitted diagnostics are unchanged; on a large Effect monorepo build this removes roughly 1–2s of check time.

• 257af25: Skip flow-analysis type queries for references that conclusively cannot be an Effect.

  The effectInFailure and promiseInEffectSuccess rules walk every node of a file and query its flow type just to test whether it is a strict Effect type. The new TypeParser.NodeCouldBeStrictEffect prefilter inspects the referenced symbol's declared type first — flow narrowing can only refine the declared type, so a declared type that conclusively contains no possibly-Effect constituent (primitives, plain objects with a different type name, unions thereof) can never produce a strict Effect flow type, and the expensive query is skipped. The predicate is conservative: any/unknown, type parameters, conditionals, symbol-less types, and deep unions always fall through to the full query. Emitted diagnostics are unchanged; on a large Effect monorepo build this removes ~10% of build wall time (~2.7s of ~26.8s).

---

Configuration

📅 Schedule: (UTC)

• Branch creation
  • At any time (no schedule defined)
• Automerge
  • At any time (no schedule defined)

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

---

• If you want to rebase/retry this PR, check this box

---

This PR was generated by Mend Renovate. View the repository job log.