[renovate]

This PR contains the following updates:

Package	Change	Age	Confidence
@effect/tsgo (source)	0.53.3 → 0.67.3

---

Release Notes

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

v0.67.3

Compare Source

Patch Changes

• 1477f2e: Fix preferEffectArray, preferEffectRecord, preferEffectString, promiseInEffectSuccess and anyUnknownInErrorContext skipping everything inside a class extends expression. Their walks stop at type nodes, and the extends clause of a class is an ExpressionWithTypeArguments, which counts as one, so the make of a service class was never checked. The walks now visit the expression of a class extends clause; its type arguments, implements clauses and interface extends clauses are still skipped.

  import { Context, Effect } from "effect"
  
  const xs: ReadonlyArray<number> = [1, 2, 3]
  
  export class Doubled extends Context.Service<Doubled, { readonly all: ReadonlyArray<number> }>()("Doubled", {
    make: Effect.gen(function*() {
      // now reported by preferEffectArray
      return { all: xs.map((n) => n * 2) }
    })
  }) {}

  effectFnOpportunity had the same blind spot when checking whether a function declaration is used before it is declared: a call inside an earlier class extends expression was ignored, so it offered to convert a hoisted function into a const that the class would then read before initialization. That opportunity is no longer offered.

  export class Early extends Context.Service<Early, { readonly value: number }>()("Early", {
    make: makeEarly(1) // runs when the class is defined
  }) {}
  
  // no longer suggested as Effect.fn: the const would not be initialized yet
  function makeEarly(n: number) {
    return Effect.gen(function*() {
      return { value: n }
    })
  }

v0.67.1

Compare Source

Patch Changes

• 71b16e4: CI: cap the Go build cache saved by the TypeScript validation and release jobs at 2 GB. The cache had grown to about 3.5 GB compressed per TypeScript version, and jobs that restore it were running out of disk. The new repoctl go-cache trim command keeps the most recently used files of go env GOCACHE up to the size limit and removes the rest:

  repoctl go-cache trim --max-size 2GB

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

v0.67.0

Compare Source

Minor Changes

• 45e777b: Run Oxlint's type-aware rules, including the Effect rules, on tsrs with effect-tsgo --tsrs-lint.

  tsrs 0.21.0 ships its port of tsgolint as tsrs --lint. The Effect-patched tsrs now registers the Effect rules there,
  and --tsrs-lint[=<version|tag>] in front of effect-tsgo oxlint or effect-tsgo vp makes the patched Oxlint run
  them on it instead of the patched tsgolint:

  effect-tsgo --tsrs-lint oxlint --type-aware   # the installed tsrs version when it ships, else the latest
  effect-tsgo --tsrs-lint=latest vp lint        # or a tsrs version or tag

  The packaged tsrs is updated to 0.21.0.

v0.64.1

Compare Source

Patch Changes

• c369721: Fix repoctl spawning npm/pnpm/corepack on Windows after the Effect 4.1.2 update: the .cmd shims now run as a single shell command line, because the spawner no longer accepts shell together with an argument list. This unblocks the win32 release builds.

v0.63.0

Compare Source

Minor Changes

• b961835: Add failCauseToConstructor, a style suggestion for Effect v3 and v4 that rewrites Effect.failCause / Effect.failCauseSync wrapping a single Cause.fail / Cause.die into the direct constructor:

  Effect.failCause(Cause.die(new Error("boom")))   // -> Effect.die(new Error("boom"))
  pipe(error, Cause.fail, Effect.failCause)        // -> Effect.fail(error)
  Effect.failCauseSync(() => Cause.fail(error))    // -> Effect.failSync(() => error)

  Piped spellings are detected through piping flows, and later steps are kept. On v3, a lazy Cause.die becomes Effect.dieSync; v4 has no dieSync, so it is not reported there. Forwarded, stored, composed or transformed causes, explicit failCause<E> type arguments, as assertions and annotated thunks are skipped. Lazy forms written as a pipe(...) subject or with a piped body are reported without a quick fix, as are lazy values whose error type would change once returned from a failSync thunk (such as cond ? "A" : "B", which Cause.fail widens to string) and named-import calls where no value Effect module binding is in scope (type-only imports do not count).

• cbf958c: Add manualMetricTapToTrack, an Effect v4 style suggestion with a quickfix that rewrites Effect.tap / tapError / tapDefect calls which only call Metric.update into Effect.trackSuccesses / trackErrors / trackDefects:

  handleRequest.pipe(
    Effect.tap((size) => Metric.update(responseSize, size)),
    Effect.tapError(() => Metric.update(requestErrors, 1)),
    Effect.tap(Metric.update(rpcSuccesses, 1))
  )
  // becomes
  handleRequest.pipe(
    Effect.trackSuccesses(responseSize),
    Effect.trackErrors(requestErrors, () => 1),
    Effect.trackSuccesses(Metric.withConstantInput(rpcSuccesses, 1))
  )

  Inside callbacks, only metrics that are stable at the call site (earlier const bindings, declare const, enum members) are moved, because track* evaluates the metric once while a tap callback re-evaluates it on every run. A computed input stays inside a mapper so it is still evaluated on every run.

• e75ca43: Add mapMapErrorToMapBoth style diagnostic (default off, Effect v3 and v4) with a quickfix. Adjacent Effect.map + Effect.mapError steps (either order) anywhere in one piping flow are reported: in a pipe/.pipe/Effect.fn pipeline, across chained .pipe(...).pipe(...) calls, and in nested data-first, curried or mixed data-first/pipeable calls. The quickfix merges them into Effect.mapBoth and removes the other step, collapsing a .pipe(...) left without steps to its subject; on v4, Effect.mapEager + Effect.mapErrorEager suggests Effect.mapBothEager. The quickfix is withheld when it cannot keep behavior: a step callee that is not a plain or dotted name (such as getEffect().map), explicit type arguments on any call between and including the two steps (a curried application, a containing or empty pipe/.pipe), no binding in scope that reaches mapBoth, a rewrite that would newly start an expression statement with ( or another token that continues the previous line, or a pair split across calls where merging would move a callback that is not a function literal, or the work of an eager first step, across other code.

  // before
  fetchCount.pipe(
    Effect.map((n) => n > 0),
    Effect.mapError((message) => new TaskError({ message }))
  )
  // also reported: fetchCount.pipe(Effect.map((n) => n > 0)).pipe(Effect.mapError(...))
  // after
  fetchCount.pipe(
    Effect.mapBoth({
      onSuccess: (n) => n > 0,
      onFailure: (message) => new TaskError({ message })
    })
  )

Patch Changes

• a2751c7: catchAllToMapError and catchToOrElseSucceed now name the catch variant the callee resolves to in their message. Previously a named import, renamed import or local alias of Effect.catchAll was reported as Effect.catch:

  import { catchAll } from "effect/Effect"
  
  pipe(program, catchAll((error) => fail(error.length)))
  // before: ... more directly than `Effect.catch` followed by `Effect.fail`
  // after:  ... more directly than `Effect.catchAll` followed by `Effect.fail`

• a2751c7: Quick fixes, refactors and completions now build references to Effect modules (Effect, Layer, Schema, Data, Context, ...) from the file's imports instead of reusing the receiver of the call being rewritten, and support namespace imports of the package barrel.

  import * as X from "effect"
  
  const program = source.pipe(X.Effect.map(() => undefined))
  // effectMapVoid quick fix:
  const program = source.pipe(X.Effect.asVoid)

  When the call site reaches Effect through something other than an import, the fix now uses the import:

  import { Effect } from "effect"
  const E = Effect
  const program = source.pipe(E.map(() => undefined))
  // quick fix now produces Effect.asVoid instead of E.asVoid

• 5ebba91: Perf CI: base and head are now measured on the same runner, and only when a maintainer opts in with the perf label. Builds still run in parallel, one job per channel and side, each with that commit's own tooling. A separate measure job per channel downloads both binaries and runs 9 rounds of stock, base and head compiles in a rotating order. The report's main column is now head vs base directly, flagged by a paired Wilcoxon signed-rank test (p < 0.01), with base and PR overhead over stock tsgo kept as context. repoctl perf ci takes --base-bin/--base-commit/--base-version, --head-bin/--head-commit/--head-version and --rounds instead of --side/--commit/--version/--patched-bin/--pairs, and writes version 2 cells:

  repoctl perf ci --channel latest \
    --base-bin ./tsgo-base --base-commit "$BASE_SHA" --base-version 7.0.2 \
    --head-bin ./tsgo-head --head-commit "$HEAD_SHA" --head-version 7.0.2 \
    --workload-dir /tmp/effect-workload --output perf/latest.json

• 611fae3: Rust port bookkeeping: each origin marker now carries the hash of the Go declaration it was last synced to, so porting/manifest.tsv and porting/ported.tsv, which caused constant merge conflicts, are gone. The repoctl tsrs port-* commands compute the manifest in memory, port-check no longer fails on a stale marker line number, and port-ack writes the hash (and current line) into the markers:

  // go: internal/typeparser/effect_type.go:45 TypeParser.EffectType 8a9c52f8a845e081

• fd5ec0a: preferSchemaOverJson's Effect v4 hint names Schema.fromJsonString(Schema.Unknown) for unknown shapes instead of Schema.UnknownFromJsonString, which effect marks @internal and leaves out of its published types:

  Use `Schema.fromJsonString(Schema.Unknown)` for unknown shapes, `Schema.fromJsonString(schema)` for known ones, or `Schema.toCodecJson(schema)` when working with JSON values instead of strings.
  

• 1b8a25b: Update the TypeScript next tag to typescript@next, which ships TypeScript commit 97aedd3b75e8e18a3cf2786ffbdb2e6c88aea23f, and the Rust port to tsrs@0.20.1-ts7.1.0-beta. Symbol tables are read through per-provider helpers, since TypeScript next replaces the map-based SymbolTable with an insertion-ordered one.

v0.62.0

Compare Source

Minor Changes

• 3e46087: Add mapConstToAs, a style suggestion for Effect v3 and v4 that rewrites Effect.map callbacks which ignore their input and return a constant into Effect.as:

  saveUser("alice").pipe(Effect.map(() => "saved"))
  // becomes
  saveUser("alice").pipe(Effect.as("saved"))

  Literals, negative numbers, enum members, earlier const bindings and declare const values are recognized; object/array literals, let bindings, property reads and computed expressions are not, since Effect.as captures its value once while a map callback re-evaluates it on every run. Callbacks with a return type annotation are also skipped, because the annotation fixes the success type and Effect.as would infer it from the value instead.

  syncToSucceed and flatMapIgnoredParamToAndThen share the same constant detection, so they now also recognize declare const values, negative numeric literals and enum members.

Patch Changes

• 048c91f: Update the TypeScript next tag to typescript@next, which ships typescript-go commit 49e69830214c55a8cc361aa3c4e7412d0afd02fe, update the TypeScript beta tag to typescript@beta, and update the TypeScript latest tag to typescript@latest. Refresh the Oxlint configuration schema from the selected package.

v0.61.0

Compare Source

Minor Changes

• 151678b: Add the flatMapIdentityToFlatten diagnostic (style, suggestion) and quickfix, which replaces Effect.flatMap by Effect.flatten when the callback is one of two forms:

  • Effect's identity export referenced directly (identity, Function.identity, or an import renamed with as). Local variables holding identity are not followed.
  • An arrow function or function expression without type annotations that returns its own parameter, such as (inner) => inner or function(inner) { return inner }.

  Annotated callbacks and aliases of identity are not reported, because an annotation can change the resulting type.

  // before
  loadTask.pipe(Effect.flatMap((inner) => inner))
  Effect.flatMap(loadTask, identity)
  // after
  loadTask.pipe(Effect.flatten)
  Effect.flatten(loadTask)

Patch Changes

• 8b0e3b5: Fix the win32-x64 tsrs release build. Git on the Windows runner checked out tsrs/Cargo.toml with CRLF line endings, so repoctl could not read the [workspace.metadata.typescript] commit and the build failed with No [workspace.metadata.typescript] commit in tsrs/Cargo.toml. The parser now accepts CRLF, and the Windows release jobs check out with core.autocrlf turned off.

v0.59.0

Compare Source

Minor Changes

• 9b9783c: Add proxy commands that run the Effect-patched tsc, tsrs and Oxlint shipped with @effect/tsgo directly, without patching node_modules. This works with shared or read-only package stores such as the pnpm global virtual store, where effect-tsgo patch cannot rewrite the installed binaries. Every argument after the tool is passed through unchanged.

  effect-tsgo tsc -p tsconfig.json         # the build of the installed TypeScript version, else the latest
  effect-tsgo tsc@7.0.2 --lsp --stdio      # a specific supported TypeScript version
  effect-tsgo tsc@next --build             # an upstream tag: latest, beta, next
  effect-tsgo tsrs --noEmit                # the build of the installed tsrs version, else the latest
  effect-tsgo oxlint --type-aware          # the installed oxlint CLI with the patched binding and tsgolint

  The type augmentation that adds the effecttsgo plugin to Oxlint's config types is still applied only by effect-tsgo patch.

Patch Changes

• 9b9783c: Fix the tsrs build reusing stale Effect diagnostics in incremental builds after the plugin options change. The build info now records the Effect options, as the Go build does, and a change to them drops the cached semantic diagnostics. For example, with "incremental": true and an existing .tsbuildinfo, switching "diagnosticSeverity": { "floatingEffect": "off" } to "error" now reports floatingEffect without --force, and switching it back stops reporting it.

• 9b9783c: Match upstream tsrs npm packaging by building release binaries with noembed and shipping the exact .d.ts library files from the pinned tsrs checkout beside each executable. Packaged tsrs binaries now load those files from disk instead of embedded libraries.

• 9b9783c: Update the TypeScript next tag to typescript@next, which ships typescript-go commit 8a62bbe746909624b69b6e671026b454da2f02cf, update the TypeScript beta tag to typescript@beta, and update the TypeScript latest tag to typescript@latest. Refresh the tsconfig schema from JSON Schema Store.

  Bump tsrs to tsrs@0.20.0-ts7.1.0-beta, which ports TypeScript 7.1.0-beta.

v0.57.0

Compare Source

Minor Changes

• 8e4d618: Add experimental support for tsrs, the Rust port of the TypeScript 7 compiler. All Effect diagnostics, quick fixes, refactors and completions are ported to Rust and produce the same output as the Go version.

  effect-tsgo patch --tsrs patches your installed tsrs package, replacing its binary with an Effect-patched build of the same tsrs version. TypeScript patching is unchanged.

  npm install --save-dev tsrs@0.18.0-ts7.1.0-dev.20260929
  npx effect-tsgo patch --tsrs        # patch TypeScript and tsrs
  npx effect-tsgo patch --no-typescript --tsrs   # patch tsrs only
  npx tsrs -p tsconfig.json
  # src/index.ts(4,3): error TS377001: This Effect value is neither yielded nor used in an assignment. effect(floatingEffect)
  npx effect-tsgo unpatch --tsrs      # restore tsrs's original binary

  The patched tsrs binary is available on darwin-arm64, linux-x64 (glibc) and linux-arm64 (glibc). Other platforms, including Linux musl, are skipped with a message explaining why.

v0.56.1

Compare Source

Patch Changes

• 93fc061: Update the TypeScript next tag to typescript@next, which ships typescript-go commit a91e93821feafd081641f9f5d161eba626d0b2ce, update the TypeScript beta tag to typescript@beta, and update the TypeScript latest tag to typescript@latest.

v0.56.0

Compare Source

Minor Changes

• 97d3c56: Track the typescript@beta dist-tag alongside typescript@latest and typescript@next. repoctl upstream update now resolves the beta tag into upstream.json, so the TypeScript beta compiler (currently 7.1.0-beta) is built, tested in CI under the beta channel, and shipped with the platform packages.

Patch Changes

• eb044ca: Update the TypeScript next tag to typescript@next, which ships typescript-go commit 28534d7609062699a68b1b66e2367f8d95dbf290, update the TypeScript beta tag to typescript@beta, and update the TypeScript latest tag to typescript@latest.

v0.55.0

Compare Source

Minor Changes

• d53a707: Add the opt-in preferEffectString diagnostic in effectNative for native String method invocations. It suggests 32 effect/String counterparts, including trimLeft to String.trimStart and trimRight to String.trimEnd.

  Each suggestion explains typing or runtime differences. For example, email.indexOf("@") suggests String.indexOf, which returns Option with None replacing -1.

  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.

v0.54.1

Compare Source

Patch Changes

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

v0.54.0

Compare Source

Minor Changes

• e00f33c: Add the schemaClassObjectLiteral diagnostic. It warns when an object literal is checked as a Schema class instance. A plain object has no class prototype, so instanceof, class methods, and Schema encoding fail at runtime. A Schema brand does not help, because a spread copies the brand property.

  class User extends Schema.Class<User, { readonly brand: unique symbol }>("User")({ name: Schema.String }) {}
  
  const copy: User = { ...user } // warning: build it with User.make({ ...user })
  const renamed = User.make({ ...user, name: "b" }) // ok

  In Effect v4, the rule skips objects nested inside a Schema constructor call, such as Parent.make({ child: { ...child } }), because v4 builds the nested class instance from the plain object.

v0.53.5

Compare Source

Patch Changes

• c83ee4d: runEffectInsideEffect now reports Effect.runSyncExit and Effect.runPromiseExit, the same as Effect.runSync and Effect.runPromise. The quick fix rewrites them to Effect.runSyncExitWith and Effect.runPromiseExitWith in Effect v4, and to Runtime.runSyncExit and Runtime.runPromiseExit in Effect v3.

  export const nested = Effect.gen(function*() {
    yield* Effect.void
    setTimeout(() => {
      Effect.runPromiseExit(child)
      // ^- `Effect.runPromiseExit` is called inside an Effect with a separate services invocation.
    }, 0)
  })

• de42db0: Update the TypeScript next tag to typescript@next, which ships typescript-go commit 5237fd46890956e4bb8177a1a05dcd69e4166560, and update the TypeScript latest tag to typescript@latest.

v0.53.4

Compare Source

Patch Changes

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

---

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.